基于TENSORFLOW的多标签分类——成本和权重NaN

Question

上下文化
我正在构建一个用于多标签分类的神经网络：识别图像中的标签（一个人穿着什么衣服，颜色等等）。我想使用纯tensorflow（而不是像kears这样的API），以便在度量上有更多的灵活性
P.S：这个tensorflow模型所用的数据是用一个Keras-Build模型测试的，没有产生我将在这里暴露的问题。

数据
我的输入数据是（X，Y）：X是形状（1814204,3），Y是形状（1814,39）。因此，基本上X是一组图像，Y是与每个图像相关联的标签，用于监督学习过程
总共有39个标签，因此对于每个大小的图像（1204204,3），我们关联一个形状向量（1,39）：39个值可以是0或1。1，如果在该图像中标识了相应的标签，则为O。可以同时识别多个标签，这意味着我们没有使用一个热编码，也不是多类分类情况
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

对于大小为（？，204204,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.现在，我正在定义我的成本函数和我的优化器。

• 对于成本函数，我使用交叉熵和对数，独立计算批次样本上所有输出组件的平均值。例如，如果我有一个10号的批次，模型的输出是形状（10,39），因此对于成本，我们将有一个形状向量（1,39）（对于每个标签，我们计算批次中不同示例的平均值）
• 对于优化器，我使用adam优化器

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

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中的“轴=0”。reduce_mean允许我独立计算每个标签的平均值，即批次示例的平均值！

3.定义占位符、初始化模型和培训
定义了具有不同参数的抽象模型后，我创建了占位符并构建了计算图，然后初始化权重并开始训练。问题：随着优化的进行，我开始为不同层中的权重设置NaN值，并在成本函数中设置NaN值。所以第一个反应是尝试调试和理解发生了什么
我尝试测试一个简单的案例，如下所示：
初始化权重---

#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()

欢迎任何帮助。

Answer 1

建议使用tf.nn.softmax_cross_entropy_with_logits_v2而不是自己实现它，因为它涵盖了许多通常会导致nan丢失的角落案例。

您使用tf的方式。nn。softmax_交叉_熵_与_logits_v2是通过使密集层4的激活成为线性，而不是softmax。这样，密集层4的输出将是logits，然后可以直接输入tf。nn。softmax\u交叉\u熵\u与\u logits\u v2。

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

• softmax_cross_entropy_with_logits_v2文件
• softmax和softmax_cross_entropy_with_logits有什么区别？
• TensorFlow：sparse_softmax_cross_entropy_with_logits和softmax_cross_entropy_with_logits有什么区别？

编辑：我的错，我没有仔细阅读这个问题，所以我错过了你说的这不是一个多类分类问题的事实。如果这不是一个多类别分类问题，则可能超出我目前的专业知识范围。因此，我将给你们留下另一个链接，你们和我都可以仔细阅读。

• Tensorflow S形和交叉熵与S形交叉熵

Answer 2

此链接解决了我的问题：Tensorflow NaN错误？

基本上，当计算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)