2

我想在 Tensorflow 中调整这个循环神经网络(来自本教程
https://github.com/aymericdamien/TensorFlow-Examples/
,然后是 RNN 程序),这样它将成为一个去噪自动编码器。我有 5 个时间步长,每次从 sin(x) 中采样无噪声目标,噪声输入为 sin(x)+ 高斯误差。现在我的问题是示例中的 RNN 为每个输入序列提供了 1 个输出值,但我想要每个时间步的输出(我想要 5 个输出,而不是 1)我该怎么做?我怀疑这可能是重新定义权重和偏差的问题,但是如何?这是代码。非常感谢您的帮助,

import tensorflow as tf
from tensorflow.python.ops import rnn, rnn_cell
import numpy as np


# Parameters
learning_rate = 0.0005
training_iters = 1000
batch_size = 3
display_step = 100

# Network Parameters
n_input = 2 
n_output = 2
n_steps = 5 # timesteps
n_hidden = 40 # hidden layer num of features

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_steps, n_input])

# Define weights
weights = {
   'out': tf.Variable(tf.random_normal([n_hidden, n_output]))
}
biases = {
    'out': tf.Variable(tf.random_normal([ n_output]))
}


# length of time series to be sampled
N = 1000000
dim_input = 2
x1 = np.zeros(N)
x2 = np.zeros(N)
y1 = np.zeros(N)
y2 = np.zeros(N)



# generate data
for i in range(0,N):
    # clean
    y1[i] = np.math.sin(i)
    y2[i] = np.math.cos(i)

    # noisy 
    x1[i] = y1[i]+np.random.normal(loc=0.0, scale=0.05)
    x2[i] = y2[i]+np.random.normal(loc=0.0, scale=0.05)


def next_batch():

   batch = np.empty([batch_size,n_steps,dim_input])
   batch_y = np.empty([batch_size,n_steps,dim_input])
   # for plotting purposes only
   inits = np.empty([batch_size], dtype=int)
   for b in range(0,batch_size):
      # the first one of the batch
      inits[b] = int(np.round(np.random.uniform(low=0,high=N-n_steps-  1)))
    init = inits[b]

    for i in range(0,n_steps):
        # noisy input
        batch[b,i,0] = x1[init + i]
        batch[b,i,1] = x2[init + i]
        # target (no noise)"
        batch_y[b,i,0] = y1[init+i]
        batch_y[b,i,1] = y2[init+i]



    return(batch,batch_y,inits)

def RNN(x, weights, biases):

   x = tf.transpose(x, [1, 0, 2])
   # Reshaping to (n_steps*batch_size, n_input)
   x = tf.reshape(x, [-1, n_input])
   # Split to get a list of 'n_steps' tensors of shape (batch_size, n_input)
   x = tf.split(0, n_steps, x)

   # Define a lstm cell with tensorflow
   lstm_cell = rnn_cell.BasicLSTMCell(n_hidden, forget_bias=1.0)

   # Get lstm cell output
   outputs, states = rnn.rnn(lstm_cell, x, dtype=tf.float32)

   # Linear activation, using rnn inner loop last output
   return tf.matmul(outputs[-1], weights['out']) + biases['out']


   pred = RNN(x, weights, biases)

# Define loss and optimizer
# SSE, there must be an easier way to do this
def get_cost(prediction,truth):
    z = 0
    for i in range(0,batch_size):
       z = z + np.square(np.add(prediction[i,:],   np.multiply(-1,truth[i,:])))
    z = np.add(z[0],z[1])
    z = np.sum(z)
    return(z)

cost =  get_cost(pred,y)
optimizer =  tf.train.AdamOptimizer(learning_rate=learning_rate).
   minimize(cost)

# Evaluate model
accuracy = cost

# Initializing the variables
init = tf.initialize_all_variables()

# Launch the graph
with tf.Session() as sess:
    sess.run(init)
    step = 1
    # Keep training until reach max iterations
    while step * batch_size < training_iters:
        print('step '+ str(step))
        batch_x, batch_y, inits = next_batch()

        sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
        if step % display_step == 0:

            # Calculate batch accuracy
            acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
            # Calculate batch loss
            loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
            print(loss)

    step += 1
    print("Optimization Finished!")

如果我运行它,我会收到以下错误消息:ValueError: Shape (?, 5, 2) must have rank 2。这看起来很公平,因为目标是 5 步长,输出只有 1。但是我该如何解决那?

非常感谢。

4

2 回答 2

1
import tensorflow as tf
from tensorflow.python.ops import rnn, rnn_cell
import numpy as np
import matplotlib.pyplot as plt

## Denoising autoencoder.  

import numpy as np

