Modelos MLP de varios pasos

Modelos MLP de varios pasos

En la práctica, hay poca diferencia con el modelo MLP en la predicción de una salida vectorial que representa variables de salida diferentes (como en el ejemplo anterior) o una salida vectorial que representa múltiples pasos de tiempo de una variable. Sin embargo, hay sutiles e importantes diferencias en la forma en que se preparan los datos de la formación. En esta sección, vamos a demostrar el
en el caso de desarrollar un modelo de pronóstico de varios pasos utilizando un modelo vectorial. Antes de que miremos el
especificidades del modelo, veamos en primer lugar la preparación de los datos para la previsión de varios pasos.

Preparación de datos

Al igual que con el pronóstico de un solo paso, una serie de tiempo utilizada para el pronóstico de series de tiempo de varios pasos debe ser dividido en muestras con componentes de entrada y salida. Tanto los componentes de entrada como de salida estará compuesto de múltiples pasos de tiempo y puede o no tener el mismo número de pasos. Por ejemplo, dada la serie temporal univariada:

[10, 20, 30, 40, 50, 60, 70, 80, 90]

Podríamos usar los últimos tres pasos de tiempo como entrada y pronosticar los próximos dos pasos de tiempo. La primera muestra tendría el siguiente aspecto:

Entrada:

[10, 20, 30]

Salida:

[40, 50]

La función split_sequence() que se muestra a continuación implementa este comportamiento y dividirá una secuencia determinada de series temporales univariadas en muestras con un número determinado de pasos temporales de entrada y salida.

# dividir una secuencia univariada en muestras
def split_sequence(sequence, n_steps_in, n_steps_out):
  X, y = list(), list()
  for i in range(len(sequence)):
    # encontrar el final de este patron
    end_ix = i + n_steps_in
    out_end_ix = end_ix + n_steps_out
    # comprobar si estamos mas alla de la secuencia
    if out_end_ix > len(sequence):
     break
    # romper las partes de entrada y salida del patron
    seq_x, seq_y = sequence[i:end_ix], sequence[end_ix:out_end_ix]
    X.append(seq_x)
    y.append(seq_y)
  return array(X), array(y)

Podemos demostrar esta función en el pequeño conjunto de datos creado. El ejemplo completo es que se enumeran a continuación.

# preparacion de los datos en varios pasos
from numpy import array
# dividir una secuencia univariada en muestras
def split_sequence(sequence, n_steps_in, n_steps_out):
  X, y = list(), list()
  for i in range(len(sequence)):
    # encontrar el final de este patron
    end_ix = i + n_steps_in
    out_end_ix = end_ix + n_steps_out
    # comprobar si estamos mas alla de la secuencia
    if out_end_ix > len(sequence):
     break
    # reunir las partes de entrada y salida del patron
    seq_x, seq_y = sequence[i:end_ix], sequence[end_ix:out_end_ix]
    X.append(seq_x)
    y.append(seq_y)
  return array(X), array(y)
# definir la secuencia de entrada
raw_seq = [10, 20, 30, 40, 50, 60, 70, 80, 90]
# elegir un numero de pasos de tiempo
n_steps_in, n_steps_out = 3, 2
# dividir en muestras
X, y = split_sequence(raw_seq, n_steps_in, n_steps_out)
# reunir los datos
for i in range(len(X)):
  print(X[i], y[i])

Al ejecutar el ejemplo se divide la serie univariante en pasos de tiempo de entrada y salida y se imprime los componentes de entrada y salida de cada uno de ellos.

[10 20 30] [40 50]
[20 30 40] [50 60]
[30 40 50] [60 70]
[40 50 60] [70 80]
[50 60 70] [80 90]

Ahora que sabemos cómo preparar los datos para el pronóstico de varios pasos, veamos un MLP que puede aprender este mapeo.

Modelo de salida vectorial

El MLP puede emitir un vector directamente que puede ser interpretado como un pronóstico de varios pasos. Este
en la sección anterior, donde un paso de cada serie de tiempo de salida era pronosticado como un vector. Con el número de pasos de entrada y salida especificados en los pasos y en los pasos fuera de las variables, podemos diseñar un modelo de pronóstico de series de tiempo de varios pasos.

# definir modelo
model = Sequential()
model.add(Dense(100, activation='relu', input_dim=n_steps_in))
model.add(Dense(n_steps_out))
model.compile(optimizer='adam', loss='mse')

El modelo puede hacer una predicción para una sola muestra. Podemos predecir los siguientes dos pasos más allá del final del conjunto de datos proporcionando en la entrada:

[70, 80, 90]

Es de esperar que el resultado previsto sea:

[100, 110]

Como se espera en el modelo, la forma de la muestra única de datos de entrada al hacer la predicción debe ser [1, 3] para los pasos de 1 muestra y 3 tiempos (features) de la entrada y de la salida.

# demostrar prediccion
x_input = array([70, 80, 90])
x_input = x_input.reshape((1, n_steps_in))
yhat = model.predict(x_input, verbose=0)

Enlazando todo esto, el MLP para la previsión de varios pasos con una serie temporal univariada que se enumeran a continuación.

# ejemplo univariante de vector de salida vectorial de varios pasos
from numpy import array
from keras.models import Sequential
from keras.layers import Dense
# dividir una secuencia univariada en muestras
def split_sequence(sequence, n_steps_in, n_steps_out):
  X, y = list(), list()
  for i in range(len(sequence)):
    # encontrar el final de este patron
    end_ix = i + n_steps_in
    out_end_ix = end_ix + n_steps_out
    # comprobar si estamos mas alla de la secuencia
    if out_end_ix > len(sequence):
     break
    # recoger las partes de entrada y salida del patron
    seq_x, seq_y = sequence[i:end_ix], sequence[end_ix:out_end_ix]
    X.append(seq_x)
    y.append(seq_y)
  return array(X), array(y)
# definir la secuencia de entrada
raw_seq = [10, 20, 30, 40, 50, 60, 70, 80, 90]
# elegir un numero de pasos de tiempo
n_steps_in, n_steps_out = 3, 2
# dvidir en muestras
X, y = split_sequence(raw_seq, n_steps_in, n_steps_out)
# definir modelo
model = Sequential()
model.add(Dense(100, activation='relu', input_dim=n_steps_in))
model.add(Dense(n_steps_out))
model.compile(optimizer='adam', loss='mse')
# modelo adecuado
model.fit(X, y, epochs=2000, verbose=0)
# demostrar prediccion
x_input = array([70, 80, 90])
x_input = x_input.reshape((1, n_steps_in))
yhat = model.predict(x_input, verbose=0)
print(yhat)

Ejecutando el ejemplo de pronósticos e imprimiendo los siguientes dos pasos de tiempo en la secuencia.

[[102.572365 113.88405 ]]