Python-Tensorflow，二进制分类，总是预测0

我只是从Tensorflow开始，试图创建一个用于二进制分类的经典神经网络

# Loading Dependencies

import math
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.python.framework import ops
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

seed = 1234
tf.set_random_seed(seed)
np.random.seed(seed)

# Load and Split data
data = pd.read_json(file)
X = data["X"]
y = data["y"]
X = X.astype(np.float32)
y = y.astype(np.float32)

X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size = 0.3)

X_train = X_train.reshape(X_train.shape[0], -1).T
y_train = y_train.values.reshape((1, y_train.shape[0]))
X_valid = X_valid.reshape(X_valid.shape[0], -1).T
y_valid = y_valid.values.reshape((1, y_valid.shape[0]))

print("X Train: ", X_train.shape)
print("y Train: ", y_train.shape)
print("X Dev: ", X_valid.shape)
print("y Dev: ", y_valid.shape)

X列：（168751122）
y列：（11122）
X开发：（16875482）
y发展：（1482）

训练数据包含浮点数，而标签仅为0或1。然而，这些也被转换为浮动，因为我在过去有一些问题

初始化参数

def initialize_parameters(layer_dimensions):
    tf.set_random_seed(seed)
    layers_count = len(layer_dimensions)
    parameters = {}

    for layer in range(1, layers_count):
        parameters['W' + str(layer)] = tf.get_variable('W' + str(layer), 
                                                   [layer_dimensions[layer], layer_dimensions[layer - 1]], 
                                                   initializer = tf.contrib.layers.xavier_initializer(seed = seed))

        parameters['b' + str(layer)] = tf.get_variable('b' + str(layer), 
                                                   [layer_dimensions[layer], 1], 
                                                   initializer = tf.zeros_initializer())

    return parameters

形状为：
W1-（5016875）
W2-（25,50）
W3-（10,25）
W4-（5，10）
W5-（1,5）
b1-（50，1）
b2-（25，1）
b3-（10，1）
b4-（5，1）
b5-（1，1）

调用模型时，我指定了每个层的编号和尺寸（见下文）

正向传播

def forward_propagation(X, parameters):
    parameters_count = len(parameters) // 2 
    A = X

    for layer in range(1, parameters_count):
        W = parameters['W' + str(layer)]
        b = parameters['b' + str(layer)]

        Z = tf.add(tf.matmul(W, A), b)
        A = tf.nn.relu(Z)

    W = parameters['W' + str(parameters_count)]
    b = parameters['b' + str(parameters_count)]

    Z = tf.add(tf.matmul(W, A), b)

    return Z

计算成本（我使用的是sigmoid函数，因为我们处理的是二进制分类）

把它放在一起

def model(X_train, y_train, X_valid, y_valid, layer_dimensions, alpha = 0.0001, epochs = 10):

    ops.reset_default_graph()
    tf.set_random_seed(seed)

    (x_rows, m) = X_train.shape
    y_rows = y_train.shape[0]

    costs = []

    X = tf.placeholder(tf.float32, shape=(x_rows, None), name="X")
    y = tf.placeholder(tf.float32, shape=(y_rows, None), name="y")

    parameters = initialize_parameters(layer_dimensions)
    Z = forward_propagation(X, parameters)
    cost = compute_cost(Z, y)
    optimizer = tf.train.AdamOptimizer(learning_rate = alpha).minimize(cost)

    init = tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init)
        for epoch in range(epochs):
            _ , epoch_cost = sess.run([optimizer, cost], feed_dict={X: X_train, y: y_train})
            print ("Cost after epoch %i: %f" % (epoch + 1, epoch_cost))
            costs.append(epoch_cost)

        parameters = sess.run(parameters)

        correct_predictions = tf.equal(tf.argmax(Z), tf.argmax(y))
        accuracy = tf.reduce_mean(tf.cast(correct_predictions, "float"))

        print ("Train Accuracy:", accuracy.eval({X: X_train, y: y_train}))
        print ("Test Accuracy:", accuracy.eval({X: X_valid, y: y_valid}))

        return parameters

