Comment contrôler la taille de sortie d'une cellule LSTM en tensorflow

Question

J'ai essayé de construire un exemple simple d'utilisation d'un RNN LSTM via Tensorflow pour prédire les valeurs de séries temporelles de certaines séries cibles, avec des séries temporelles d'entrée connues.

Link to example problem

Je suis en train de

what I try to accomplish formally

En substance, je pense que la sortie du convertisseur A cellulaire et la mult matrice suivante devrait fonctionner comme:

X = np.zeros([40,2,1]) 
A = np.zeros([40,1,2]) 
b = np.arange(0,2) 

X = tf.convert_to_tensor(X) 
A = tf.convert_to_tensor(A) 
b = tf.convert_to_tensor(b) 

Y = tf.matmul(X,A)+b 

Le tensorflow code est configuré pour afficher les tailles de sortie, et pas avec fonctionnel tf.graph/session:

import numpy as np 
import tkinter 
import matplotlib.pyplot as plt 
import tensorflow as tf 
n=40 
x = np.linspace(0,10,n) 
y1 = np.sin(x) 
y2 = np.cos(x) 

x1=np.random.normal(0,y1**2,n) 
x2=np.random.normal(0,y2**2,n) 

y1=(y1**2>0.4)*1 
y2=(y2**2>0.4)*1 

ys = np.vstack((y1,y2)) 
xs = np.vstack((x1,x2)) 

def plot_results_multiple(xs, ys): 
    fig = plt.figure(facecolor='white') 
    ax = fig.add_subplot(111) 
    for i, data in enumerate(xs): 
     plt.plot(data, label='x'+str(i)) 
     plt.legend() 
    for i, data in enumerate(ys): 
     plt.plot(data, label='y'+str(i)) 
     plt.legend() 
    plt.show() 

plot_results_multiple(xs,ys) 

xs = xs.T 
ys = ys.T 

print("Shape of arrays " +str(xs.shape) + " " +str(ys.shape)) 


batch_size = 1 
lstm_size = 1 
nseries = 2 
time_steps = 40 
nclasses = 2 

lstm = tf.contrib.rnn.BasicLSTMCell(lstm_size,state_is_tuple=True) 
stacked_lstm = tf.contrib.rnn.MultiRNNCell([lstm] * 2, state_is_tuple=True) 

state = lstm.zero_state(batch_size, tf.float32) 
inputs = tf.unstack(xs, num=40, axis=0) 

outputs = [] 

with tf.variable_scope("RNN"): 
    for timestep in range(time_steps): 
     if timestep > 0: tf.get_variable_scope().reuse_variables() 
     output, state = lstm(tf.cast(tf.reshape(inputs[timestep],[1,nseries]),tf.float32), state) 
     print(tf.convert_to_tensor(output).get_shape()) 
     outputs.append(output) 

print(tf.convert_to_tensor(outputs).get_shape()) 
output = tf.reshape(tf.concat(outputs, 1), [-1, lstm_size]) 
softmax_w = tf.get_variable(
    "softmax_w", [time_steps, 1,nclasses],tf.float32)# dtype= 
print(softmax_w.get_shape()) 
softmax_b = tf.get_variable("softmax_b", [nseries], dtype=tf.float32) 
print(softmax_b.get_shape()) 
logits = tf.matmul(output, softmax_w) + softmax_b 

print(logits.get_shape()) 

Je pense que le problème que je vais avoir est de déterminer comment modifier la cellule RNN LSTM, comme il est restituent un tenseur 1x1, à partir d'une entrée de 2x1, où je me attends un 2x1 eteint. Toute aide est fortement appréciée.

Answer 1

Il est contrôlé par les unités de neurones cachés qui est le premier paramètre de tf.contrib.rnn.BasicLSTMCell (lstm_size, state_is_tuple)

Le code source est ici: https://github.com/tensorflow/tensorflow/blob/b0ecc7d2c1486367ec65d297e372f8935ee3ddfe/tensorflow/python/ops/rnn_cell_impl.py#254

@property 
    def output_size(self): 
    return self._num_units 

Donc, si vous voulez changer la taille de sortie, vous devez changer le nombre de unités de tf.contrib.rnn.BasicLSTMCell.