神经网络的函数逼近 - 损失 0

Question

我正在尝试创建一个 NN 来近似函数（正弦、余弦、自定义...），但我在格式上遇到困难，我不想使用输入标签，而是输入-输出。我该如何更改它？

import tensorflow as tf
import random
from math import sin
import numpy as np


n_nodes_hl1 = 500
n_nodes_hl2 = 500
n_nodes_hl3 = 500

n_inputs = 1 # CHANGES HERE
n_outputs = 1 #CHANGES HERE
batch_size = 100

x = tf.placeholder('float', [None, n_inputs]) #CHANGES HERE
y = tf.placeholder('float', [None, n_outputs]) #CHANGES HERE

def neural_network_model(data):
    hidden_layer_1 = {'weights':tf.Variable(tf.random_normal([n_inputs, n_nodes_hl1])),
                      'biases': tf.Variable(tf.random_normal([n_nodes_hl1]))} #CHANGES HERE

    hidden_layer_2 = {'weights':tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])),
                      'biases': tf.Variable(tf.random_normal([n_nodes_hl2]))}

    hidden_layer_3 = {'weights':tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])),
                      'biases': tf.Variable(tf.random_normal([n_nodes_hl2]))}

    output_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl3, n_outputs])),
                    'biases': tf.Variable(tf.random_normal([n_outputs]))} #CHANGES HERE


    l1 = tf.add(tf.matmul(data, hidden_layer_1['weights']), hidden_layer_1['biases'])
    l1 = tf.nn.relu(l1)


    l2 = tf.add(tf.matmul(l1, hidden_layer_2['weights']), hidden_layer_2['biases'])
    l2 = tf.nn.relu(l2)

    l3 = tf.add(tf.matmul(l2, hidden_layer_3['weights']), hidden_layer_3['biases'])
    l3 = tf.nn.relu(l3)

    output = tf.add(tf.matmul(l3, output_layer['weights']), output_layer['biases'])

    return output

def train_neural_network(x):
    prediction = neural_network_model(x)
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction, labels=y))

    optmizer = tf.train.AdamOptimizer().minimize(cost)

    epochs = 10

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        for epoch in range(epochs): 
            loss = 0
            for _ in range(batch_size^2): #CHANGES HERE
                batch_x, batch_y = generate_input_output(batch_size) #CHANGES HERE
                a, c = sess.run([optmizer, cost], feed_dict={x: batch_x, y:batch_y})
                loss += c
            print("Epoch:", epoch+1, "out of", epochs, "- Loss:", loss)

        correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(y,1))
        accuracy = tf.reduce_mean(tf.cast(correct, 'float'))

        test_x, test_y = generate_input_output(batch_size) #CHANGES HERE

        print('Accuracy', accuracy.eval({x:test_x, y:test_y}))

def desired_function(x): #CHANGES HERE
    return sin(x)

def generate_input_output(batch_size): #CHANGES HERE
    batch_x = [random.uniform(-10, 10) for _ in range(batch_size)]
    batch_y = [desired_function(x) for x in batch_x]
    batch_x = np.reshape(batch_x, (-1, 1))
    batch_y = np.reshape(batch_y, (-1, 1))
    return batch_x, batch_y

train_neural_network(x)

Answer 1

我自己还没有尝试过，所以您可能需要更改更多的东西才能使模型达到运行，但您肯定会想要更改此行：

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

更像是：

cost = tf.reduce_sum(tf.square(prediction - y))

基本上，在这种情况下，您的成本函数要简单得多...您只想减少网络输出与预期 y 值之间的平方差之和。

Answer 2

我觉得你的解决方案非常冗长。我会 post 一个更简单的解决方案，你能指出其中哪一部分你不明白吗？

import tensorflow as tf
import numpy as np

n_nodes_hl1 = 500
n_nodes_hl2 = 500
n_nodes_hl3 = 500
batch_size = 100

x = tf.placeholder('float', [None, 1])
y = tf.placeholder('float', [None, 1])

x1 = tf.contrib.layers.fully_connected(x, n_nodes_hl1)
x2 = tf.contrib.layers.fully_connected(x1, n_nodes_hl2)
x3 = tf.contrib.layers.fully_connected(x2, n_nodes_hl3)
result = tf.contrib.layers.fully_connected(x3, 1,
                                           activation_fn=None)

loss = tf.nn.l2_loss(result - y)

train_op = tf.train.AdamOptimizer().minimize(loss)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for i in range(10000):
        xpts = np.random.rand(batch_size) * 10
        ypts = np.sin(xpts)

        _, loss_result = sess.run([train_op, loss],
                                  feed_dict={x: xpts[:, None],
                                             y: ypts[:, None]})

        print('iteration {}, loss={}'.format(i, loss_result))

在我看来，你的解决方案是用于分类的，你没有完全重写它用于回归，因为那里还剩下 softmax_cross_entropy_with_logits 之类的东西，你肯定不希望在回归中网络。

神经网络的函数逼近 - 损失 0

Function approximation with Neural Network - Loss 0

python

approximation

neural-network

tensorflow