Question

我用tensorflow构建了一个神经网络。它是一个简单的3层神经网络，最后一层是softmax。

我在标准成人收入数据集（例如https://archive.ics.uci.edu/ml/datasets/adult）上尝试过，因为它是公开的，有大量数据（大约50k例子），并且还提供单独的测试数据。

由于存在一些分类属性，我将它们转换为一个热编码。对于神经网络，我使用了Xavier初始化和Adam Optimizer。由于只有两个输出类别（> 50k和<= 50k），最后一个softmax层只有两个神经元。经过一次热编码扩展后，14个属性/列扩展为108列。

我在前两个隐藏层（从5到25）中尝试了不同数量的神经元。我还尝试了迭代次数（从1000到20000）。

训练精度不受神经元数量的影响。它有了更多的迭代次数。但是我不能做到比82％更好:(

我错过了一些基本的方法吗？有没有人试过这个（神经网络与这个数据集）？如果是这样，预期结果是什么？低精度可能是由于缺少值吗？（如果数据集中没有多少，我打算尝试过滤掉所有缺失的值）。

还有其他想法吗？这是我的张量流神经网络代码，以防其中有任何错误等。

def create_placeholders(n_x, n_y):
    X = tf.placeholder(tf.float32, [n_x, None], name = "X")
    Y = tf.placeholder(tf.float32, [n_y, None], name = "Y")
    return X, Y

def initialize_parameters(num_features):
    tf.set_random_seed(1)                   # so that your "random" numbers match ours
    layer_one_neurons = 5
    layer_two_neurons = 5
    layer_three_neurons = 2
    W1 = tf.get_variable("W1", [layer_one_neurons,num_features], initializer = tf.contrib.layers.xavier_initializer(seed = 1))
    b1 = tf.get_variable("b1", [layer_one_neurons,1], initializer = tf.zeros_initializer())
    W2 = tf.get_variable("W2", [layer_two_neurons,layer_one_neurons], initializer = tf.contrib.layers.xavier_initializer(seed = 1))
    b2 = tf.get_variable("b2", [layer_two_neurons,1], initializer = tf.zeros_initializer())
    W3 = tf.get_variable("W3", [layer_three_neurons,layer_two_neurons], initializer = tf.contrib.layers.xavier_initializer(seed = 1))
    b3 = tf.get_variable("b3", [layer_three_neurons,1], initializer = tf.zeros_initializer())
    parameters = {"W1": W1,
                      "b1": b1,
                      "W2": W2,
                      "b2": b2,
                      "W3": W3,
                      "b3": b3}

    return parameters

def forward_propagation(X, parameters):
    """
    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX

    Arguments:
    X -- input dataset placeholder, of shape (input size, number of examples)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3"
                  the shapes are given in initialize_parameters

    Returns:
    Z3 -- the output of the last LINEAR unit
    """

    # Retrieve the parameters from the dictionary "parameters" 
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']
    W3 = parameters['W3']
    b3 = parameters['b3']

    Z1 = tf.add(tf.matmul(W1, X), b1)                                           
    A1 = tf.nn.relu(Z1)                                             
    Z2 = tf.add(tf.matmul(W2, A1), b2)                                  
    A2 = tf.nn.relu(Z2)                                         
    Z3 = tf.add(tf.matmul(W3, A2), b3)

    return Z3

def compute_cost(Z3, Y):
    """
    Computes the cost

    Arguments:
    Z3 -- output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)
    Y -- "true" labels vector placeholder, same shape as Z3

    Returns:
    cost - Tensor of the cost function
    """

    # to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)
    logits = tf.transpose(Z3)
    labels = tf.transpose(Y)

    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = logits, labels = labels))

    return cost

