使用 Tensorflow 在二进制分类中更改精度值且损失值不变

Question

我正在尝试使用深度神经网络架构根据二进制标签值 - 0 和 +1 进行分类。这是我在 tensorflow 中执行此操作的代码。这个问题也继承了

中的讨论

import tensorflow as tf
import numpy as np
from preprocess import create_feature_sets_and_labels

train_x,train_y,test_x,test_y = create_feature_sets_and_labels()

x = tf.placeholder('float', [None, 5])
y = tf.placeholder('float')

n_nodes_hl1 = 500
n_nodes_hl2 = 500
# n_nodes_hl3 = 500

n_classes = 1
batch_size = 100

def neural_network_model(data):

    hidden_1_layer = {'weights':tf.Variable(tf.random_normal([5, n_nodes_hl1])),
                      'biases':tf.Variable(tf.random_normal([n_nodes_hl1]))}

    hidden_2_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])),
                      'biases':tf.Variable(tf.random_normal([n_nodes_hl2]))}

    # hidden_3_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])),
    #                   'biases':tf.Variable(tf.random_normal([n_nodes_hl3]))}

    # output_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])),
    #                   'biases':tf.Variable(tf.random_normal([n_classes]))}

    output_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl2, n_classes])),
                    'biases':tf.Variable(tf.random_normal([n_classes]))}


    l1 = tf.add(tf.matmul(data, hidden_1_layer['weights']), hidden_1_layer['biases'])
    l1 = tf.nn.relu(l1)

    l2 = tf.add(tf.matmul(l1, hidden_2_layer['weights']), hidden_2_layer['biases'])
    l2 = tf.nn.relu(l2)

    # l3 = tf.add(tf.matmul(l2, hidden_3_layer['weights']), hidden_3_layer['biases'])
    # l3 = tf.nn.relu(l3)

    # output = tf.transpose(tf.add(tf.matmul(l3, output_layer['weights']), output_layer['biases']))
    output = tf.add(tf.matmul(l2, output_layer['weights']), output_layer['biases'])
    return output



def train_neural_network(x):
    prediction = tf.sigmoid(neural_network_model(x))
    cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(prediction, y))
    optimizer = tf.train.AdamOptimizer().minimize(cost)

    hm_epochs = 10

    with tf.Session() as sess:
        sess.run(tf.initialize_all_variables())

        for epoch in range(hm_epochs):
            epoch_loss = 0
            i = 0
            while i < len(train_x):
                start = i
                end = i + batch_size
                batch_x = np.array(train_x[start:end])
        batch_y = np.array(train_y[start:end])

        _, c = sess.run([optimizer, cost], feed_dict={x: batch_x,
                                              y: batch_y})
        epoch_loss += c
        i+=batch_size

            print('Epoch', epoch, 'completed out of', hm_epochs, 'loss:', epoch_loss)

        # correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1))
        # accuracy = tf.reduce_mean(tf.cast(correct, 'float'))
        predicted_class = tf.greater(prediction,0.5)
        correct = tf.equal(predicted_class, tf.equal(y,1.0))
        accuracy = tf.reduce_mean( tf.cast(correct, 'float') )

        # print (test_x.shape)
        # accuracy = tf.nn.l2_loss(prediction-y,name="squared_error_test_cost")/test_x.shape[0]
        print('Accuracy:', accuracy.eval({x: test_x, y: test_y}))

train_neural_network(x)

具体来说，（延续上一个问题的讨论）我删除了一层 - hidden_3_layer。已更改

prediction = neural_network_model(x)

到

prediction = tf.sigmoid(neural_network_model(x))

并根据 Neil 的回答添加了 predicted_class, correct, accuracy 部分。我还在我的 csv 中将所有 -1 更改为 0。

这是我的踪迹：

