python – 神经网络：神秘的ReLu

2019年8月3日 342次阅读

我一直在构建一个编程语言检测器,即代码片段的分类器,作为更大项目的一部分.

我的基线模型非常简单：将输入标记化并将片段编码为词袋或者,

在这种情况下,包包,并在这些功能之上做一个简单的NN.

《python – 神经网络：神秘的ReLu》

NN的输入是大多数独特令牌的固定长度计数器阵列,例如“def”,
从语料库中自动提取的“self”,“function”,“ – >”,“const”,“#include”等.
这个想法是这些令牌对于编程语言来说是非常独特的,所以即使这种天真的方法也应该得到
高准确度得分.

Input:
  def   1
  for   2
  in    2
  True  1
  ):    3
  ,:    1

  ...

Output: python

建立

我很快就获得了99％的准确率,并认为这是符合预期的标志.这是模型
(完整的可运行脚本是here)：

# Placeholders
x = tf.placeholder(shape=[None, vocab_size], dtype=tf.float32, name='x')
y = tf.placeholder(shape=[None], dtype=tf.int32, name='y')
training = tf.placeholder_with_default(False, shape=[], name='training')

# One hidden layer with dropout
reg = tf.contrib.layers.l2_regularizer(0.01)
hidden1 = tf.layers.dense(x, units=96, kernel_regularizer=reg, 
                          activation=tf.nn.elu, name='hidden1')
dropout1 = tf.layers.dropout(hidden1, rate=0.2, training=training, name='dropout1')

# Output layer
logits = tf.layers.dense(dropout1, units=classes, kernel_regularizer=reg,
                         activation=tf.nn.relu, name='logits')

# Cross-entropy loss
loss = tf.reduce_mean(
    tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, abels=y))

# Misc reports: accuracy, correct/misclassified samples, etc.
correct_predicted = tf.nn.in_top_k(logits, y, 1, name='in-top-k')
prediction = tf.argmax(logits, axis=1)
wrong_predicted = tf.logical_not(correct_predicted, name='not-in-top-k')
x_misclassified = tf.boolean_mask(x, wrong_predicted, name='misclassified')
accuracy = tf.reduce_mean(tf.cast(correct_predicted, tf.float32), name='accuracy')

输出非常令人鼓舞：

iteration=5  loss=2.580  train-acc=0.34277
iteration=10  loss=2.029  train-acc=0.69434
iteration=15  loss=2.054  train-acc=0.92383
iteration=20  loss=1.934  train-acc=0.98926
iteration=25  loss=1.942  train-acc=0.99609
Files.VAL mean accuracy = 0.99121             <-- After just 1 epoch!

iteration=30  loss=1.943  train-acc=0.99414
iteration=35  loss=1.947  train-acc=0.99512
iteration=40  loss=1.946  train-acc=0.99707
iteration=45  loss=1.946  train-acc=0.99609
iteration=50  loss=1.944  train-acc=0.99902
iteration=55  loss=1.946  train-acc=0.99902
Files.VAL mean accuracy = 0.99414

测试精度也在1.0左右.一切看起来都很完美.

神秘的ReLu

但后来我注意到我将activation = tf.nn.relu放入最后的密集层(logits),这显然是一个错误：
在softmax之前不需要丢弃负分数,因为它们表示具有低概率的类.
零门槛只会使这些类人为地更加可能,这将是一个错误.摆脱它应该只会使模型在正确的类中更加健壮和自信.

那正是我所想.
所以我用activation = None替换它,再次运行模型然后发生了一件令人惊讶的事情：
表现没有改善.完全没有.事实上,它显着下降：

iteration=5  loss=5.236  train-acc=0.16602
iteration=10  loss=4.068  train-acc=0.18750
iteration=15  loss=3.110  train-acc=0.37402
iteration=20  loss=5.149  train-acc=0.14844
iteration=25  loss=2.880  train-acc=0.18262
Files.VAL mean accuracy = 0.28711

iteration=30  loss=3.136  train-acc=0.25781
iteration=35  loss=2.916  train-acc=0.22852
iteration=40  loss=2.156  train-acc=0.39062
iteration=45  loss=1.777  train-acc=0.45312
iteration=50  loss=2.726  train-acc=0.33105
Files.VAL mean accuracy = 0.29362