def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001, num_epochs = 1000, print_cost = True):
    """
    Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.

    Arguments:
    X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
    Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
    X_test -- training set, of shape (input size = 12288, number of training examples = 120)
    Y_test -- test set, of shape (output size = 6, number of test examples = 120)
    learning_rate -- learning rate of the optimization
    num_epochs -- number of epochs of the optimization loop
    print_cost -- True to print the cost every 100 epochs

    Returns:
    parameters -- parameters learnt by the model. They can then be used to predict.
    """

    ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables
    tf.set_random_seed(1)                             # to keep consistent results
    seed = 3                                          # to keep consistent results
    (n_x, m) = X_train.shape                          # (n_x: input size, m : number of examples in the train set)
    n_y = Y_train.shape[0]                            # n_y : output size
    costs = []                                        # To keep track of the cost

    # Create Placeholders of shape (n_x, n_y)
    X, Y = create_placeholders(n_x, n_y)

    # Initialize parameters
    parameters = initialize_parameters(X_train.shape[0])

    # Forward propagation: Build the forward propagation in the tensorflow graph
    Z3 = forward_propagation(X, parameters)

    # Cost function: Add cost function to tensorflow graph
    cost = compute_cost(Z3, Y)

    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
    optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

    # Initialize all the variables
    init = tf.global_variables_initializer()

    # Start the session to compute the tensorflow graph
    with tf.Session() as sess:

        # Run the initialization
        sess.run(init)

        # Do the training loop
        for epoch in range(num_epochs):
            _ , epoch_cost = sess.run([optimizer, cost], feed_dict={X: X_train, Y: Y_train})

            # Print the cost every epoch
            if print_cost == True and epoch % 100 == 0:
                print ("Cost after epoch %i: %f" % (epoch, epoch_cost))
            if print_cost == True and epoch % 5 == 0:
                costs.append(epoch_cost)

        # plot the cost
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations (per tens)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()

        # lets save the parameters in a variable
        parameters = sess.run(parameters)
        print ("Parameters have been trained!")

        # Calculate the correct predictions
        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))

        # Calculate accuracy on the test set
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

        print ("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
        #print ("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))

        return parameters

import math
import numpy as np
import h5py
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.python.framework import ops
import pandas as pd
%matplotlib inline
np.random.seed(1)

df = pd.read_csv('adult.data', header = None)
X_train_orig = df.drop(df.columns[[14]], axis=1, inplace=False)
Y_train_orig = df[[14]]
X_train = pd.get_dummies(X_train_orig) # get one hot encoding
Y_train = pd.get_dummies(Y_train_orig) # get one hot encoding
parameters = model(X_train.T, Y_train.T, None, None, num_epochs = 10000)

有关其他公开数据集的任何建议吗？

我尝试使用默认参数从scikit学习这个数据集的标准算法，并且我得到了以下精度：

Random Forest:    86
SVM:              96
kNN:              83
MLP:              79

我上传了我的iPython笔记本：https://github.com/sameermahajan/ClassifiersWithIncomeData/blob/master/Scikit%2BLearn%2BClassifiers.ipynb

SVM的最佳准确性可以从一些解释中得到预期：http://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html有趣的是，SVM也花了很多时间来运行，比其他任何方法都要多。

这可能不是神经网络在上面查看MLPClassifier精度要解决的好问题。我的神经网络毕竟不是那么糟糕！感谢所有回复和您对此的兴趣。

Answer 1

我没有在这个数据集上进行实验，但在查看了一些论文并进行了一些研究后，看起来你的网络运行正常。

首先是您从训练集或测试集计算出的准确度？两者都会为您提供网络性能的良好提示。

我对机器学习还有点新意，但我可以提供一些帮助：

通过查看数据文档链接：https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.names

本文：https://cseweb.ucsd.edu/classes/wi17/cse258-a/reports/a120.pdf

从这些链接中，85％的训练和测试集的准确度看起来很不错，你也不会太远。

您是否进行某种交叉验证以寻找过度拟合的网络？

我没有您的代码，所以如果这是一个错误或编程相关的问题，无法帮助您，也许分享您的代码可能是一个好主意。

我认为通过预处理数据可以获得更高的准确性：您的数据中存在许多未知数，神经网络对错误标记和错误数据非常敏感。

您应该尝试查找并替换或删除未知数。
你也可以尝试找出最有用的功能，然后删除几乎没用的功能。
特征缩放/数据规范化对于神经网络也非常重要，我对数据看起来并不多，但也许你可以尝试弄清楚如何在[0,1]之间扩展数据尚未完成。
我链接的文件似乎看到通过添加最多5层的图层来提升性能，您是否尝试添加更多图层？
如果您没有网络，也可以添加网络直播。
我可能会尝试其他通常适用于SVM（支持向量机）或Logistic回归甚至随机森林等任务的网络但不确定通过查看那些比人工神经网络表现更好的结果网络

我还会看看这些链接：https://www.kaggle.com/wenruliu/adult-income-dataset/feed

https://www.kaggle.com/wenruliu/income-prediction

在这个链接中，有些人尝试算法并提供处理数据的技巧并解决这个问题。

希望有所帮助

祝你好运，马克。

Answer 2

我认为您过分关注网络结构，而忘记了结果也很大程度上取决于数据质量。我尝试了一个快速的现成随机森林，它给了我类似的结果（acc = 0.8275238）。

我建议你做一些特色工程（@Marc提供的kaggle链接有一些很好的例子）。当您在分类变量中有多个因子级别（例如，分组到各大洲的国家/地区）或将连续变量（年龄变量分级为旧级别）时，为您的NA（看here），组值决定一个策略， mid -aged，young）。

使用您的数据，研究您的数据集并尝试应用专业知识来删除冗余或过窄的信息。完成后，再开始调整模型。另外，您可以考虑按照我的方式进行操作：使用集合模型（通常使用默认值快速且非常准确），例如RF或XGB，以检查所有模型之间的结果是否一致。一旦确定自己处于正确的轨道，就可以开始调整结构，图层等，看看是否可以进一步推动结果。

希望这有帮助。

祝你好运！

成人收入数据集的神经网络训练精度低

2 个答案: