Tengo un conjunto de datos X que consiste en N = 4000 muestras, cada muestra se compone de d = 2 características (valores continuos) que abarca t = 10 pasos de tiempo. Yo también tengo el correspondiente «etiquetas» de cada una de las muestras que son también valores continuos, en el momento del paso 11.

En el momento en que mi conjunto de datos está en la forma X: [4000,20], Y: [4000].

Quiero formar una LSTM utilizando TensorFlow para predecir el valor de Y (regresión), dado los 10 anteriores entradas de d características, pero estoy teniendo un momento difícil la aplicación de este en TensorFlow.

El principal problema que tenemos en este momento es la comprensión de cómo TensorFlow está a la espera de la entrada para ser formateado. He visto varios ejemplos como el de este, pero estos ejemplos lidiar con una gran cadena continua de datos de series de tiempo. Mis datos son diferentes muestras, cada una independiente de la serie de tiempo.

Hola, estoy tratando de implementar algo muy similar a lo que hizo, y espero que usted me puede dar algunos consejos desde tensorflow todavía es alucinante para mí. Para su instalación, ¿cómo funciona el archivo de entrada parecen realmente? Es cada una de las muestras, básicamente, una lista de longitud 10 con cada elemento que contiene el 2 de funciones y para cada una de las muestras tiene una etiqueta? por ejemplo, [[f1,f2], [f1,f2], …]

OriginalEl autor Renier Botha | 2016-09-05

2 Comentarios

  1. 9

    La documentación de tf.nn.dynamic_rnn estados:

    inputs: La RNN entradas. Si time_major == False (por defecto), este debe ser un Tensor de la forma: [batch_size, max_time, ...], o anidada tupla de tales elementos.

    En su caso, esto significa que la entrada debe tener una forma de [batch_size, 10, 2]. En lugar de la formación en todos los 4000 secuencias a la vez, tendría que utilizar sólo batch_size muchos de ellos en cada iteración. Algo similar a lo siguiente debería de trabajo (añadido remodelar para mayor claridad):

    batch_size = 32
    # batch_size sequences of length 10 with 2 values for each timestep
    input = get_batch(X, batch_size).reshape([batch_size, 10, 2])
    # Create LSTM cell with state size 256. Could also use GRUCell, ...
    # Note: state_is_tuple=False is deprecated;
    # the option might be completely removed in the future
    cell = tf.nn.rnn_cell.LSTMCell(256, state_is_tuple=True)
    outputs, state = tf.nn.dynamic_rnn(cell,
                                       input,
                                       sequence_length=[10]*batch_size,
                                       dtype=tf.float32)

    De la documentación, outputs será de forma [batch_size, 10, 256], es decir, uno de 256 de salida para cada paso de tiempo. state será un tupla de formas [batch_size, 256]. Se podría predecir su valor final, uno para cada secuencia, de que:

    predictions = tf.contrib.layers.fully_connected(state.h,
                                                    num_outputs=1,
                                                    activation_fn=None)
    loss = get_loss(get_batch(Y).reshape([batch_size, 1]), predictions)

    El número 256 en las formas de outputs y state está determinado por cell.output_size resp. cell.state_size. Cuando la creación de la LSTMCell como los anteriormente mencionados, son el mismo. Ver también el LSTMCell documentación.

    Gracias por la respuesta! Voy a probar esto pronto y vamos a saber si se soluciona mi problema. Una pregunta, sin embargo: ¿qué hace exactamente el 256 consulte en tf.nn.rnn_cell.LSTMCell(256, state_is_tuple=True)? He leído la documentación y el valor se conoce como n_units. ¿Eso significa que el número de pasos de tiempo? es decir, la memoria de la LSTM celular? Lo siento, sé que esto es una extensión de la pregunta original.
    El número de pasos de tiempo en cada secuencia está dada por la sequence_length parámetro que se dan en tf.nn.dynamic_rnn. 256 se refiere al tamaño del estado interno de la LSTM que se actualiza en cada paso de tiempo.
    pregunta: ¿no quieres que tu plenamente conectado capa para las predicciones a tener num_outputs=batch_size? Entonces usted tendría una predicción al final de cada serie de tiempo en el lote?
    Totalmente conectado capa de salida de forma [batch_size, num_outputs], es decir, num_outputs es el número de salidas para cada entrada en su lote.

    OriginalEl autor fwalch

  2. 0

    (Esta respuesta «addres» el problema es que cuando directa np.reformar() no organizar la final de la matriz como queremos. Si queremos directamente remodelar en 3D np.remodelar va a hacer, pero ten cuidado con el final de la organización de la entrada).

    En mi personal intente finalmente resolver este problema de la alimentación de entrada de forma para la RNN y no confundir más, voy a dar mi «personal» explicación para esto.

    En mi caso (y creo que muchos otros pueden tener este esquema de organización en sus matrices), la mayoría de los blogs de fuera «no ayudan». Vamos a darle una oportunidad en cómo convertir un 2D matriz de funciones en 3D en forma de uno de RNNs.

    Supongamos que tenemos este tipo de organización en nuestra matriz de características de: tenemos 5 observaciones (es decir, las filas – para la convención creo que es la más lógica término) y en cada fila, tenemos 2 características para CADA paso de tiempo (y tenemos 2 timesteps), como este:

    (El df es comprender mejor visualmente mis palabras)

    In [1]: import numpy as np                                                           
    
    In [2]: arr = np.random.randint(0,10,20).reshape((5,4))                              
    
    In [3]: arr                                                                          
    Out[3]: 
    array([[3, 7, 4, 4],
           [7, 0, 6, 0],
           [2, 0, 2, 4],
           [3, 9, 3, 4],
           [1, 2, 3, 0]])
    
    In [4]: import pandas as pd                                                          
    
    In [5]: df = pd.DataFrame(arr, columns=['f1_t1', 'f2_t1', 'f1_t2', 'f2_t2'])         
    
    In [6]: df                                                                           
    Out[6]: 
       f1_t1  f2_t1  f1_t2  f2_t2
    0      3      7      4      4
    1      7      0      6      0
    2      2      0      2      4
    3      3      9      3      4
    4      1      2      3      0

    Ahora vamos a tomar los valores a trabajar con ellos. La cosa aquí es que RNNs de incorporar el «intervalo de tiempo» dimensión de su entrada, debido a su architechtural la naturaleza. Podemos imaginar la dimensión de de apilamiento 2D matrices, uno detrás del otro por el número de timesteps tenemos. En este caso, tenemos dos timesteps; así que vamos a tener dos matrices 2D apilados: uno para timestep1 y detrás de eso, el uno para timestep2.

    En realidad, en la que de entrada 3D tenemos que hacer, todavía tenemos 5 observaciones. La cosa es que nos la necesidad de organizar de forma diferente: la RNN tomar la primera fila (o especificado por lotes – pero vamos a mantenerlo simple aquí) de la primera matriz (es decir, timestep1) y la primera fila de la segunda apilados de la matriz (es decir, timestep2). Luego de la segunda fila…hasta el último (el 5º en nuestro ejemplo). So, en cada fila de cada paso de tiempo, tenemos que tener las dos características, por supuesto, separadas en diferentes matrices de cada una correspondiente a su paso de tiempo. Vamos a ver esto con los números.

    Voy a hacer dos matrices para facilitar la comprensión. Recuerde que, debido a nuestro esquema organizativo en el df, usted puede haber notado que tenemos que tomar las dos primeras columnas (es decir, de las características 1 y 2 para el timestep1) como nuestra PRIMERA MATRIZ DE LA PILA y las dos últimas columnas, es decir, la 3ª y la 4ª, nuestra SEGUNDA MATRIZ DE LA PILA, así que todo tiene sentido por último.

    In [7]: arrStack1 = arr[:,0:2]                                                       
    
    In [8]: arrStack1                                                                    
    Out[8]: 
    array([[3, 7],
           [7, 0],
           [2, 0],
           [3, 9],
           [1, 2]])
    
    In [9]: arrStack2 = arr[:,2:4]                                                       
    
    In [10]: arrStack2                                                                   
    Out[10]: 
    array([[4, 4],
           [6, 0],
           [2, 4],
           [3, 4],
           [3, 0]])

    Finalmente, lo único que tenemos que hacer es pila de ambas matrices («una detrás de la otra»), como si fueran parte de la misma estructura final:

    In [11]: arrfinal3D = np.stack([arrStack1, arrStack2])                               
    
    In [12]: arrfinal3D                                                                  
    Out[12]: 
    array([[[3, 7],
            [7, 0],
            [2, 0],
            [3, 9],
            [1, 2]],
    
           [[4, 4],
            [6, 0],
            [2, 4],
            [3, 4],
            [3, 0]]])
    
    In [13]: arrfinal3D.shape                                                            
    Out[13]: (2, 5, 2)

    Que es así: tenemos nuestra matriz de funciones listo para ser alimentado en la RNN celular, teniendo en cuenta nuestra organización de las funciones 2D de la matriz.

    (Para un liner con respecto a todo esto se podría utilizar:

    In [14]: arrfinal3D_1 = np.stack([arr[:,0:2], arr[:,2:4]])                           
    
    In [15]: arrfinal3D_1                                                                
    Out[15]: 
    array([[[3, 7],
            [7, 0],
            [2, 0],
            [3, 9],
            [1, 2]],
    
           [[4, 4],
            [6, 0],
            [2, 4],
            [3, 4],
            [3, 0]]])

    ¡Espero que esto ayude!

    OriginalEl autor Ezarate11

Dejar respuesta

Please enter your comment!
Please enter your name here