('Epoch', 0, 'completed out of', 10, 'loss:', 37.312037646770477)
('Epoch', 1, 'completed out of', 10, 'loss:', 37.073578298091888)
('Epoch', 2, 'completed out of', 10, 'loss:', 37.035196363925934)
('Epoch', 3, 'completed out of', 10, 'loss:', 37.035196363925934)
('Epoch', 4, 'completed out of', 10, 'loss:', 37.035196363925934)
('Epoch', 5, 'completed out of', 10, 'loss:', 37.035196363925934)
('Epoch', 6, 'completed out of', 10, 'loss:', 37.035196363925934)
('Epoch', 7, 'completed out of', 10, 'loss:', 37.035196363925934)
('Epoch', 8, 'completed out of', 10, 'loss:', 37.035196363925934)
('Epoch', 9, 'completed out of', 10, 'loss:', 37.035196363925934)
('Accuracy:', 0.42608696)

如您所见，损失并没有减少。因此我不知道它是否仍然正常工作。

这是多次重新运行的结果。结果摇摇欲坠：

('Epoch', 0, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 1, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 2, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 3, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 4, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 5, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 6, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 7, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 8, 'completed out of', 10, 'loss:', 26.513012945652008)
('Epoch', 9, 'completed out of', 10, 'loss:', 26.513012945652008)
('Accuracy:', 0.60124224)

另一个：

('Epoch', 0, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 1, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 2, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 3, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 4, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 5, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 6, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 7, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 8, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 9, 'completed out of', 10, 'loss:', 22.873702049255371)
('Accuracy:', 1.0)

还有一个：

('Epoch', 0, 'completed out of', 10, 'loss:', 23.163824260234833)
('Epoch', 1, 'completed out of', 10, 'loss:', 22.88000351190567)
('Epoch', 2, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 3, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 4, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 5, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 6, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 7, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 8, 'completed out of', 10, 'loss:', 22.873702049255371)
('Epoch', 9, 'completed out of', 10, 'loss:', 22.873702049255371)
('Accuracy:', 0.99627328)

我也看到过0.0的精度值-_-

----------------编辑----------------

关于数据和数据处理的一些细节。我正在使用来自 Yahoo! 的 IBM 每日股票数据融资 20 年（差不多）。这相当于大约 5200 行条目。

我是这样处理的：

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
import csv
import pickle

def create_feature_sets_and_labels(test_size = 0.2):
    df = pd.read_csv("ibm.csv")
    df = df.iloc[::-1]
    features = df.values
    testing_size = int(test_size*len(features))
    train_x = list(features[1:,1:6][:-testing_size])
    train_y = list(features[1:,7][:-testing_size])
    test_x = list(features[1:,1:6][-testing_size:])
    test_y = list(features[1:,7][-testing_size:])
    scaler = MinMaxScaler(feature_range=(-5,5))
    train_x = scaler.fit_transform(train_x)
    train_y = scaler.fit_transform(train_y)
    test_x = scaler.fit_transform(test_x)
    test_y = scaler.fit_transform(test_y)

    return train_x, train_y, test_x, test_y

if __name__ == "__main__":
    train_x, train_y, test_x, test_y = create_feature_sets_and_labels()
    with open('stockdata.pickle', 'wb') as f:
        pickle.dump([train_x, train_y, test_x, test_y], f)

第 0 列是日期。因此，这不用作功能。第 7 列也不是。我使用 sklearn 的 MinMaxScaler() 在 -5 到 5 的范围内对数据进行了标准化。

------------编辑 2-----------------

我注意到当数据以非标准化形式呈现时，系统不会改变其准确性。

Answer 1

一旦您在 ML 训练任务中将数据预处理为错误的形状或范围，其余的数据流就会出错。您在问题的代码中以不同的方式多次执行此操作。

按顺序进行处理。第一个问题是预处理。您的目标应该是：

表格形式的X值（输入特征），每一行是一个例子，每一列是一个特征。值应为数字并按比例缩放以用于神经网络。测试和训练数据需要以相同的方式缩放——这并不意味着使用相同的 .fit_transform 因为那会重新适合缩放器。
表格形式的Y值（输出标签），每一行是与X的同一行匹配的例子，每一列是一个输出的真实值。对于 class化问题，值通常为 0 和 1，并且不应重新缩放，因为它们代表 class 成员资格。

