python - tutorial - Forma de entrada de la red neuronal LSTM desde el marco de datos

redes neuronales python pdf

Question

Estoy tratando de implementar un LSTM con Keras .

Sé que las LSTM en Keras requieren un tensor 3D con forma (nb_samples, timesteps, input_dim) como entrada. Sin embargo, no estoy del todo seguro de cómo debería ser la entrada en mi caso, ya que tengo solo una muestra de T observaciones para cada entrada, no múltiples muestras, es decir (nb_samples=1, timesteps=T, input_dim=N) . ¿Es mejor dividir cada una de mis entradas en muestras de longitud T/M ? T es alrededor de unos pocos millones de observaciones para mí, entonces ¿cuánto tiempo debería ser cada muestra en ese caso, es decir, cómo elegiría M ?

Además, tengo razón en que este tensor debería verse algo así como:

[[[a_11, a_12, ..., a_1M], [a_21, a_22, ..., a_2M], ..., [a_N1, a_N2, ..., a_NM]],
[[b_11, b_12, ..., b_1M], [b_21, b_22, ..., b_2M], ..., [b_N1, b_N2, ..., b_NM]],
...,
[[x_11, x_12, ..., a_1M], [x_21, x_22, ..., x_2M], ..., [x_N1, x_N2, ..., x_NM]]]

donde M y N se definieron como antes y x corresponde a la última muestra que habría obtenido de la división como se discutió anteriormente?

Finalmente, dado un marco de datos de pandas con T observaciones en cada columna, y N columnas, una para cada entrada, ¿cómo puedo crear tal entrada para alimentar a Keras?

Answer 1

A continuación se muestra un ejemplo que establece datos de series de tiempo para entrenar un LSTM. El resultado del modelo no tiene sentido ya que solo lo configuré para demostrar cómo construir el modelo.

import pandas as pd
import numpy as np
# Get some time series data
df = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/timeseries.csv")
df.head()

Marco de datos de series de tiempo:

Date A B C D E F G
0 2008-03-18 24.68 164.93 114.73 26.27 19.21 28.87 63.44
1 2008-03-19 24.18 164.89 114.75 26.22 19.07 27.76 59.98
2 2008-03-20 23.99 164.63 115.04 25.78 19.01 27.04 59.61
3 2008-03-25 24.14 163.92 114.85 27.41 19.61 27.84 59.41
4 2008-03-26 24.44 163.45 114.84 26.86 19.53 28.02 60.09

Puede construir entradas de entrada en un vector y luego usar la función pandas .cumsum() para construir la secuencia de la serie de tiempo:

# Put your inputs into a single list
df[''single_input_vector''] = df[input_cols].apply(tuple, axis=1).apply(list)
# Double-encapsulate list so that you can sum it in the next step and keep time steps as separate elements
df[''single_input_vector''] = df.single_input_vector.apply(lambda x: [list(x)])
# Use .cumsum() to include previous row vectors in the current row list of vectors
df[''cumulative_input_vectors''] = df.single_input_vector.cumsum()

La salida se puede configurar de manera similar, pero será un vector único en lugar de una secuencia:

# If your output is multi-dimensional, you need to capture those dimensions in one object
# If your output is a single dimension, this step may be unnecessary
df[''output_vector''] = df[output_cols].apply(tuple, axis=1).apply(list)

Las secuencias de entrada tienen que tener la misma longitud para ejecutarlas a través del modelo, por lo que debe rellenarlas para que sean la longitud máxima de sus vectores acumulativos:

# Pad your sequences so they are the same length
from keras.preprocessing.sequence import pad_sequences
max_sequence_length = df.cumulative_input_vectors.apply(len).max()
# Save it as a list
padded_sequences = pad_sequences(df.cumulative_input_vectors.tolist(), max_sequence_length).tolist()
df[''padded_input_vectors''] = pd.Series(padded_sequences).apply(np.asarray)

Los datos de entrenamiento pueden extraerse del marco de datos y colocarse en matrices numpy. Tenga en cuenta que los datos de entrada que salen de la estructura de datos no formarán una matriz tridimensional. Hace una matriz de matrices, que no es lo mismo.

Puede usar hstack y remodelar para crear una matriz de entrada 3D.

# Extract your training data
X_train_init = np.asarray(df.padded_input_vectors)
# Use hstack to and reshape to make the inputs a 3d vector
X_train = np.hstack(X_train_init).reshape(len(df),max_sequence_length,len(input_cols))
y_train = np.hstack(np.asarray(df.output_vector)).reshape(len(df),len(output_cols))

Probarlo:

>>> print(X_train_init.shape)
(11,)
>>> print(X_train.shape)
(11, 11, 6)
>>> print(X_train == X_train_init)
False

Una vez que tenga los datos de entrenamiento, puede definir las dimensiones de su capa de entrada y las capas de salida.

# Get your input dimensions
# Input length is the length for one input sequence (i.e. the number of rows for your sample)
# Input dim is the number of dimensions in one input vector (i.e. number of input columns)
input_length = X_train.shape[1]
input_dim = X_train.shape[2]
# Output dimensions is the shape of a single output vector
# In this case it''s just 1, but it could be more
output_dim = len(y_train[0])

Construye el modelo:

from keras.models import Model, Sequential
from keras.layers import LSTM, Dense
# Build the model
model = Sequential()
# I arbitrarily picked the output dimensions as 4
model.add(LSTM(4, input_dim = input_dim, input_length = input_length))
# The max output value is > 1 so relu is used as final activation.
model.add(Dense(output_dim, activation=''relu''))
model.compile(loss=''mean_squared_error'',
optimizer=''sgd'',
metrics=[''accuracy''])

Finalmente puede entrenar el modelo y guardar el registro de entrenamiento como historial:

# Set batch_size to 7 to show that it doesn''t have to be a factor or multiple of your sample size
history = model.fit(X_train, y_train,
batch_size=7, nb_epoch=3,
verbose = 1)

Salida:

Epoch 1/3
11/11 [==============================] - 0s - loss: 3498.5756 - acc: 0.0000e+00
Epoch 2/3
11/11 [==============================] - 0s - loss: 3498.5755 - acc: 0.0000e+00
Epoch 3/3
11/11 [==============================] - 0s - loss: 3498.5757 - acc: 0.0000e+00

Eso es. Use model.predict(X) donde X tiene el mismo formato (diferente al número de muestras) como X_train para hacer predicciones desde el modelo.

Answer 2

Forma de Tensor

Tienes razón en que Keras está esperando un tensor 3D para una red neuronal LSTM, pero creo que la pieza que te falta es que Keras espera que cada observación tenga múltiples dimensiones .

Por ejemplo, en Keras he usado vectores de palabras para representar documentos para el procesamiento del lenguaje natural. Cada palabra del documento está representada por un vector numérico n-dimensional (por lo tanto, si n = 2 la palabra "cat" se representaría con algo así como [0.31, 0.65] ). Para representar un solo documento, los vectores de palabras se alinean en secuencia (por ejemplo, ''The cat sat.'' = [[0.12, 0.99], [0.31, 0.65], [0.94, 0.04]] ). Un documento sería una muestra única en una Keras LSTM.

Esto es análogo a las observaciones de su serie temporal. Un documento es como una serie temporal, y una palabra es como una observación única en su serie temporal, pero en su caso es solo que la representación de su observación es n = 1 dimensión.

Por eso, creo que su tensor debería ser algo así como [[[a1], [a2], ... , [aT]], [[b1], [b2], ..., [bT]], ..., [[x1], [x2], ..., [xT]]] , donde x corresponde a nb_samples , timesteps = T , y input_dim = 1 , porque cada una de tus observaciones es solo un número.

Tamaño del lote

El tamaño del lote debe configurarse para maximizar el rendimiento sin exceder la capacidad de memoria en su máquina, según esta publicación de Cross Validated . Por lo que sé, su información de entrada no necesita ser un múltiplo del tamaño de su lote, ni cuando entrena el modelo y hace predicciones a partir de él.

Ejemplos

Si está buscando código de muestra, en el Keras Github hay varios ejemplos que usan LSTM y otros tipos de red que tienen entrada secuenciada.