Estás leyendo la publicación: Creación de un modelo de transferencia de aprendizaje para la previsión de series temporales
El aprendizaje por transferencia es un enfoque para ahorrar esfuerzo durante el entrenamiento de grandes modelos de aprendizaje automático o aprendizaje profundo. Ayuda a evitar procesos repetitivos para aprender la característica de los datos. Hay varios modelos preentrenados que se utilizan en la visión artificial para facilitar el aprendizaje por transferencia. En este artículo, aprenderemos cómo aprovechar el aprendizaje de transferencia en problemas de pronóstico de series de tiempo, especialmente cuando usamos un modelo de aprendizaje profundo como LSTM para predicciones. Construiremos un modelo para una tarea de pronóstico de series de tiempo y lo usaremos como un modelo previamente entrenado en una aplicación de pronóstico de series de tiempo diferente pero similar sin gastar mucho esfuerzo en el entrenamiento.
Tabla de contenido
- ¿Qué es el aprendizaje por transferencia?
- Creación de un modelo de aprendizaje por transferencia para la previsión de series temporales
- Uso de un modelo de pronóstico de series de tiempo preentrenado
- Resumen
¿Qué es el aprendizaje por transferencia?
El aprendizaje por transferencia es una de las técnicas de usar pesos fácilmente disponibles o preentrenados de diferentes modelos entrenados para tareas similares y usarlos en nuestras tareas para producir resultados eficientes. Hay varios modelos de transferencia de aprendizaje proporcionados por el marco TensorFlow, pero hay más adecuados para la clasificación de imágenes.
Por lo tanto, este artículo incluye un estudio de caso sobre cómo implementar la técnica de transferencia de aprendizaje para datos de series de tiempo, donde primero, se construye un modelo para algunos datos y hay un modelo más correspondiente desarrollado para el mismo tipo de datos y utilizado para obtener predicciones.
Modelo de aprendizaje de transferencia de edificios
Entonces, para el estudio de caso de este artículo, hemos utilizado datos de series temporales para pronosticar el consumo de energía del hogar utilizando técnicas de pronóstico de series temporales.
Los datos adquiridos inicialmente estaban en forma de un archivo de texto (txt) y estos datos se preprocesaron adecuadamente utilizando el marco de pandas para obtener el archivo de texto (txt) en forma de un archivo de valores separados por comas (CSV) y también el analizar_fecha() Se utilizó la función para obtener los datos adecuados para el pronóstico de series de tiempo. Los pasos a seguir se muestran a continuación.
df = pd.read_csv(‘/content/drive/MyDrive/Colab notebooks/Transfer learning with time series data/household_power_conquisition.txt’, sep=’;’, parse_dates={‘dt’ : [‘Date’, ‘Time’]}, infer_datetime_format=Verdadero, low_memory=Falso, na_values=[‘nan’,’?’]index_col=”dt”)
Una vez que se realizó el preprocesamiento adecuado, los datos se visualizaron para las observaciones iniciales t utilizando la función head() de pandas, como se muestra a continuación.
df.cabeza()
Entonces, una vez que se visualizaron los datos, se dividieron en entrenamiento y prueba usando el modelo scikit-learn y el 20 % de los datos disponibles se reservaron para la validación. Los pasos a seguir para el mismo se muestran a continuación.
principal, val = train_test_split (df, test_size = 0.2)
Aquí se usaron los datos “principales” para construir el primer modelo LSTM. Usando el conjunto de datos principal, los datos se visualizaron para las tendencias y la estacionalidad presente, donde ciertas características se volvieron a muestrear mensualmente en varios parámetros agregados como la suma y la media.
La función denominada GlobalActivePower se volvió a muestrear para la suma y la media para visualizar la distribución como se muestra a continuación.
main.Global_active_power.resample(‘D’).sum().plot(title=”Remuestreo para la suma”) plt.tight_layout() plt.show() main.Global_active_power.resample(‘D’).mean(). plot(title=”Remuestreo para la media”, color=”red”) plt.tight_layout() plt.show()
De manera similar, cualquier característica del conjunto de datos se puede volver a muestrear en consecuencia para verificar la distribución en varias funciones agregadas. Incluso ciertas características se pueden volver a muestrear en varios parámetros de frecuencia de datos de series temporales. Aquí hay un código de muestra para volver a muestrear una de las características mensualmente y visualizarlo a continuación.
principal[‘Voltage’].resample(‘M’).mean().plot(tipo=’barra’, color=”rojo”) plt.xticks(rotación=60) plt.ylabel(‘Voltaje’) plt.title(‘Voltaje por trimestre (resumido sobre el trimestre)’) plt.show()
Entonces, como hemos visto anteriormente, hay varias características que deben normalizarse en una escala común. Entonces, para este propósito, se utilizó la biblioteca min-max scaler del módulo de aprendizaje scikit y se realizó un preprocesamiento adecuado para el ajuste del modelo adecuado como se muestra a continuación.
from sklearn.preprocessing import MinMaxScaler ## Si desea entrenar en función de los datos remuestreados (a lo largo de una hora), utilice los siguientes valores = df_resample.values scaler = MinMaxScaler(feature_range=(0, 1)) scaled = scaler.fit_transform( valores) reenmarcado = series_to_supervised(escalado, 1, 1) # soltar columnas que no queremos predecir reenmarcado.drop(reenmarcado.columnas[[8,9,10,11,12,13]], eje=1, en el lugar=Verdadero) imprimir(reenmarcado.cabeza())
Ahora los valores escalados se preprocesan adecuadamente para dividirlos en entrenamiento y prueba y facilitar la construcción de modelos. Los pasos involucrados se muestran a continuación.
# dividir en conjuntos de entrenamiento y prueba valores = reframed.values n_train_time = 365*24 tren = valores[:n_train_time, :]
prueba = valores[n_train_time:, :]
##prueba = valores[n_train_time:n_test_time, :]
# dividir en entrada y salida tren_X, tren_y = tren[:, :-1]tren[:, -1]
prueba_X, prueba_y = prueba[:, :-1]prueba[:, -1]
# reformar la entrada para que sea 3D [samples, timesteps, features]
tren_X = tren_X.reforma((tren_X.forma[0]1, tren_X.forma[1])) prueba_X = prueba_X.reforma((prueba_X.forma[0]1, prueba_X.forma[1])) print(train_X.shape, train_y.shape, test_X.shape, test_y.shape) # Reformamos la entrada al formato 3D como esperaban los LSTM, es decir [samples, timesteps, features].
Ahora que la división de datos es exitosa, procedemos con la construcción del modelo donde se construye una red neuronal recurrente. Pero primero, importemos las bibliotecas necesarias para lo mismo como se muestra a continuación.
importar tensorflow como tf importar keras desde tensorflow.keras.layers importar Dense desde tensorflow.keras.models importar secuencial desde tensorflow.keras.utils importar to_categorical desde tensorflow.keras.optimizers importar SGD desde tensorflow.keras.callbacks importar EarlyStopping desde keras.utils importar np_utils importar itertools desde tensorflow.keras.layers importar LSTM desde tensorflow.keras.layers importar Conv1D desde tensorflow.keras.layers importar MaxPooling1D desde tensorflow.keras.layers importar Dropout
Entonces ahora el modelo está construido con las capas como se muestra a continuación.
modelo = Sequential() model.add(LSTM(100, input_shape=(train_X.shape[1]tren_X.forma[2]))) modelo.add(Abandono(0.2)) modelo.add(Denso(1))
Ahora, el modelo se compila adecuadamente como se muestra a continuación y la métrica utilizada para evaluar el modelo es la raíz cuadrada media, ya que es un parámetro más relevante para la evaluación de datos de series temporales. Los pasos involucrados se muestran a continuación.
model.compile(pérdida=”equilibrio_cuadrado_error”, optimizador=”adam”)
Ahora el modelo se ajusta a los datos divididos como se muestra a continuación.
history = model.fit(train_X, train_y, epochs=20, batch_size=70, validation_data=(test_X, test_y), detallado=2, shuffle=False)
Ahora, usando este modelo, intentemos obtener predicciones y, como este modelo se compiló para mean_squared_error, evaluémoslo solo por los mismos motivos. Para los datos de series de tiempo, especialmente para obtener predicciones, tenemos que realizar un preprocesamiento de la variable de destino y los pasos para el mismo se muestran a continuación.
# hacer una predicción ypred = model.predict(test_X) test_X = test_X.reshape((test_X.shape[0]7)) # invertir la escala para los valores pronosticados inv_ypred = np.concatenate((ypred, test_X[:, -6:]), eje=1) inv_ypred = escalador.inverse_transform(inv_ypred) inv_ypred = inv_ypred[:,0]
# invertir escala para valores reales test_y = test_y.reshape((len(test_y), 1)) inv_yact = np.concatenate((test_y, test_X[:, -6:]), eje=1) inv_yact = escalador.inverse_transform(inv_yact) inv_yact = inv_yact[:,0]
# calcular RMSE rmse = np.sqrt(mean_squared_error(inv_yact, inv_ypred)) print(‘Prueba RMSE: %.3f’ % rmse)
Entonces para el modelo desarrollado obtenemos un Prueba RMSE de 0.622 como se muestra a continuación.
Uso de un modelo de pronóstico de series de tiempo preentrenado
Ahora vamos a guardar los pesos y parámetros del modelo en un h5 formato como se muestra a continuación.
modelo.guardar(‘lstm_modelo_nuevo.h5’)
Ahora, en una nueva instancia para un tipo de datos similar, el modelo guardado se puede cargar en el entorno de trabajo como se muestra a continuación.
desde tensorflow.keras.models importar modelo_carga modelo_cargado=modelo_carga(‘/content/lstm_model_new.h5’)
Las capas del modelo cargado se pueden obtener como se muestra a continuación.
modelo_cargado.capas
Si podemos recordar, habíamos dejado de lado una cierta parte de los datos para la validación. Entonces, para el nuevo modelo creado, los datos de validación se preprocesaron adecuadamente como se mencionó anteriormente y, de manera similar, se construyó un modelo secuencial congelando ciertas capas para facilitar el aprendizaje de transferencia. Los pasos a seguir se muestran a continuación.
# extraer todas las capas del modelo base excepto la última capa por capa en modelo_cargado.capas[:-1]: model1.add(layer) # Congelar todas las capas del modelo base por capa en loaded_model.layers: layer.trainable=False # agregar nuevas capas model1.add(Dense(50,input_dim=1)) model1.add(Dropout( 0.1)) modelo1.add(Denso(1))
Entonces, una vez que se congelaron las capas necesarias, el modelo se compiló de manera similar y el modelo se ajustó para los datos divididos. De manera similar al modelo preentrenado, también se evaluó el error cuadrático medio y el modelo muestra un rendimiento excelente y casi los mismos resultados que el modelo preentrenado.
La raíz cuadrática media del nuevo modelo obtenido fue de 0,621.
Entonces, así es como podemos implementar el aprendizaje de transferencia para datos de series temporales donde se pueden usar modelos previamente entrenados para tipos de datos similares para obtener predicciones más fáciles.
Nota
Los datos de series temporales son muy inciertos y contienen varios parámetros como tendencia y estacionalidad. Por lo tanto, es una buena práctica visualizar la serie primero y usar los modelos que están entrenados previamente para tipos de datos similares.
Resumen
El aprendizaje por transferencia es una de las técnicas para producir modelos efectivos, pero el hecho subyacente es que a medida que los datos varían, los modelos previamente entrenados que se usarán también varían y los datos de series de tiempo incluyen varios factores técnicos, como la estacionariedad, la estacionalidad y las tendencias, y se vuelve importante opte por el modelo preentrenado correcto para el tipo correcto de datos.