训练的准确性越来越好,但从未超过91-92％.我来回改变了几次激活,
改变不同的参数(层大小,丢失,正则化,额外的层,任何东西),并始终有相同的结果：
“错误”模型立即达到99％,而“正确”模型在50个时代后几乎达不到90％.根据
张量板,重量分布没有太大差异：梯度没有消失,两个模型都学到了
一般.

这怎么可能？最终的ReLu如何使模型如此优越？特别是如果这个ReLu是一个bug？

最佳答案 预测分布

在玩了一会儿之后,我决定想象两种模型的实际预测分布：

predicted_distribution = tf.nn.softmax(logits, name='distribution')

以下是分布的直方图以及它们随时间的演变.

使用ReLu(错误型号)

《python – 神经网络：神秘的ReLu》

没有ReLu(正确型号)

《python – 神经网络：神秘的ReLu》

第一个直方图是有意义的,大多数概率接近于0.
但是ReLu模型的直方图是可疑的：经过几次迭代后,这些值似乎集中在0.15左右.打印实际预测证实了这个想法：

[0.14286 0.14286 0.14286 0.14286 0.14286 0.14286 0.14286]
[0.14286 0.14286 0.14286 0.14286 0.14286 0.14286 0.14286]

我有7个班级(当时有7种不同的语言),0.14286是1/7.事实证明,学习输出的“完美”模型
0 logits,反过来在均匀预测中转换.

但是,如何将此分布报告为99％准确？

tf.nn.in_top_k

在深入研究tf.nn.in_top_k之前,我检查了另一种计算准确度的方法：

true_correct = tf.equal(tf.argmax(logits, 1), tf.cast(y, tf.int64))
alternative_accuracy = tf.reduce_mean(tf.cast(true_correct, tf.float32))

…对最高预测班级和基本事实进行诚实比较.结果是这样的：

iteration=2  loss=3.992  train-acc=0.13086  train-alt-acc=0.13086
iteration=4  loss=3.590  train-acc=0.13086  train-alt-acc=0.12207
iteration=6  loss=2.871  train-acc=0.21777  train-alt-acc=0.13672
iteration=8  loss=2.466  train-acc=0.37695  train-alt-acc=0.16211
iteration=10  loss=2.099  train-acc=0.62305  train-alt-acc=0.10742
iteration=12  loss=2.066  train-acc=0.79980  train-alt-acc=0.17090
iteration=14  loss=2.016  train-acc=0.84277  train-alt-acc=0.17285
iteration=16  loss=1.954  train-acc=0.91309  train-alt-acc=0.13574
iteration=18  loss=1.956  train-acc=0.95508  train-alt-acc=0.06445
iteration=20  loss=1.923  train-acc=0.97754  train-alt-acc=0.11328

实际上,k = 1的tf.nn.in_top_k很快就偏离了正确的准确度,并开始报告幻想的99％值.
那它实际上做了什么？这是the documentation
说到这个：

Says whether the targets are in the top K predictions.

This outputs a batch_size bool array, an entry out[i] is true if the prediction for the target class is among the top k
predictions among all predictions for example i.
Note that the behavior of InTopK differs from the TopK op in its handling of ties;
if multiple classes have the same prediction value and straddle the top-k boundary,
all of those classes are considered to be in the top k.

就是这样.如果概率是统一的(实际上意味着“我不知道”),它们都是正确的.情况更糟,因为如果logits分布几乎是均匀的,softmax可能会将其转换为完全均匀的分布,如下面的简单示例所示：

x = tf.constant([0, 1e-8, 1e-8, 1e-9])
tf.nn.softmax(x).eval()
# >>> array([0.25, 0.25, 0.25, 0.25], dtype=float32)

……这意味着根据tf.nn.in_top_k规范,每次几乎统一的预测都可以被认为是“正确的”.

结论

tf.nn.in_top_k是张量流中准确性度量的危险选择,因为它可能会默默地吞下错误的预测
并将其报告为“正确”.相反,您应该始终使用这个长而可信的表达式：

accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(logits, 1), tf.cast(y, tf.int64)), tf.float32))
点赞