count = 0
# length of time series to be sampled  
N = 10000

x1 = np.zeros(N)
x2 = np.zeros(N)
y1 = np.zeros(N)
y2 = np.zeros(N)
batch_size = 30
learning_rate = 0.0005
training_iters = 300000
display_step = 100
# Network Parameters
n_input = 2 
n_output = 2
n_steps = 15 # timesteps
n_hidden = 75 # hidden layer num of


# generate data
for i in range(0,N):
# clean
y1[i] = np.math.sin(i)
y2[i] = np.math.cos(i)

# noisy 
x1[i] = y1[i]+np.random.normal(loc=0.0, scale=0.1)
x2[i] = y2[i]+np.random.normal(loc=0.0, scale=0.1)


def next_batch():

   batch = np.empty([batch_size,n_steps,n_input])
   batch_y = np.empty([batch_size,n_steps,n_input])
   # for plotting purposes only
   inits = np.empty([batch_size], dtype=int)
   for b in range(0,batch_size):
       # the first one of the batch
       inits[b] = int(np.round(np.random.uniform(low=0,high=N-n_steps-1)))
    init = inits[b]

    for i in range(0,n_steps):
        # noisy input
        batch[b,i,0] = x1[init + i]
        batch[b,i,1] = x2[init + i]
        # target (no noise)"
        batch_y[b,i,0] = y1[init+i]
        batch_y[b,i,1] = y2[init+i]

        return(batch,batch_y,inits)


# Parameters

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_steps, n_output])

N_train = N - 500

def RNN(x):

   # Prepare data shape to match `rnn` function requirements
   # Current data input shape: (batch_size, n_steps, n_input)
   # Required shape: 'n_steps' tensors list of shape (batch_size, n_input)

   # Permuting batch_size and n_steps
   x = tf.transpose(x, [1, 0, 2])
   # Reshaping to (n_steps*batch_size, n_input)
   x = tf.reshape(x, [-1, n_input])
   # Split to get a list of 'n_steps' tensors of shape (batch_size, n_input)
   x = tf.split(0, n_steps, x)


   # Define a lstm cell with tensorflow
   lstm_cell = rnn_cell.LSTMCell(num_units = n_hidden,      forget_bias=1.0, num_proj=2)

   # Get lstm cell output
   outputs, states = rnn.rnn(lstm_cell, x, dtype=tf.float32)



   return outputs

   print(x)

pred = RNN(x)

# Define loss and optimizer 
def get_cost(prediction,truth):
   #print('pred' + str(prediction))
   # SSE. there must be an easier way than this:
   z = 0
   for step in range(0,n_steps):
       for b in range(0,batch_size):
           for y_dim in range(0,2):
               d1 = prediction[step][b,y_dim]
               d2 = truth[b,step,y_dim]
               diff= (d1 - d2 )
               z = z + diff * diff
   return(z)

cost =  get_cost(pred,y)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

# Evaluate model

# Initializing the variables
init = tf.initialize_all_variables()


# Launch the graph

with tf.Session() as sess:
   sess.run(init)
   step = 1
   # Keep training until reach max iterations
   while step * batch_size < training_iters:
       #print('step '+ str(step))
       batch_x, batch_y, inits = next_batch()

       # Reshape data to get 28 seq of 28 elements
       #batch_x = batch_x.reshape((batch_size, n_steps, n_input))
       # Run optimization op (backprop)
       sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
    if step % display_step == 0:

        # Calculate batch loss
        loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
        print(str(step) + ':' + str(loss))

    step += 1
print("Optimization Finished!")


batch_size = 1

test_data, test_label, inits = next_batch()
#print "Testing Accuracy:", \
#sess.run(accuracy, feed_dict={x: test_data, y: test_label})
p2 = sess.run(pred, feed_dict={x: test_data, y: test_label})
#print('---inits---')
#print(inits)


print('---batch---')
print(test_data)
print('---truth---')
print(test_label)
print('---pred---')
print(p2)


c_final = get_cost(p2, test_label)
print(c_final)
于 2016-12-18T18:57:36.093 回答
0

首先,我们生成一些数据:sin(i) 和 cos(i) 的二维序列,其中 i 从 1 到 N。这给了我们变量 y。然后我们在这个序列中添加一些 Normal 噪声,这就是 x。然后,我们训练一个循环神经网络,从嘈杂的输入中创建干净的输出。换句话说,我们训练网络使其从输入 [cos(i)+e1,sin(i)+e2) ] 输出 [cos(i),sin(i)]。这是一个普通的去噪自动编码器,除了数据有一个时间元素。现在你可以将新数据输入神经网络,它有望消除噪音。

于 2016-12-19T20:55:31.327 回答