python - 通过使用梯度下降法，使用 theano 计算神经网络的最佳输入。输入

Question

我已经使用 Theano 实现并训练了一个具有 k 个二进制输入 (0,1)、一个隐藏层和一个输出层单元的神经网络。一旦经过训练，我希望获得最大化输出的输入(例如，x 使输出层的单位最接近 1)。到目前为止我还没有找到它的实现，所以我正在尝试以下方法:

1. 训练网络 => 获取经过训练的权重(theta1、theta2)
2. 定义神经网络函数，以x为输入，并训练theta1、theta2作为固定参数。即:f(x) = sigmoid( theta1*(sigmoid (theta2*x )))。该函数接受 x 并使用给定的训练权重(theta1、theta2)给出 0 到 1 之间的输出。
3. 应用梯度下降法x 上的神经网络函数 f(x) 并获得在给定 theta1 和 theta2 的情况下最大化 f(x) 的 x。

对于这些，我用一个玩具示例实现了以下代码(k = 2)。基于 http://outlace.com/Beginner-Tutorial-Theano/ 上的教程但改变了向量 y，因此只有一种输入组合可以给出 f(x) ~ 1，即 x = [0, 1]。

Edit1:按照建议，optimizer 设置为 None，偏差单位固定为 1。第 1 步:训练神经网络。这运行良好并且没有错误。

import os
os.environ["THEANO_FLAGS"] = "optimizer=None"
import theano
import theano.tensor as T
import theano.tensor.nnet as nnet
import numpy as np

x = T.dvector()
y = T.dscalar()

def layer(x, w):
    b = np.array([1], dtype=theano.config.floatX)
    new_x = T.concatenate([x, b])
    m = T.dot(w.T, new_x) #theta1: 3x3 * x: 3x1 = 3x1 ;;; theta2: 1x4 * 4x1
    h = nnet.sigmoid(m)
    return h

def grad_desc(cost, theta):
    alpha = 0.1 #learning rate
    return theta - (alpha * T.grad(cost, wrt=theta))

in_units = 2
hid_units = 3
out_units = 1

theta1 = theano.shared(np.array(np.random.rand(in_units + 1, hid_units), dtype=theano.config.floatX)) # randomly initialize
theta2 = theano.shared(np.array(np.random.rand(hid_units + 1, out_units), dtype=theano.config.floatX))

hid1 = layer(x, theta1) #hidden layer

out1 = T.sum(layer(hid1, theta2)) #output layer
fc = (out1 - y)**2 #cost expression

cost = theano.function(inputs=[x, y], outputs=fc, updates=[
        (theta1, grad_desc(fc, theta1)),
        (theta2, grad_desc(fc, theta2))])
run_forward = theano.function(inputs=[x], outputs=out1)

inputs = np.array([[0,1],[1,0],[1,1],[0,0]]).reshape(4,2) #training data X
exp_y = np.array([1, 0, 0, 0]) #training data Y
cur_cost = 0
for i in range(5000):
    for k in range(len(inputs)):
        cur_cost = cost(inputs[k], exp_y[k]) #call our Theano-compiled cost function, it will auto update weights

print(run_forward([0,1]))

[0,1] 的向前运行输出为:0.968905860574。我们还可以使用 theta1.get_value() 和 theta2.get_value()

获取权重值

第 2 步:定义神经网络函数 f(x)。训练后的权重(theta1、theta2)是该函数的常量参数。

由于偏置单元是输入 x 向量的一部分，事情变得有点棘手。为此，我连接 b 和 x。但现在代码运行良好。

b = np.array([[1]], dtype=theano.config.floatX)
#b_sh = theano.shared(np.array([[1]], dtype=theano.config.floatX))
rand_init = np.random.rand(in_units, 1)
rand_init[0] = 1
x_sh = theano.shared(np.array(rand_init, dtype=theano.config.floatX))
th1 = T.dmatrix()
th2 = T.dmatrix()

nn_hid = T.nnet.sigmoid( T.dot(th1, T.concatenate([x_sh, b])) )
nn_predict = T.sum( T.nnet.sigmoid( T.dot(th2, T.concatenate([nn_hid, b]))))

第 3 步:现在的问题是梯度下降，因为它不限于 0 到 1 之间的值。 fc2 = (nn_predict - 1)**2

cost3 = theano.function(inputs=[th1, th2], outputs=fc2, updates=[
        (x_sh, grad_desc(fc2, x_sh))])
run_forward = theano.function(inputs=[th1, th2], outputs=nn_predict)

cur_cost = 0
for i in range(10000):

cur_cost = cost3(theta1.get_value().T, theta2.get_value().T) #call our Theano-compiled cost function, it will auto update weights
if i % 500 == 0: #only print the cost every 500 epochs/iterations (to save space)
    print('Cost: %s' % (cur_cost,))
    print x_sh.get_value()

最后一次迭代打印: 成本:0.000220317356533 [[-0.11492753] [1.99729555]]

此外，输入 1 不断变得更负，输入 2 不断增加，而最优解为 [0, 1]。如何解决这个问题？

Answer 1

您通过广播规则添加 b=[1]，而不是连接它。另外，一旦您将其连接起来，您的 x_sh 就会具有一维到多维的特征，这就是为什么错误发生在 nn_predict 而不是 nn_hid