您的 create_feature_sets_and_labels 函数的重写可以正确执行操作：

def create_feature_sets_and_labels(test_size = 0.2):
    df = pd.read_csv("ibm.csv")
    df = df.iloc[::-1]
    features = df.values
    testing_size = int(test_size*len(features))

    train_x = np.array(features[1:,1:6][:-testing_size]).astype(np.float32)
    train_y = np.array(features[1:,7][:-testing_size]).reshape(-1, 1).astype(np.float32)

    test_x = np.array(features[1:,1:6][-testing_size:]).astype(np.float32)
    test_y = np.array(features[1:,7][-testing_size:]).reshape(-1, 1).astype(np.float32)

    scaler = MinMaxScaler(feature_range=(-5,5))

    scaler.fit(train_x)

    train_x = scaler.transform(train_x)
    test_x = scaler.transform(test_x)

    return train_x, train_y, test_x, test_y

与您的版本的重要区别：

使用类型转换 np.array，而不是 list（细微差别）
y 值是表格形式的 [n_examples, n_outputs]（主要区别，您的行向量形状是后来许多问题的原因）
缩放器适合一次然后应用到特征（主要区别，如果你分别缩放训练和测试数据，你没有预测任何有意义的东西）
Scaler not 应用于输出（classifier 的主要区别，您希望训练和测试值为 0,1有意义的培训和报告准确性）

您针对此数据的训练代码也存在一些问题：

y = tf.placeholder('float') 应该是 y = tf.placeholder('float', [None, 1])。这对处理没有影响，但在 y 形状错误时会正确抛出错误。该错误本来是事情出错的线索。
n_nodes_hl1 = 500 和 n_nodes_hl2 = 500 可以低得多，网络实际上会更好地工作，例如n_nodes_hl1 = 10 和 n_nodes_hl2 = 10 - 这主要是因为您使用了较大的权重初始值，您也可以缩小权重，对于更复杂的数据，您可能希望这样做。在这种情况下，减少隐藏神经元的数量更简单。
正如我们在评论中讨论的那样，train_neural_network 函数的开头应如下所示：
```
output = neural_network_model(x)
prediction = tf.sigmoid(output)
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output, y))
optimizer = tf.train.AdamOptimizer().minimize(cost)
```
。 . .这是一个主要区别。通过使用 sigmoid_cross_entropy_with_logits，您已承诺使用输出层的预转换值进行训练。但是您仍然希望预测值能够衡量准确性（或者对于您想要读取预测值的网络的任何其他用途）。
为了一致地衡量损失，您希望每个示例都有平均损失，因此您需要将每批均值之和除以批数：'loss:', epoch_loss/(len(train_x)/batch_size)

如果我进行所有这些更正，并且运行再进行几个时期 - 例如50，然后我得到了 0.7 的典型损失和 0.5 的准确度测量 - 这种情况相当可靠地发生，但由于起始权重的变化确实有一点移动。准确性不是很稳定，并且可能会出现过度拟合，这是您根本不允许的（并且您应该阅读有助于测量和管理过度拟合的技术，这是可靠地训练 NN 的重要部分）

0.5 的值可能看起来很糟糕。可以通过修改网络架构或元参数来改进它。我可以降低到 0.43 训练损失和高达 0.83 测试准确度，例如通过在隐藏层中将 tf.nn.relu 换成 tf.tanh 并将运行ning 换成 500时代。

要了解有关神经网络的更多信息、训练时要测量的内容以及模型中可能值得更改的内容，您需要更深入地研究该主题。

使用 Tensorflow 在二进制分类中更改精度值且损失值不变

Changing accuracy value and no change in loss value in binary classification using Tensorflow

python

machine-learning

neural-network

logistic-regression

tensorflow