小编Sci*_*tas的帖子

我正在尝试构建一个LSTM自动编码器,目的是从序列中获取一个固定大小的矢量,这表示序列尽可能好.该自动编码器由两部分组成:

• LSTM编码器:获取序列并返回输出向量(return_sequences = False)
• LSTM解码器:获取输出向量并返回序列(return_sequences = True)

因此,最后,编码器是多对一 LSTM,解码器是一对多 LSTM.

图片来源:Andrej Karpathy

在较高的层次上,编码看起来像这样(类似于这里描述的):

encoder = Model(...)
decoder = Model(...)

autoencoder = Model(encoder.inputs, decoder(encoder(encoder.inputs)))

autoencoder.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

autoencoder.fit(data, data,
          batch_size=100,
          epochs=1500)

data数组的形状(训练样本数,序列长度,输入维数)(1200, 10, 5)如下所示:

array([[[1, 0, 0, 0, 0],
        [0, 1, 0, 0, 0],
        [0, 0, 1, 0, 0],
        ..., 
        [0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0]],
        ... ] …

有人可以解释所有这些交叉熵损失之间的差异吗？keras正在谈论

• 二进制交叉熵
• 分类交叉熵
• 稀疏分类交叉熵

而tensorflow有

• 具有Logits的Softmax交叉熵
• 具有Logits的稀疏Softmax交叉熵
• Sigmoid交叉熵与Logits

(还提出了一个问题:是否有没有logits的交叉熵类型？)

他们之间有什么不同和关系？它们的典型应用是什么？数学背景是什么？是否应该知道其他交叉熵类型？

在我的情况下，我有两个不同的功能集（因此，行数相同且标签相同）DataFrames：

df1：

| A | B | C |
-------------
| 1 | 4 | 2 |
| 1 | 4 | 8 |
| 2 | 1 | 1 |
| 2 | 3 | 0 |
| 3 | 2 | 5 |

df2：

| E | F |
---------
| 6 | 1 |
| 1 | 3 |
| 8 | 1 |
| 2 | 8 |
| 5 | 2 …

我有一个名为的列表list_of_strings，如下所示：

['a', 'b', 'c', 'a', 'd', 'c', 'e']

我想按一个值（在本例中为c）拆分此列表。我也想保留c由此产生的分裂。

所以预期的结果是：

[['a', 'b', 'c'], ['a', 'd', 'c'], ['e']]]

有什么简单的方法可以做到这一点？

分组和计数后,我试图删除这样的多索引:

df = df[['CID','FE', 'FID']].groupby(by=['CID','FE']).count()
              .unstack().reset_index()

打印列(df.colums)表明它仍然是MultiIndex.

MultiIndex(levels=[['FID', 'CID'], [...]]

我不能访问列CID通过df['CID']

考虑：

text = "abcdef"
pattern = "(b|e)cd(b|e)"

repl = [r"\1bla\2", r"\1blabla\2"]
text = re.sub(pattern, lambda m: random.choice(repl), text)

我想用列表的条目随机替换匹配项repl。但是，当使用lambda m: random.choice(repl)作为一个回调，它不会取代\1，\2其捕获更多的等等，返回"\1bla\2"为纯文本。

我试图查找re.py以了解他们如何在内部执行此操作，因此我可能能够调用相同的内部函数，但这似乎并不简单。

上面的示例返回a\1bla\2f或a\1blabla\2fwhileabblaef或abblablaef在我的情况下是有效的选项。

请注意，我使用的是一个函数，因为在有多个匹配项的情况下，例如text = "abcdef abcdef"，它应该repl为每个匹配项随机选择一个替换项- 而不是对所有匹配项使用相同的替换项。

我正在尝试并行GridSearchCV化scikit-learn. 它在一个jupyter (hub) notebook环境中运行。经过一番研究，我发现了这段代码：

from sklearn.externals.joblib import Parallel, parallel_backend, register_parallel_backend
from ipyparallel import Client
from ipyparallel.joblib import IPythonParallelBackend

c = Client(profile='myprofile')
print(c.ids)
bview = c.load_balanced_view()

register_parallel_backend('ipyparallel', lambda : IPythonParallelBackend(view=bview))

grid = GridSearchCV(pipeline, cv=3, n_jobs=4, param_grid=param_grid)

with parallel_backend('ipyparallel'):
    grid.fit(X_train, Y_train)

请注意，我已将n_jobs参数设置为4，机器的 cpu 核心数是多少。（这就是nproc返回的结果）

但它似乎不起作用：ImportError: cannot import name 'register_parallel_backend'，尽管我安装了 joblibconda install joblib并且也尝试过pip install -U joblib。

那么，在这种环境中并行化的最佳方法是什么GridSearchCV？

更新：

不带参数ipyparallel且仅设置n_jobs参数： …

我有一个df1看起来像这样的DataFrame :

A       B       C
-----------------
1       1       2
2       2       3
5       4       9

我希望连续获得所有唯一值.例如,第一行中的示例1和2.2,3排在第二排.第三排是4,5和9.

结果可能会有所不同,我可以想象一个包含具有唯一值的列表或替换重复项的新列None也可以(或者其他东西,可能在这种情况下有更多的pythonic).

我想创建一个 L2 损失函数，它忽略标签值为 0 的值（=> 像素）。张量batch[1]包含标签，output而是净输出的张量，两者的形状均为(None,300,300,1).

labels_mask = tf.identity(batch[1])
labels_mask[labels_mask > 0] = 1
loss = tf.reduce_sum(tf.square((output-batch[1])*labels_mask))/tf.reduce_sum(labels_mask)

我当前的代码屈服于TypeError: 'Tensor' object does not support item assignment（在第二行）。什么是张量流方式来做到这一点？我还尝试将损失归一化为tf.reduce_sum(labels_mask)，我希望它像这样工作。

我正在设置我的情节的宽度和高度

fig.update_layout(width=500, height=500)

不幸的是，这会产生不同大小的图，具体取决于标签的宽度，如下所示。

但是，我没有找到一种方法来生成相同大小的图。

fig.add_trace(go.Scatter(...))

既add_trace不允许也go.Scatter不允许设置宽度。有没有办法让我俯瞰？

MV：

    fig = go.Figure()
    fig.update_layout(width=500, height=500)
    for i, data in enumerate(data_list):
        fig.add_trace(go.Scatter(x=data['x'], y=data['y'], name='some_label'))