小编Ove*_*gon的帖子

假设我有一个整数序列：

0,1,2, ..

并希望根据给定的最后3个整数来预测下一个整数，例如：

[0,1,2]->5，[3,4,5]->6等

假设我像这样设置模型：

batch_size=1
time_steps=3
model = Sequential()
model.add(LSTM(4, batch_input_shape=(batch_size, time_steps, 1), stateful=True))
model.add(Dense(1))

据我了解，模型具有以下结构（请原图）：

第一个问题：我的理解正确吗？

请注意，我已经画出了C_{t-1}, h_{t-1}进入图片的先前状态，因为指定时会暴露出来stateful=True。在这个简单的“下一个整数预测”问题中，应通过提供此额外的信息来改善性能（只要先前的状态是由前三个整数产生的）。

这使我想到了一个主要问题： 似乎标准做法（例如，参见此博客文章和TimeseriesGenerator keras预处理实用程序）是在训练过程中向模型提供一组交错的输入。

例如：

batch0: [[0, 1, 2]]
batch1: [[1, 2, 3]]
batch2: [[2, 3, 4]]
etc

这让我感到困惑，因为这似乎需要第一Lstm单元的输出（对应于第一时间步长）。看这个图：

从tensorflow docs：

stateful：布尔值（默认为False）。如果为True，则批次中索引i的每个样本的最后状态将用作下一个批次中索引i的样本的初始状态。

似乎此“内部”状态不可用，并且所有可用状态都是最终状态。看这个图：

因此，如果我的理解是正确的（显然不是这样），那么在使用时是否不应该将不重叠的样本窗口馈送到模型中stateful=True？例如：

batch0: [[0, 1, 2]]
batch1: [[3, 4, 5]]
batch2: [[6, 7, 8]]
etc

我是Keras（以及ML）的新手，并且正在尝试训练二进制分类器。我正在使用加权二进制交叉熵作为损失函数，但不确定如何测试实现是否正确。

这是加权二进制交叉熵的准确实现吗？我该如何测试呢？

def weighted_binary_crossentropy(self, y_true, y_pred):
    logloss = -(y_true * K.log(y_pred) * self.weights[0] + \
               (1 - y_true) * K.log(1 - y_pred) * self.weights[1])

    return K.mean(logloss, axis=-1)

我在本地编辑了 Keras.optimizer和.layers模块，但 Colab 使用自己的 Keras 和 TensorFlow 库。上传然后使用编辑过的库会涉及到每个路径和包交互，并且对于一些小的编辑来说是一种矫枉过正。

我最接近访问模块的是keras.optimizers.__file__，它给出了一个我不知道该怎么做的相对路径：'/usr/local/lib/python3.6/dist-packages/keras/optimizers.py'

可以编辑 Colab 库吗？永久（不是每个运行时）？

我是 Keras、Tensorflow、Python 的新手，我正在尝试构建一个供个人使用/未来学习的模型。我刚开始使用 python，我想出了这段代码（在视频和教程的帮助下）。我的问题是，我对 Python 的内存使用量随着每个 epoch 甚至在构建新模型之后慢慢增加。一旦内存达到 100%，训练就会停止，没有错误/警告。我不太了解，但问题应该在循环内的某个地方（如果我没记错的话）。我知道

k.clear.session()

但问题要么没有被删除，要么我不知道如何将它集成到我的代码中。我有：Python v 3.6.4、Tensorflow 2.0.0rc1（cpu 版本）、Keras 2.3.0

这是我的代码：

import pandas as pd
import os
import time
import tensorflow as tf
import numpy as np
import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, LSTM, BatchNormalization
from tensorflow.keras.callbacks import TensorBoard, ModelCheckpoint

EPOCHS = 25
BATCH_SIZE = 32           

df = pd.read_csv("EntryData.csv", names=['1SH5', '1SHA', '1SA5', '1SAA', '1WH5', '1WHA',
                                         '2SA5', '2SAA', '2SH5', '2SHA', '2WA5', '2WAA',
                                         '3R1', '3R2', '3R3', '3R4', '3R5', '3R6',
                                         'Target'])

df_val …

TF1 有sess.run()和.eval()获取张量的值 - 而 Keras 有K.get_value()；现在，两者的工作方式都不一样（根本没有前两个）。

K.eager(K.get_value)(tensor)似乎通过退出在 Keras 图内部和K.get_value(tensor)图外部工作 - 都急切地使用 TF2 的默认值（在前者中是关闭的）。但是，如果tensor是Keras 后端操作，则会失败：

import keras.backend as K
def tensor_info(x):
    print(x)
    print("Type: %s" % type(x))
    try:        
        x_value = K.get_value(x)
    except:
        try:    x_value = K.eager(K.get_value)(x)
        except: x_value = x.numpy()
    print("Value: %s" % x_value)  # three methods

ones = K.ones(1)
ones_sqrt = K.sqrt(ones)

