从Tensorflow获得相反的输出可以学习OR门

Question

鉴于DNN(多层感知器的简单情况)分别具有5个和3个维度的2个隐藏层,我正在训练模型以识别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.]]))

[OUT]:

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)

[OUT]:

[[ 0.99998868]
 [ 0.99998868]]

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

如何让tensorflow.learn代码生成与"old-school"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不是时期的数量,它是您运行培训操作的次数,或者是您看到新批次的次数.

为什么steps = 0.05允许？

在tf.learn代码中,它们不检查是否steps为整数.他们只是运行一个while循环检查(在这一行):

last_step < max_steps

因此,如果max_steps = 0.05,它的行为与if相同max_steps = 1(last_step在循环中递增).