Question

在训练期间，我无法理解为什么跟随模型的权重越来越小，直到NaN。

该模型如下：

def initialize_embedding_matrix(embedding_matrix):
    embedding_layer = Embedding(
        input_dim=embedding_matrix.shape[0],
        output_dim=embedding_matrix.shape[1],
        weights=[embedding_matrix],
        trainable=True)
    return embedding_layer

def get_divisor(x):
    return K.sqrt(K.sum(K.square(x), axis=-1))


def similarity(a, b):
    numerator = K.sum(a * b, axis=-1)
    denominator = get_divisor(a) * get_divisor(b)
    denominator = K.maximum(denominator, K.epsilon())
    return numerator / denominator


def max_margin_loss(positive, negative):
    loss_matrix = K.maximum(0.0, 1.0 + negative - Reshape((1,))(positive))
    loss = K.sum(loss_matrix, axis=-1, keepdims=True)
    return loss


def warp_loss(X):
    z, positive_entity, negatives_entities = X
    positiveSim = Lambda(lambda x: similarity(x[0], x[1]), output_shape=(1,), name="positive_sim")([z, positive_entity])
    z_reshaped = Reshape((1, z.shape[1].value))(z)
    negativeSim = Lambda(lambda x: similarity(x[0], x[1]), output_shape=(negatives_titles.shape[1].value, 1,), name="negative_sim")([z_reshaped, negatives_entities])
    loss = Lambda(lambda x: max_margin_loss(x[0], x[1]), output_shape=(1,), name="max_margin")([positiveSim, negativeSim])
    return loss

def mean_loss(y_true, y_pred):
    return K.mean(y_pred - 0 * y_true)

def build_nn_model():
    wl, tl = load_vector_lookups()
    embedded_layer_1 = initialize_embedding_matrix(wl)
    embedded_layer_2 = initialize_embedding_matrix(tl)

    sequence_input_1 = Input(shape=(_NUMBER_OF_LENGTH,), dtype='int32',name="text")
    sequence_input_positive = Input(shape=(1,), dtype='int32', name="positive")
    sequence_input_negatives = Input(shape=(10,), dtype='int32', name="negatives")

    embedded_sequences_1 = embedded_layer_1(sequence_input_1)
    embedded_sequences_positive = Reshape((tl.shape[1],))(embedded_layer_2(sequence_input_positive))
    embedded_sequences_negatives = embedded_layer_2(sequence_input_negatives)

    conv_step1 = Convolution1D(
        filters=1000,
        kernel_size=5,
        activation="tanh",
        name="conv_layer_mp",
        padding="valid")(embedded_sequences_1)

    conv_step2 = GlobalMaxPooling1D(name="max_pool_mp")(conv_step1)
    conv_step3 = Activation("tanh")(conv_step2)
    conv_step4 = Dropout(0.2, name="dropout_mp")(conv_step3)
    z = Dense(wl.shape[1], name="predicted_vec")(conv_step4) # activation="linear"

    loss = warp_loss([z, embedded_sequences_positive, embedded_sequences_negatives])
    model = Model(
        inputs=[sequence_input_1, sequence_input_positive, sequence_input_negatives],
        outputs=[loss]
        )
    model.compile(loss=mean_loss, optimizer=Adam())
    return model

model = build_nn_model()
x, y_real, y_fake = load_x_y()
    X_train = {
    'text': x_train,
    'positive': y_real_train,
    'negatives': y_fake_train
}

model.fit(x=X_train,  y=np.ones(len(x_train)), batch_size=10, shuffle=True, validation_split=0.1, epochs=10)

稍微描述一下模型：

我有两个预先训练好的嵌入（wl，tl），并使用这些值初始化Keras嵌入。
有3个输入。 sequence_input_1将整数作为输入（单词索引。例如[42, 32 .., 4]）。在他们sequence.pad_sequences(X, maxlen=_NUMBER_OF_LENGTH)上使用固定长度。 sequence_input_positive是正输出的整数，sequence_input_negatives是每个示例的N个随机负输出（在上面的代码中为10）。
max_margin_loss衡量cosinus_similarity(positive_example, sequence_input_1)和cosinus_similarity(negative_example[i], sequence_input_1)之间的差异，并使用Adam优化程序将损失降至最低。

即使仅使用20个数据点训练此模型，Convolution1D和Dense中的权重也会转到NaN。如果我添加更多数据点，嵌入权重也会转到NaN。我可以观察到，随着模型运行，权重越来越小，直到它们进入NaN。值得注意的是，损失不会归于NaN。当权重达到NaN时，损失将变为零。

我无法找到出错的地方。

这是我到现在为止所尝试的：

我已经看到，当使用铰链损耗时，人们正在使用随机梯度下降。使用SGD优化器并未改变此处的行为。
更改了批量大小。行为没有变化。
检查输入数据没有nan值。
对输入矩阵（预训练数据）进行归一化以嵌入np.linalg.norm
将预训练矩阵从float64转换为float32

您是否在模型架构中看到任何奇怪的内容？如果不是：我无法找到调试架构的方法，以便了解为什么权重越来越小，直到达到NaN。当人们注意到这种行为时，他们正在使用一些步骤吗？

修改：

在嵌入中使用trainable=False时，未观察到nan权重的这种行为，并且培训似乎有平滑的结果。但是我希望嵌入能够训练。那么为什么这种行为在嵌入时是可训练的？

EDIT2 ：

使用trainable=True并通过统一随机初始化权重embeddings_initializer='uniform'，培训顺利进行。所以发生的原因是我的单词嵌入。我检查了我预先训练过的单词嵌入，但没有NaN个值。我也将它们标准化，以防它导致但不缺。不知道为什么这些特定的权重给出了这种行为。

EDIT3 ：

似乎造成这种情况的原因是来自其中一个Embeddings的很多行都在gensim中训练，其中全部为零。离。

[0.2, 0.1, .. 0.3],
[0.0, 0.0, .. 0.0],
[0.0, 0.0, .. 0.0],
[0.0, 0.0, .. 0.0],
[0.2, 0.1, .. 0.1]

要想把它作为嵌入的维度真的很大就不那么容易了。

我打开这个问题以防万一有人提出类似的问题或者想回答上面提到的问题：＆＃34;人们在注意到这种行为时是否会采取一些措施？＆＃34; < / p>

Answer 1

根据您的编辑，它更容易找到问题。

这些零未更改地传递给warp_loss函数。经过卷积的部分最初保持不变，因为任何滤波器乘以零都会导致零，并且默认偏差初始化器也是'zeros'。同样的想法适用于密集（过滤器* 0 = 0和偏差初始化器='零'）

到达此行：return numerator / denominator并导致错误（除以零）

我在许多代码中看到的常见做法是添加K.epsilon()以避免这种情况：

return numerator / (denominator + K.epsilon())

NaN

1 个答案: