成本函数训练目标与准确度期望目标
Cost function training target versus accuracy desired goal
当我们训练神经网络时，我们通常使用梯度下降，它依赖于连续的、可微分的实值成本函数。例如，最终成本函数可能采用均方误差。或者换句话说，梯度下降隐含地假设最终目标是回归——最小化实值误差度量。
有时我们希望神经网络做的是执行分类 - 给定输入，将其分类为两个或多个离散类别。在这种情况下，用户关心的最终目标是分类准确性 - 正确分类的案例百分比。
但是当我们使用神经网络进行分类时，尽管我们的目标是分类准确性，这并不是神经网络试图优化的。神经网络仍在尝试优化实值成本函数。有时它们指向同一个方向，但有时却不同。特别是，我曾 运行 遇到过以下情况：经过训练可以正确最小化成本函数的神经网络的分类准确度比简单的手动编码阈值比较差。
我使用 TensorFlow 将其归结为一个最小的测试用例。它建立一个感知器（没有隐藏层的神经网络），在绝对最小的数据集（一个输入变量，一个二进制输出变量）上训练它评估结果的分类精度，然后将其与简单手的分类精度进行比较-编码阈值比较；结果分别是60%和80%。直觉上，这是因为具有大输入值的单个离群值会产生相应大的输出值，因此最小化成本函数的方法是更加努力地适应这种情况，在这个过程中错误分类两个更普通的情况。感知器正在正确地做它被告知要做的事情；只是这与我们实际想要的分类器不符。但是分类准确率不是连续可微函数，所以不能作为梯度下降的目标
我们如何训练神经网络以使其最终分类准确率最大化？
import numpy as np
import tensorflow as tf
sess = tf.InteractiveSession()
tf.set_random_seed(1)
# Parameters
epochs = 10000
learning_rate = 0.01
# Data
train_X = [
[0],
[0],
[2],
[2],
[9],
]
train_Y = [
0,
0,
1,
1,
0,
]
rows = np.shape(train_X)[0]
cols = np.shape(train_X)[1]
# Inputs and outputs
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# Weights
W = tf.Variable(tf.random_normal([cols]))
b = tf.Variable(tf.random_normal([]))
# Model
pred = tf.tensordot(X, W, 1) + b
cost = tf.reduce_sum((pred-Y)**2/rows)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
tf.global_variables_initializer().run()
# Train
for epoch in range(epochs):
# Print update at successive doublings of time
if epoch&(epoch-1) == 0 or epoch == epochs-1:
print('{} {} {} {}'.format(
epoch,
cost.eval({X: train_X, Y: train_Y}),
W.eval(),
b.eval(),
))
optimizer.run({X: train_X, Y: train_Y})
# Classification accuracy of perceptron
classifications = [pred.eval({X: x}) > 0.5 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = perceptron accuracy'.format(correct, rows))
# Classification accuracy of hand-coded threshold comparison
classifications = [x[0] > 1.0 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = threshold accuracy'.format(correct, rows))
我认为您忘记了通过 simgoid 传递输出。固定如下：
import numpy as np
import tensorflow as tf
sess = tf.InteractiveSession()
tf.set_random_seed(1)
# Parameters
epochs = 10000
learning_rate = 0.01
# Data
train_X = [
[0],
[0],
[2],
[2],
[9],
]
train_Y = [
0,
0,
1,
1,
0,
]
rows = np.shape(train_X)[0]
cols = np.shape(train_X)[1]
# Inputs and outputs
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# Weights
W = tf.Variable(tf.random_normal([cols]))
b = tf.Variable(tf.random_normal([]))
# Model
# CHANGE HERE: Remember, you need an activation function!
pred = tf.nn.sigmoid(tf.tensordot(X, W, 1) + b)
cost = tf.reduce_sum((pred-Y)**2/rows)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
tf.global_variables_initializer().run()
# Train
for epoch in range(epochs):
# Print update at successive doublings of time
if epoch&(epoch-1) == 0 or epoch == epochs-1:
print('{} {} {} {}'.format(
epoch,
cost.eval({X: train_X, Y: train_Y}),
W.eval(),
b.eval(),
))
optimizer.run({X: train_X, Y: train_Y})
# Classification accuracy of perceptron
classifications = [pred.eval({X: x}) > 0.5 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = perceptron accuracy'.format(correct, rows))
# Classification accuracy of hand-coded threshold comparison
classifications = [x[0] > 1.0 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = threshold accuracy'.format(correct, rows))
输出：
0 0.28319069743156433 [ 0.75648874] -0.9745011329650879
1 0.28302448987960815 [ 0.75775659] -0.9742625951766968
2 0.28285878896713257 [ 0.75902224] -0.9740257859230042
4 0.28252947330474854 [ 0.76154679] -0.97355717420578
8 0.28187844157218933 [ 0.76656926] -0.9726400971412659
16 0.28060704469680786 [ 0.77650583] -0.970885694026947
32 0.27818527817726135 [ 0.79593837] -0.9676888585090637
64 0.2738055884838104 [ 0.83302218] -0.9624817967414856
128 0.26666420698165894 [ 0.90031379] -0.9562843441963196
256 0.25691407918930054 [ 1.01172411] -0.9567816257476807
512 0.2461051195859909 [ 1.17413962] -0.9872989654541016
1024 0.23519910871982574 [ 1.38549554] -1.088881492614746
2048 0.2241383194923401 [ 1.64616168] -1.298340916633606
4096 0.21433120965957642 [ 1.95981205] -1.6126530170440674
8192 0.2075471431016922 [ 2.31746769] -1.989408016204834
9999 0.20618653297424316 [ 2.42539024] -2.1028473377227783
4/5 = perceptron accuracy
4/5 = threshold accuracy
How can we train a neural network so that it ends up maximizing classification accuracy?
I'm asking for a way to get a continuous proxy function that's closer to the accuracy
首先，今天用于（深度）神经网络中class化任务的损失函数并不是他们发明的，但它可以追溯到几十年前，它实际上来自早期逻辑回归。这是二进制 classification 的简单情况的方程式：
它背后的想法正是想出一个 连续且可微的 函数，这样我们就可以利用（庞大且仍在扩展的）凸函数库class化问题的优化。
可以肯定地说，上述损失函数是我们迄今为止最好的损失函数，考虑到上述所需的数学约束。
我们是否应该考虑解决并完成这个问题（即更好地近似准确度）？至少原则上不会。我年纪大了，还记得那个时代，当时唯一可用的激活函数是 tanh 和 sigmoid；然后出现了 ReLU，给这个领域带来了真正的推动。同样，有人最终可能会想出更好的损失函数，但可以说这将发生在研究论文中，而不是作为对 SO 问题的答案...
也就是说，当前的损失函数来自非常基本的考虑概率和信息论（与当前深度学习领域形成鲜明对比的领域） , 站在坚实的理论基础上）至少会让人怀疑是否即将提出更好的损失建议。
loss和accuracy的关系还有一个微妙的地方，就是后者与前者有质的区别，在这样的讨论中经常被忽略。让我详细说明一下...
与此讨论相关的所有 class 变量（即神经网络、逻辑回归等）都是 概率；也就是说，它们不是 return 硬 class 成员资格 (0/1)，而是 class 概率（[0, 1] 中的连续实数）。
为了简单起见，将讨论限制在二元情况下，当将 class 概率转换为（硬）class 成员资格时，我们隐含地涉及 阈值 ，通常等于0.5，如if p[i] > 0.5，则class[i] = "1"。现在，我们可以发现很多情况下这种天真的默认阈值选择将不起作用（首先想到的是严重不平衡的数据集），我们将不得不选择一个不同的。但我们在这里讨论的重点是，这个阈值选择虽然对准确性至关重要，但完全 外部 最小化损失的数学优化问题，并作为它们之间的进一步“绝缘层”，损害了简单的观点，即损失只是准确性的代表（它不是）。正如 this Cross Validated thread:
的答案中所说的那样
the statistical component of your exercise ends when you output a probability for each class of your new sample. Choosing a threshold beyond which you classify a new observation as 1 vs. 0 is not part of the statistics any more. It is part of the decision component.
稍微扩大一个已经很广泛的讨论：我们能否完全摆脱连续和可微函数的数学优化的（非常）限制约束？换句话说，我们可以取消反向传播和梯度下降吗？
嗯，我们实际上已经这样做了，至少在强化学习的子领域：2017 年是社区 new research from OpenAI on something called Evolution Strategies made headlines. And as an extra bonus, here is an ultra-fresh (Dec 2017) paper by Uber on the subject, again generating much enthusiasm 的一年。
当我们训练神经网络时，我们通常使用梯度下降，它依赖于连续的、可微分的实值成本函数。例如，最终成本函数可能采用均方误差。或者换句话说，梯度下降隐含地假设最终目标是回归——最小化实值误差度量。
有时我们希望神经网络做的是执行分类 - 给定输入，将其分类为两个或多个离散类别。在这种情况下，用户关心的最终目标是分类准确性 - 正确分类的案例百分比。
但是当我们使用神经网络进行分类时，尽管我们的目标是分类准确性，这并不是神经网络试图优化的。神经网络仍在尝试优化实值成本函数。有时它们指向同一个方向，但有时却不同。特别是，我曾 运行 遇到过以下情况：经过训练可以正确最小化成本函数的神经网络的分类准确度比简单的手动编码阈值比较差。
我使用 TensorFlow 将其归结为一个最小的测试用例。它建立一个感知器（没有隐藏层的神经网络），在绝对最小的数据集（一个输入变量，一个二进制输出变量）上训练它评估结果的分类精度，然后将其与简单手的分类精度进行比较-编码阈值比较；结果分别是60%和80%。直觉上，这是因为具有大输入值的单个离群值会产生相应大的输出值，因此最小化成本函数的方法是更加努力地适应这种情况，在这个过程中错误分类两个更普通的情况。感知器正在正确地做它被告知要做的事情；只是这与我们实际想要的分类器不符。但是分类准确率不是连续可微函数，所以不能作为梯度下降的目标
我们如何训练神经网络以使其最终分类准确率最大化？
import numpy as np
import tensorflow as tf
sess = tf.InteractiveSession()
tf.set_random_seed(1)
# Parameters
epochs = 10000
learning_rate = 0.01
# Data
train_X = [
[0],
[0],
[2],
[2],
[9],
]
train_Y = [
0,
0,
1,
1,
0,
]
rows = np.shape(train_X)[0]
cols = np.shape(train_X)[1]
# Inputs and outputs
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# Weights
W = tf.Variable(tf.random_normal([cols]))
b = tf.Variable(tf.random_normal([]))
# Model
pred = tf.tensordot(X, W, 1) + b
cost = tf.reduce_sum((pred-Y)**2/rows)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
tf.global_variables_initializer().run()
# Train
for epoch in range(epochs):
# Print update at successive doublings of time
if epoch&(epoch-1) == 0 or epoch == epochs-1:
print('{} {} {} {}'.format(
epoch,
cost.eval({X: train_X, Y: train_Y}),
W.eval(),
b.eval(),
))
optimizer.run({X: train_X, Y: train_Y})
# Classification accuracy of perceptron
classifications = [pred.eval({X: x}) > 0.5 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = perceptron accuracy'.format(correct, rows))
# Classification accuracy of hand-coded threshold comparison
classifications = [x[0] > 1.0 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = threshold accuracy'.format(correct, rows))
我认为您忘记了通过 simgoid 传递输出。固定如下：
import numpy as np
import tensorflow as tf
sess = tf.InteractiveSession()
tf.set_random_seed(1)
# Parameters
epochs = 10000
learning_rate = 0.01
# Data
train_X = [
[0],
[0],
[2],
[2],
[9],
]
train_Y = [
0,
0,
1,
1,
0,
]
rows = np.shape(train_X)[0]
cols = np.shape(train_X)[1]
# Inputs and outputs
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# Weights
W = tf.Variable(tf.random_normal([cols]))
b = tf.Variable(tf.random_normal([]))
# Model
# CHANGE HERE: Remember, you need an activation function!
pred = tf.nn.sigmoid(tf.tensordot(X, W, 1) + b)
cost = tf.reduce_sum((pred-Y)**2/rows)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
tf.global_variables_initializer().run()
# Train
for epoch in range(epochs):
# Print update at successive doublings of time
if epoch&(epoch-1) == 0 or epoch == epochs-1:
print('{} {} {} {}'.format(
epoch,
cost.eval({X: train_X, Y: train_Y}),
W.eval(),
b.eval(),
))
optimizer.run({X: train_X, Y: train_Y})
# Classification accuracy of perceptron
classifications = [pred.eval({X: x}) > 0.5 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = perceptron accuracy'.format(correct, rows))
# Classification accuracy of hand-coded threshold comparison
classifications = [x[0] > 1.0 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = threshold accuracy'.format(correct, rows))
输出：
0 0.28319069743156433 [ 0.75648874] -0.9745011329650879
1 0.28302448987960815 [ 0.75775659] -0.9742625951766968
2 0.28285878896713257 [ 0.75902224] -0.9740257859230042
4 0.28252947330474854 [ 0.76154679] -0.97355717420578
8 0.28187844157218933 [ 0.76656926] -0.9726400971412659
16 0.28060704469680786 [ 0.77650583] -0.970885694026947
32 0.27818527817726135 [ 0.79593837] -0.9676888585090637
64 0.2738055884838104 [ 0.83302218] -0.9624817967414856
128 0.26666420698165894 [ 0.90031379] -0.9562843441963196
256 0.25691407918930054 [ 1.01172411] -0.9567816257476807
512 0.2461051195859909 [ 1.17413962] -0.9872989654541016
1024 0.23519910871982574 [ 1.38549554] -1.088881492614746
2048 0.2241383194923401 [ 1.64616168] -1.298340916633606
4096 0.21433120965957642 [ 1.95981205] -1.6126530170440674
8192 0.2075471431016922 [ 2.31746769] -1.989408016204834
9999 0.20618653297424316 [ 2.42539024] -2.1028473377227783
4/5 = perceptron accuracy
4/5 = threshold accuracy
How can we train a neural network so that it ends up maximizing classification accuracy?
I'm asking for a way to get a continuous proxy function that's closer to the accuracy
首先，今天用于（深度）神经网络中class化任务的损失函数并不是他们发明的，但它可以追溯到几十年前，它实际上来自早期逻辑回归。这是二进制 classification 的简单情况的方程式：
它背后的想法正是想出一个 连续且可微的 函数，这样我们就可以利用（庞大且仍在扩展的）凸函数库class化问题的优化。
可以肯定地说，上述损失函数是我们迄今为止最好的损失函数，考虑到上述所需的数学约束。
我们是否应该考虑解决并完成这个问题（即更好地近似准确度）？至少原则上不会。我年纪大了，还记得那个时代，当时唯一可用的激活函数是 tanh 和 sigmoid；然后出现了 ReLU，给这个领域带来了真正的推动。同样，有人最终可能会想出更好的损失函数，但可以说这将发生在研究论文中，而不是作为对 SO 问题的答案...
也就是说，当前的损失函数来自非常基本的考虑概率和信息论（与当前深度学习领域形成鲜明对比的领域） , 站在坚实的理论基础上）至少会让人怀疑是否即将提出更好的损失建议。
loss和accuracy的关系还有一个微妙的地方，就是后者与前者有质的区别，在这样的讨论中经常被忽略。让我详细说明一下...
与此讨论相关的所有 class 变量（即神经网络、逻辑回归等）都是 概率；也就是说，它们不是 return 硬 class 成员资格 (0/1)，而是 class 概率（[0, 1] 中的连续实数）。
为了简单起见，将讨论限制在二元情况下，当将 class 概率转换为（硬）class 成员资格时，我们隐含地涉及 阈值 ，通常等于0.5，如if p[i] > 0.5，则class[i] = "1"。现在，我们可以发现很多情况下这种天真的默认阈值选择将不起作用（首先想到的是严重不平衡的数据集），我们将不得不选择一个不同的。但我们在这里讨论的重点是，这个阈值选择虽然对准确性至关重要，但完全 外部 最小化损失的数学优化问题，并作为它们之间的进一步“绝缘层”，损害了简单的观点，即损失只是准确性的代表（它不是）。正如 this Cross Validated thread:
the statistical component of your exercise ends when you output a probability for each class of your new sample. Choosing a threshold beyond which you classify a new observation as 1 vs. 0 is not part of the statistics any more. It is part of the decision component.
稍微扩大一个已经很广泛的讨论：我们能否完全摆脱连续和可微函数的数学优化的（非常）限制约束？换句话说，我们可以取消反向传播和梯度下降吗？
嗯，我们实际上已经这样做了，至少在强化学习的子领域：2017 年是社区 new research from OpenAI on something called Evolution Strategies made headlines. And as an extra bonus, here is an ultra-fresh (Dec 2017) paper by Uber on the subject, again generating much enthusiasm 的一年。