2

我正在使用 tensorflow 为 MNIST 数据集复制一个神经网络，该数据集之前是在 skflow 中编程的。这是skflow中的模型：

import tensorflow.contrib.learn as skflow
from sklearn import metrics
from sklearn.datasets import fetch_mldata
from sklearn.cross_validation import train_test_split

mnist = fetch_mldata('MNIST original')

train_dataset, test_dataset, train_labels, test_labels = train_test_split( mnist.data, mnist.target, test_size=10000, random_state=42)

classifier = skflow.TensorFlowDNNClassifier(hidden_units=[1200, 1200], n_classes=10, optimizer="SGD", learning_rate=0.01, batch_size=128, steps=1000)
classifier.fit(train_dataset, train_labels)
score = metrics.accuracy_score(test_labels, classifier.predict(test_dataset))
print("Accuracy: %f" % score)

该模型的准确度为 0.950600。

但是在 tensorflow 中复制的模型在损失函数中得到了 nan 并且未能改进（我认为它与Tensorflow NaN 错误无关？因为我使用的是 tf.nn.softmax_cross_entropy_with_logits）。

我不知道为什么，因为 tensorflow 中的模型设置与 skflow 中的模型相同。我唯一不确定是否相同，是关于 skflow 如何初始化网络的权重，我在 skflow 的代码中搜索了该部分但我没有找到它。

这是张量流中的代码：

import numpy as np
import tensorflow as tf
from sklearn.cross_validation import train_test_split
from sklearn.datasets import fetch_mldata

mnist = fetch_mldata('MNIST original')

num_labels = len(np.unique(mnist.target))
num_pixels = mnist.data.shape[1]

#reshape labels to one hot encoding
labels = (np.arange(num_labels) == mnist.target[:, None]).astype(np.float32)

#create train_dataset of 60000 and test_dataset of 10000 elem
train_dataset, test_dataset, train_labels, test_labels = train_test_split(mnist.data, labels, test_size=10000, random_state=42)


def accuracy(predictions, labels):
    return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])


batch_size = 128
graph = tf.Graph()
with graph.as_default():

    # Input data.
    tf_train_dataset = tf.placeholder(tf.float32,
                                  shape=(batch_size, num_pixels))
    tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
    tf_test_dataset = tf.cast(tf.constant(test_dataset), tf.float32)

    w_hidden = tf.Variable(tf.truncated_normal([num_pixels, 1200]))
    b_hidden = tf.Variable(tf.zeros([1200]))
    hidden = tf.nn.relu(tf.matmul(tf_train_dataset, w_hidden) + b_hidden)

    w_hidden_2 = tf.Variable(tf.truncated_normal([1200, 1200]))
    b_hidden_2 = tf.Variable(tf.zeros([1200]))
    hidden2 = tf.nn.relu(tf.matmul(hidden, w_hidden_2) + b_hidden_2)

    w = tf.Variable(tf.truncated_normal([1200, num_labels]))
    b = tf.Variable(tf.zeros([num_labels]))
    logits = tf.matmul(hidden2, w) + b

    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
    logits, tf_train_labels))

    # Optimizer.
    optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

    # Predictions for the training, and test data.
    train_prediction = tf.nn.softmax(logits)
    test_prediction = tf.nn.softmax(tf.matmul(tf.nn.relu(tf.matmul(tf.nn.relu(tf.matmul(tf_test_dataset, w_hidden) + b_hidden), w_hidden_2) + b_hidden_2), w) + b)

num_steps = 1001

with tf.Session(graph=graph) as session:
    tf.initialize_all_variables().run()
    print("Initialized")
    for step in range(num_steps):
        # Pick an offset within the training data, which has been randomized.
        offset = (step * batch_size) % (train_labels.shape[0] - batch_size)

        # Generate a minibatch.
        batch_data = train_dataset[offset:(offset + batch_size), :]
        batch_labels = train_labels[offset:(offset + batch_size), :]

        # Prepare a dictionary telling the session where to feed the minibatch.
        feed_dict = {tf_train_dataset: batch_data, tf_train_labels: batch_labels}
        _, l, predictions = session.run( [optimizer, loss, train_prediction], feed_dict=feed_dict)
        if (step % 100 == 0):
            print("Minibatch loss at step %d: %f" % (step, l))
            print("Minibatch accuracy: %.1f%%" % accuracy(predictions, batch_labels))
    print("Test accuracy: %.1f%%" % accuracy(test_prediction.eval(), test_labels))

我对可能是什么问题一无所知。有什么建议么？

编辑 1：正如我建议的那样，我尝试用 tf.get_variable("w_hidden", [num_pixels, 1200]) 替换 tf.Variable 调用，但我得到了 Nans。

此外，我使用 skflow.ops.dnn op 进行图层处理并使用我自己的损失等，但仍然得到了 Nans。

编辑2：原来这不是权重初始化的问题。似乎梯度太不稳定（在张量流模型中），导致损失变为 NaN。就像在TensorFlow 中添加多个层导致损失函数变成 Nan一样，我将学习率降低了一个数量级，并且成功了。

现在我不明白的是 skflow 的 SGD 优化器和上面的有什么不同。或者他们“看起来”相等，但他们需要不同的学习率的解释是什么？

4

1 回答 1

0

skflow 中的初始化依赖于tf.get_variable默认初始化 - uniform_unit_scaling_initializer（有关详细说明，请参见此处）。

你可以尝试用tf.Variable类似的东西替换你的电话tf.get_variable("w_hidden", [num_pixels, 1200])。

另一种选择是从使用skflow.ops.dnnop 开始，它会为你做图层，但你仍然会做你自己的损失等等。

如果你有一个明确的用例迫使你用纯 TensorFlow 而不是使用 skflow 重写东西，请告诉我——我很想解决这个问题。您始终可以通过传入并仍然使用训练/批处理/保存等功能来编写自定义model_fn模型TensorFlowEstimator。

于 2016-04-21T04:00:18.883 回答