现在，当我尝试训练我的模型时，它似乎从第二个时代开始达到了一个最佳状态，从那时起，成本几乎没有变化

parameters = model(X_train, y_train, X_valid, y_valid, [X_train.shape[0], 50, 25, 10, 5, 1])

第1纪元后的成本：8.758244
第2纪元后的成本：0.693096
第3纪元后的成本：0.692992
第4纪元后的成本：0.692737
第5纪元后的成本：0.697333
第6纪元后的成本：0.693062
第7纪元后的成本：0.693151
第8纪元后的成本：0.693152
第9纪元后的成本：0.693152
第10纪元后的成本：0.693155

现在来看预测

def predict(X, parameters):
    parameters_count = len(parameters) // 2 
    params = {}

    for layer in range(1, parameters_count + 1):
        params['W' + str(layer)] = tf.convert_to_tensor(parameters['W' + str(layer)])
        params['b' + str(layer)] = tf.convert_to_tensor(parameters['b' + str(layer)])

    (x_columns, x_rows) = X.shape
    X_test = tf.placeholder(tf.float32, shape=(x_columns, x_rows))

    Z = forward_propagation(X_test, params)
    p = tf.argmax(Z)

    sess = tf.Session()
    prediction = sess.run(p, feed_dict = {X_test: X})

    return prediction

然而，这将在任何情况下预测0

predictions = predict(X_valid, parameters)
predictions

数组（[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0， 0，0，0，0，0

X Train: (16875, 1122) 

每个样本有16875个特征，但只有1122个序列数据。 我认为这可能还不够

tensorflow get started中的示例代码只包含784个特性

x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])

MNIST数据分为三部分：55000个训练数据点（MNIST.train）、10000个测试数据点（MNIST.test）和5000个验证数据点（MNIST.validation）.这种划分非常重要：在机器学习中，我们必须有单独的数据，而这些数据是我们无法从中学习的，这样我们才能确保我们所学的东西实际上是泛化的！

每个样本有16875个特征，但只有1122个序列数据。 我认为这可能还不够

tensorflow get started中的示例代码只包含784个特性

x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])

MNIST数据分为三部分：55000个训练数据点（MNIST.train）、10000个测试数据点（MNIST.test）和5000个验证数据点（MNIST.validation）.这种划分非常重要：在机器学习中，我们必须有单独的数据，而这些数据是我们无法从中学习的，这样我们才能确保我们所学的东西实际上是泛化的！

---

我同意更多的数据会有帮助，但这不是问题所在。我应该能够得到至少某种类型的预测，即使它们不是那么准确。我还有一个测试集，没有加载到我发布的代码中，但结果是相同的，Z的输出是什么？Z=前向传播（X_测试，参数）p=tf.argmax（Z）sess=tf.Session（）prediction=sess.run（p，feed_dict={X_test:X}）我同意更多的数据会有帮助，但这不是问题所在。我应该能够得到至少某种类型的预测，即使它们不是那么准确。我还有一个测试集，没有加载到我发布的代码中，但结果是相同的，Z的输出是什么？Z=前向传播（X_测试，参数）p=tf.argmax（Z）sess=tf.Session（）prediction=sess.run（p，feed_dict={X_test:X}）实际标签的百分比是0？可能一切都正常。但是，由于ReLUs受到即将消亡的ReLU问题的影响，您可以尝试使用类似leaky ReLUs的内容。此外，您可以尝试只使用一层，看看这是否会产生不同的结果。结果证明您是对的。我的ReLU函数s确实正在消亡，我的所有功能最终都是0。我切换到leaky ReLUs并开始看到一些结果。感谢@Stephen的提示，您的实际标签中有多少百分比是0？可能所有功能都正常工作。但是，由于ReLUs面临着消亡ReLU问题，您可以尝试使用类似leak的功能y ReLUs。另外，你可以试着只使用一个层，看看是否会得到不同的结果。结果证明你是对的。我的ReLU函数确实正在消亡，我的所有功能最终都是0。我切换到了leaky ReLUs并开始看到一些结果。谢谢你的提示@Stephen