tensor_info(ones); print()
tensor_info(ones_sqrt)

<tf.Variable 'Variable:0' shape=(1,) dtype=float32, numpy=array([1.], dtype=float32)>
Type: <class 'tensorflow.python.ops.resource_variable_ops.ResourceVariable'>
Value: [1.] …

我遇到过研究出版物和问答讨论需要检查每个反向传播时间 (BPTT) 的 RNN 梯度 - 即每个时间步长的梯度。主要用途是自省：我们如何知道 RNN 是否正在学习长期依赖？一个自己主题的问题，但最重要的见解是梯度流：

• 如果一个非零梯度流经每个时间步，那么每个时间步都有助于学习——即，结果梯度源于对每个输入时间步的考虑，因此整个序列会影响权重更新
• 如上所述，RNN不再忽略长序列的一部分，而是被迫向它们学习

...但是我如何在 Keras / TensorFlow 中实际可视化这些梯度？一些相关的答案是在正确的方向上，但它们似乎对双向 RNN 失败了，并且只展示了如何获得层的梯度，而不是如何有意义地可视化它们（输出是一个 3D 张量 - 我该如何绘制它？）

假设我有一个这样的模型（这是一个用于时间序列预测的模型）：

ipt   = Input((data.shape[1] ,data.shape[2])) # 1
x     = Conv1D(filters = 10, kernel_size = 3, padding = 'causal', activation = 'relu')(ipt) # 2
x     = LSTM(15, return_sequences = False)(x) # 3
x = BatchNormalization()(x) # 4
out   = Dense(1, activation = 'relu')(x) # 5

现在我想向这个网络添加批量标准化层。考虑到批量标准化不适用于 LSTM，我可以在Conv1D层之前添加它吗？我认为在LSTM.

另外，我在哪里可以在这个网络中添加 Dropout？一样的地方？（在批量标准化之后还是之前？）

• AveragePooling1D在Conv1D和之间添加怎么样LSTM？在这种情况下，是否可以在层之间Conv1D和之间添加批量标准化AveragePooling1D而不对LSTM层产生任何影响？

我认为 Adam 优化器的设计是为了自动调整学习率。但是在 Keras 中的 Adam 参数选项中有一个选项可以明确提及衰减。我想澄清衰减对 Keras 中 Adam 优化器的影响。如果我们在 lr = 0.001 上使用衰减说 0.01 来编译模型，然后拟合运行 50 个 epoch 的模型，那么在每个 epoch 之后学习率是否会降低 0.01 倍？

有什么方法可以指定学习率只有在运行一定数量的 epoch 后才衰减？

在 pytorch 中有一个名为 AdamW 的不同实现，它在标准 keras 库中不存在。这与如上所述在每个时期之后改变衰减相同吗？

预先感谢您的回复。

这是一个回归问题

我的自定义 RMSE 损失：

def root_mean_squared_error_loss(y_true, y_pred):
    return tf.keras.backend.sqrt(tf.keras.losses.MSE(y_true, y_pred))

训练代码示例，其中 create_model 返回一个密集的全连接序列模型

from tensorflow.keras.metrics import RootMeanSquaredError
model = create_model()
model.compile(loss=root_mean_squared_error_loss, optimizer='adam', metrics=[RootMeanSquaredError()])

model.fit(train_.values,
          targets,
          validation_split=0.1,
          verbose=1,
          batch_size=32)

Train on 3478 samples, validate on 387 samples
Epoch 1/100
3478/3478 [==============================] - 2s 544us/sample - loss: 1.1983 - root_mean_squared_error: 0.7294 - val_loss: 0.7372 - val_root_mean_squared_error: 0.1274
Epoch 2/100
3478/3478 [==============================] - 1s 199us/sample - loss: 0.8371 - root_mean_squared_error: 0.3337 - val_loss: 0.7090 - val_root_mean_squared_error: 0.1288
Epoch 3/100
3478/3478 [==============================] - 1s …

N, M = 1000, 4000000
a = np.random.uniform(0, 1, (N, M))
k = np.random.randint(0, N, (N, M))

out = np.zeros((N, M))
for i in range(N):
    for j in range(M):
        out[k[i, j], j] += a[i, j]

我使用很长的 for 循环；%%timeit在上面pass替换操作产量

1min 19s ± 663 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

这在上下文中是不可接受的（C++ 耗时 6.5 秒）。没有理由使用 Python 对象完成上述操作；数组具有明确定义的类型。在 C/C++ 中实现它作为扩展对开发人员和用户端来说都是一种矫枉过正；我只是将数组传递给循环并进行算术运算。

有没有办法告诉 Numpy“将此逻辑移至 C”，或其他可以处理仅涉及数组的嵌套循环的库？我在一般情况下寻求它，而不是针对这个特定示例的解决方法（但如果你有一个，我可以打开一个单独的问答）。