Modelos univariados MLP

Modelos univariados MLP

Los Perceptrones multicapa, o MLPs para abreviar, pueden ser usado para modelar problemas de pronóstico de series de tiempo univariadas. Las series temporales univariadas son un conjunto de datos compuesto de una sola serie de observaciones pasadas y predecir el siguiente valor de la secuencia. Este bloque se divide en dos partes; las cuales son:

• Preparación de datos.
• Modelo MLP.

Preparación de datos

Antes de que se pueda modelar una serie univariada, se debe preparar. El modelo MLP aprenderá una función que mapea una secuencia de observaciones pasadas como entrada a una observación de salida. Como tal, la secuencia de observaciones debe transformarse en múltiples ejemplos de los que el modelo pueda aprender. Considere una secuencia univariada dada:

(Ejemplo de una serie temporal univariada)

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

Podemos dividir la secuencia en múltiples patrones de entrada/salida llamados muestras, donde los tres pasos de tiempo son usados como entrada y un paso de tiempo es usado como salida para la predicción de un paso que se está aprendiendo.

(Ejemplo de una serie temporal univariada como problema de aprendizaje supervisado)

X,           y
10, 20, 30,  40
20, 30, 40,  50
30, 40, 50,  60
...

La función split_sequence() implementa un comportamiento y dividirá una secuencia univariada dada en múltiples muestras donde cada muestra tiene un número específico de pasos de tiempo y la salida en un solo paso de tiempo.

(Ejemplo de una función para dividir una serie univariada en un problema de aprendizaje supervisado)

#dividir una secuencia univariada en muestras
def split_sequence(sequence, n_steps):
   X, y = list(), list()
   for i in range(len(sequence)):
     #encontrar el final de esta posicion
     end_ix = i + n_steps
     #comprobar si estamos mas alla de la secuencia
     if end_ix > len(sequence)-1:
       break
     seq_x, seq_y = sequence[i:end_ix], sequence[end_ix]
     X.append(seq_x)
     y.append(seq_y)
   return array(X), array(y)

Podemos demostrar esta función en nuestro pequeño conjunto creado anteriormente.
(Ejemplo de transformación de un serie temporal univariada en un problema de aprendizaje supervisado)

#preparación de datos univariados
from numpy import array

#dividir una secuencia univariada en muestras
def split_sequence(sequence, n_steps):
  X, y = list(), list()
  for i in range(len(sequence)):
    #encuentra el final de este patron
    end_ix = i n_steps
    #comprobar si estamos mas alla de la secuencia
    if end_ix > len(sequence)-1:
      break
    #recoger las partes de entrada y salida del patron
    seq_x, seq_y = sequence[i:end_ix], sequence[i: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]
#seleccionar un numero de pasos de tiempo
n_steps = 3
#definir en muestras
X, y = split_sequence(raw_seq, n_steps)
#resumir los datos
for i in range(len(X)):
  print(X[i], y[i])

Al ejecutar el ejemplo, la serie univariada se divide en seis muestras, donde cada muestra tiene tres pasos de tiempo de entrada y un paso de tiempo de salida.

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

Ahora que sabemos cómo preparar una serie univariada para el modelado, veamos como desarrollo de un modelo MLP que pueda aprender el mapeo de entradas a salida.

Modelo MLP

Un modelo MLP simple tiene una sola capa oculta de nodos, y una capa de salida utiliza para hacer una predicción. Podemos definir un MLP para pronósticos de series de tiempo univariadas de la siguiente manera.

(Ejemplo de definición de un modelo MLP)

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

En la definición es importante la forma de la entrada; esto es lo que el modelo espera como entrada para cada muestra en término del número de pasos de tiempo. El número de pasos de tiempo como entrada en el número que elegimos al preparar nuestro conjunto de datos como argumento para la función split_sequence(). La dimensión de entrada para cada muestra se especifica en el argumento de atenuación de entrada en la definición de la primera capa oculta. Técnicamente, el modelo véra cada paso de tiempo como una característica separada en lugar de pasos de tiempo separados.

Casi siempre tenemos múltiples muestras, por lo tanto, el modelo esperará que el componente de entrada de los datos de capacitación tenga las dimensiones o la forma: [samples, features]. Nuestra función split_sequence() en la sección anterior produce la X con la forma [samples, features] lista para usar en el modelado. El modelo es ajustado con Adam de descenso de gradiente estocástico y optimizado usando la función error cuadrático medio (ECM). Una vez el modelo está listo, podemos incluirlo en el conjunto de datos de formación.

(Ejemplo de un Modelo MLP)

#modelo de ajuste
model.fit(X, y, epochs=2000, verbose=0)

Después que el modelo esta ajustado, podemos usarlo para hacer una predicción. Podemos predecir el siguiente valor en la secuencia proporcionando la entrada: [70, 60, 90]. Y esperar que el modelo prediga algo como: [100]. El modelo espera que la forma de entrada dimensional con [samples, features], por lo tanto, debemos remodelar la muestra de entrada única antes de hacer la predicción, por ejemplo, con la forma [1, 3] para 1 muestra y 3 pasos de tiempo utilizados como característica de entrada.

(Ejemplo de remodelación de una sola muestra para hacer una predicción)

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

Podemos vincular todo y demostrar como desarrollar un MLP para el pronóstico de series de tiempo univariadas y hacer una sola predicción.

(Ejemplo de demostración de una MLP para pronósticos de series temporales univariadas)

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):
  X, y = list(), list()
  for i in range(len(sequence)):
    #encuentra al final de este patron
    end_ix = i + n_steps
    #comprobar si estamos mas alla de la secuencia
    if end_ix > len(sequence)-1:
     break
    #recoger las partes de entrada y salida del patron
    seq_x, seq_y = sequence[i:end_ix], sequence[end_ix]
    X.append(seq_x)
    y.append(seq_y)
  return array(X), array(y)
#definir secuencia de entrada 
raw_seq = [10, 20, 30, 40, 50, 60, 70, 80, 90]
#selecionar un numero de pasos de tiempo
n_steps = 3
#definir en muestras
X, y = split_sequence(raw_seq, n_steps)
#definir modelo
model = Sequential()
model.add(Dense(100, activation='relu', input_dim=n_steps))
model.add(Dense(1))
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))
yhat = model.predict(x_input, verbose=0)
print(yhat)

Ejecutando el ejemplo se preparan los datos, el modelo y se hace una predicción. Podemos ver que el modelo predice el siguiente valor en secuencia.

[[ 100.81071472]]