0

情境化
我正在构建一个用于多标签分类的神经网络：识别图像中的标签（一个人穿着什么衣服，它的颜色等）。我想使用纯 tensorflow（而不是 kears 之类的 API），以便对我的指标有更大的灵活性。
PS：用于这个 tensorflow 模型的数据是用 Keras 构建的模型测试的，并没有产生我将在这里公开的问题。

数据
我的输入数据是 (X,Y)：X 的形状为 (1814,204,204,3)，Y 的形状为 (1814,39)。所以基本上 X 是一组图像，Y 是与每个图像相关联的标签，这些标签将用于监督学习过程。
总共有 39 个标签，因此对于每个大小为 (1,204,204,3) 的图像，我们关联一个形状为 (1,39) 的向量：这 39 个值可以是 0 或 1。1，如果在该图像中识别出相应的标签, 否则。可以同时识别多个标签，这意味着我们没有使用一种热编码，也不是多类分类的情况！
PS：我已经对我的数据进行了标准化以便适合 [0,1]

我做了什么
1.我做 的第一件事是构建我的分类器的抽象版本（这是一个 CNN）：这是我的 CNN 的结构：

# Convolutional Layer 1
# Dropout layer 1
# Convolutional Layer 2
# Pooling Layer 2
# Dense layer 3  
# Dropout layer 3   
# Dense layer 4

对于给定大小的数据集 (?,204,204,3)：这是通过不同层的数据流： 

conv1 OUTPUT shape:  (?, 204, 204, 32)  
drop1 OUTPUT shape:  (?, 204, 204, 32)  
conv2 OUTPUT shape:  (?, 204, 204, 32)  
pool2 OUTPUT shape:  (?, 102, 102, 32)  
dense3 OUTPUT shape:  (?, 512)  
drop3 OUTPUT shape:  (?, 512)  
dense4 OUTPUT shape:  (?, 39)

这是构建CNN结构的代码 

   def create_model(X,Y):
        # Convolutional Layer #1
        conv1 = tf.layers.conv2d(
          inputs=X,
          filters=32,
          kernel_size=[3, 3],
          padding="same",
          activation=tf.nn.relu)
        print('conv1 OUTPUT shape: ',conv1.shape)

        # Dropout layer #1
        dropout1 = tf.layers.dropout(
          inputs=conv1, rate=0.2, training='TRAIN' == tf.estimator.ModeKeys.TRAIN)
        print('drop1 OUTPUT shape: ',dropout1.shape)

        # Convolutional Layer #2
        conv2 = tf.layers.conv2d(
          inputs=dropout1,
          filters=32,
          kernel_size=[3, 3],
          padding="same",
          activation=tf.nn.relu)
        print('conv2 OUTPUT shape: ',conv2.shape)

        # Pooling Layer #2
        pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2],strides=2)
        print('pool2 OUTPUT shape: ',pool2.shape)
        pool2_flat = tf.reshape(pool2, [-1, pool2.shape[1]*pool2.shape[2]*pool2.shape[3]])

        # Dense layer #3
        dense3 = tf.layers.dense(inputs=pool2_flat, units=512, activation=tf.nn.relu)
        print('dense3 OUTPUT shape: ',dense3.shape)

        # Dropout layer #3
        dropout3 = tf.layers.dropout(
          inputs=dense3, rate=0.5, training='TRAIN' == tf.estimator.ModeKeys.TRAIN)
        print('drop3 OUTPUT shape: ',dropout3.shape)

        # Dense layer #4
        Z = tf.layers.dense(inputs=dropout3, units=39, activation=tf.nn.sigmoid)
        print('dense4 OUTPUT shape: ',Z.shape)

        return Z

2. 现在，我正在定义我的成本函数和我的优化器。

  • 对于成本函数，我使用cross_entropy_with_logits 并独立计算批量样本上所有输出分量的平均值。例如，如果我有一个大小为 10 的批次，模型的输出形状为 (10,39)，因此对于成本，我们将有一个形状为 (1,39) 的向量（对于每个标签，我们计算平均值批次中的不同示例）
  • 对于优化器，我使用的是亚当优化器。

