使用 OR 门从 Tensorflow 获得相反的输出

Question

鉴于 DNN（多层感知器的简单案例）分别具有 2 个 5 维和 3 维隐藏层，我正在训练一个模型来识别 OR 门。

使用 tensorflow 学习，它似乎给了我反向输出，我不知道为什么：

from tensorflow.contrib import learn
classifier = learn.DNNClassifier(hidden_units=[5, 3], n_classes=2)

or_input = np.array([[0.,0.], [0.,1.], [1.,0.]])
or_output = np.array([[0,1,1]]).T

classifier.fit(or_input, or_output, steps=0.05, batch_size=3)
classifier.predict(np.array([ [1., 1.], [1., 0.] , [0., 0.] , [0., 1.]]))

[出]：

array([0, 0, 1, 0])

如果我这样做是“老派”，没有如下tensorflow.learn，我会得到预期的答案。

import tensorflow as tf
# Parameters
learning_rate = 1.0
num_epochs = 1000

# Network Parameters
input_dim = 2 # Input dimensions.
hidden_dim_1 = 5 # 1st layer number of features
hidden_dim_2 = 3 # 2nd layer number of features
output_dim = 1 # Output dimensions.

# tf Graph input
x = tf.placeholder("float", [None, input_dim])
y = tf.placeholder("float", [hidden_dim_2, output_dim])

# With biases.
weights = {
    'syn0': tf.Variable(tf.random_normal([input_dim, hidden_dim_1])),
    'syn1': tf.Variable(tf.random_normal([hidden_dim_1, hidden_dim_2])),
    'syn2': tf.Variable(tf.random_normal([hidden_dim_2, output_dim]))
}


biases = {
    'b0': tf.Variable(tf.random_normal([hidden_dim_1])),
    'b1': tf.Variable(tf.random_normal([hidden_dim_2])),
    'b2': tf.Variable(tf.random_normal([output_dim]))
}


# Create a model
def multilayer_perceptron(X, weights, biases):
    # Hidden layer 1  + sigmoid activation function
    layer_1 = tf.add(tf.matmul(X, weights['syn0']), biases['b0'])
    layer_1 = tf.nn.sigmoid(layer_1)
    # Hidden layer 2 + sigmoid activation function
    layer_2 = tf.add(tf.matmul(layer_1, weights['syn1']), biases['b1'])
    layer_2 = tf.nn.sigmoid(layer_2)
    # Output layer
    out_layer = tf.matmul(layer_2, weights['syn2']) + biases['b2']
    out_layer = tf.nn.sigmoid(out_layer)
    return out_layer

# Construct model
pred = multilayer_perceptron(x, weights, biases)

# Define loss and optimizer
cost = tf.sub(y, pred) 
# Or you can use fancy cost like:
##tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
init = tf.initialize_all_variables()

or_input = np.array([[0.,0.], [0.,1.], [1.,0.]])
or_output = np.array([[0.,1.,1.]]).T

# Launch the graph
with tf.Session() as sess:
    sess.run(init)
    # Training cycle
    for epoch in range(num_epochs):
        batch_x, batch_y = or_input, or_output # Loop over all data points.
        # Run optimization op (backprop) and cost op (to get loss value)
        _, c = sess.run([optimizer, cost], feed_dict={x: batch_x, y: batch_y})
        #print (c)

    # Now let's test it on the unknown dataset.
    new_inputs = np.array([[1.,1.], [1.,0.]])
    feed_dict = {x: new_inputs}
    predictions = sess.run(pred, feed_dict)
    print (predictions)

[出]：

[[ 0.99998868]
 [ 0.99998868]]

为什么我使用tensorflow.learn 得到了反向输出？我使用tensorflow.learn 做错了什么？

如何让tensorflow.learn 代码产生与“老派” tensorflow 框架相同的输出？

Answer 1

如果您为 steps 指定正确的参数，您将获得良好的结果：

classifier.fit(or_input, or_output, steps=1000, batch_size=3)

结果：

array([1, 1, 0, 1])

---

steps 是如何工作的

steps 参数指定您运行训练操作的次数。让我举几个例子：

• 使用batch_size = 16 和steps = 10，您将看到总共160 示例
• 在您的示例中，batch_size = 3 和 steps = 1000，算法将看到 3000 示例。事实上，它会看到您提供的 3 个相同示例的 1000 倍

所以，steps 不是 epoch 的数量，而是您运行训练操作的次数，或者您看到新批次的次数。

---

为什么允许steps = 0.05？

在tf.learn 代码中，他们不检查steps 是否为整数。他们只是运行一个while循环检查（this line）：

last_step < max_steps

所以如果max_steps = 0.05，它的行为与max_steps = 1 相同（last_step 在循环中递增）。