这是计算成本和优化器的代码。 

def optimizer_and_cost(output,labels):
    # Calculating cost
    cost= tf.reduce_mean(labels * - tf.log(output) + (1 - labels) * - tf.log(1 - output),axis=0)
    print('cost: shape of cost: ',cost.shape)
    cost= tf.reshape(cost, [1, 39])
    print('cost reshaped: shape of cost reshaped: ',cost.shape)

    #Optimizer
    optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)
    return optimizer,cost

PS：tf.reduce_mean 中的 'axis=0' 允许我独立计算每个标签，即批次示例的平均值！

3. 定义占位符，初始化模型和训练。
一旦定义了具有不同参数的抽象模型，我创建了占位符并构建了计算图，然后我初始化了权重并开始了训练。 问题： 随着优化的进行，我开始为不同层中的权重和成本函数中的 NaN 设置 NaN 值。因此，Reflexe 首先尝试调试并了解会发生什么。
我尝试测试一个简单的案例，如下所示：
初始化权重--->计算成本并打印它（也打印权重）--->做一个优化--->计算成本并打印它（也打印权重）。
结果：
第一次打印很好我有真正的价值（很明显）。但是在第一次优化之后：我得到了成本的 NaNs 值。为什么我的优化器在一个优化步骤后使成本变为 NaN ！
这是测试的代码！（X_train 和 Y_train 的形状为 (1269, 204, 204, 3) 和 (1269,39) ：我只取每个元素的 4 个元素进行测试）

#clearing the graph
ops.reset_default_graph()

#defining placeholders
X = tf.placeholder(tf.float32, [None, X_train.shape[1],X_train.shape[2],X_train.shape[3]])
Y = tf.placeholder(tf.float32, [None, Y_train.shape[1]])
optimizer, cost=optimizer_and_cost(create_model(X,Y),Y)

# Initialize all the variables globally
init = tf.global_variables_initializer()

# Start the session to compute the tensorflow graph
sess=tf.Session()
sess.run(init)

#printing cost and first layers weights
print('first layer weights ',sess.run(tf.trainable_variables()[0]) )
print('cost: ',sess.run(cost,feed_dict={X:X_train[0:4,:], Y:Y_train[0:4,:]}))

#doing one optimization step
_ ,OK=sess.run([optimizer, cost], feed_dict={X:X_train[0:4,:], Y:Y_train[0:4,:]})


#printing cost and first layers weights
print('first layer weights ',sess.run(tf.trainable_variables()[0]) )
print('cost :',sess.run(cost,feed_dict={X:X_train[0:4,:], Y:Y_train[0:4,:]}))

#closing session
sess.close()

欢迎任何帮助。

4

2 回答 2

1

这个链接解决了我的问题： Tensorflow NaN bug?

基本上，在计算 y*log(y) 时，它恰好有 0 log(0) ，因此解决方案在提供的链接中。无论如何，谢谢你们的帮助。

更换 

  cost= tf.reduce_mean(labels * - tf.log(output) + (1 - labels) * - tf.log(1 - output),axis=0)

有了这个 

cost= tf.reduce_mean(labels * - tf.log(tf.clip_by_value(output,1e-10,1.0)) + (1 - labels) * - tf.log(tf.clip_by_value(1 - output,1e-10,1.0)),axis=0)
于 2018-05-04T16:21:31.643 回答
0

建议使用tf.nn.softmax_cross_entropy_with_logits_v2而不是自己实现它，因为它涵盖了许多通常会导致nan损失的极端情况。

您使用的方式tf.nn.softmax_cross_entropy_with_logits_v2是通过激活 Dense Layer 4 来linear代替softmax. 这样，您的密集层 4 的输出将是logits，然后可以直接馈入tf.nn.softmax_cross_entropy_with_logits_v2.

最后，请确保您仔细阅读以下内容：

编辑：我的错，我没有仔细阅读这个问题，所以我错过了你说这不是multi-class classification问题的事实。如果这不是multi-class classification问题，那么它可能超出了我目前的专业知识。因此，我将为您提供另一个链接，您和我都可以仔细阅读。

于 2018-05-04T13:11:30.930 回答