Herramientas de usuario

Herramientas del sitio


clase:iabd:pia:2eval:tema10

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anterior Revisión previa
Próxima revisión
Revisión previa
clase:iabd:pia:2eval:tema10 [2022/01/05 14:33]
admin
clase:iabd:pia:2eval:tema10 [2025/01/06 11:22] (actual)
admin [Ejemplo]
Línea 1: Línea 1:
-====== 10. Series de tiempo ======+====== 10. Redes Neuronales Recurrentes ====== 
 +Las redes neuronales recurrentes son redes neuronales que dependen de los datos anteriores, es decir que tienen "memoria"
 + 
 +Por ejemplo, al predecir si una foto es un tipo de flor, no depende de lo que se haya predecido antes pero en una red neuronal si.  
 +Son redes que predicen secuencias de datos como por ejemplo series de temperatura, o cotizaciones de bolsa, etc: 
 +  * Procesamiento de lenguaje natural (NLP): 
 +    * Traducción automática: Las RNN se emplean para traducir texto de un idioma a otro, dado que las traducciones requieren una comprensión contextual de las secuencias de palabras. 
 +    * Generación de texto: Pueden generar texto, completando frases o creando contenido basado en ejemplos previos, como en los modelos de lenguaje. 
 +    * Análisis de sentimiento: Se utilizan para determinar si un texto tiene un sentimiento positivo, negativo o neutral. 
 +  * Reconocimiento de voz: 
 +    * Las RNN son comunes en los sistemas de reconocimiento automático de voz (ASR), donde deben entender las secuencias temporales de las ondas sonoras para convertirlas en texto. 
 +  * Generación de música: 
 +    * Se usan para generar música en formato MIDI, ya que las composiciones musicales tienen una estructura secuencial y temporal, similar al lenguaje. 
 +  * Análisis de series temporales: 
 +    * Predicción de la bolsa de valores: Se pueden emplear para predecir precios de acciones basados en datos históricos. 
 +    * Pronóstico meteorológico: Utilizan series temporales de datos climáticos para prever el clima futuro. 
 +    * Detección de anomalías: En sistemas de monitoreo de sensores, las RNN pueden identificar patrones inusuales en las series temporales. 
 +  * Modelado de secuencias de video: 
 +    * En aplicaciones de visión por computadora, las RNN pueden analizar secuencias de fotogramas para realizar tareas como la reconocimiento de acciones o segmentación de video. 
 +  * Robótica: 
 +    * Se usan para controlar robots en tareas que requieren la interpretación de secuencias temporales, como la navegación o el seguimiento de trayectorias en tiempo real. 
 +  * Diagnóstico médico: 
 +    * Análisis de secuencias de ECG o datos de sensores para detectar patrones relacionados con enfermedades o eventos de salud. 
 +  * Sistemas de recomendación: 
 +    * Pueden analizar el comportamiento pasado de un usuario (como en la navegación web o la compra de productos) para predecir lo que podría interesarle en el futuro. 
 +  * Redes sociales: 
 +    * En plataformas de redes sociales, las RNN se utilizan para analizar la evolución de los comentarios o publicaciones, predecir tendencias y generar recomendaciones personalizadas. 
 + 
 +Para hacer este tipo de redes se usan nuevas capas que son: 
 +  * **RNN estándar**: Son las redes recurrentes clásicas, pero tienen problemas en secuencias largas. 
 +  * **LSTM (Long Short-Term Memory)**: Son una mejora de las RNN estándar por lo que recuerdan lo que ocurre a largo plazo. 
 +  * **GRU (Gated Recurrent Unit)**: Parecidas a las LSTM pero más sencillas. Tienen la ventaja de que se entrenan con muchas menos épocas pero son peores si la relación a "obtener" es muy compleja. 
 + 
 +En Keras las 3 capas se definen así: 
 +<sxh python> 
 +from tensorflow.keras.layers import RNN 
 +from tensorflow.keras.layers import LSTM 
 +from tensorflow.keras.layers import GRU 
 +</sxh> 
 + 
 +Por ahora no vamos a contar como son estas neuronas pero su esquema es este: 
 + 
 +{{:clase:iabd:pia:2eval:rnn-vs-lstm-vs-gru-1024x308.png|}} 
 + 
 +Las fórmulas matemáticas de cada tipo de neurona se puede ver en [[http://dprogrammer.org/rnn-lstm-gru|RNN, LSTM & GRU]] 
 + 
 +Más información: 
 +  * [[https://medium.com/analytics-vidhya/recurrent-neural-networks-rnns-and-time-series-forecasting-d9ea933426b3|Recurrent Neural Networks(RNN’s) and Time Series Forecasting]] 
 +  * [[https://omdena.com/blog/time-series-classification-model-tutorial/|Time Series Classification Tutorial with LSTM Recurrent Neural Networks]] 
 +  * [[https://www.analyticsvidhya.com/blog/2020/05/datetime-variables-python-pandas/|All you Should Know About Datetime Variables in Python and Pandas]] 
 +  * [[https://www.themachinelearners.com/modelos-secuencia/|Modelos de Secuencia. Todo lo que necesitas es atención]] 
 + 
 + 
 +===== Ejemplo ===== 
 +Vamos a hacer una red neuronal que dado 24 temperatura (una por cada hora) obtener la temperatura que hará 12 horas despues. 
 + 
 + 
 +  * Vamos a generar una serie de datos temporales de temperaturas a lo largo del día y que cada día van aumentando. 
 + 
 +<sxh python> 
 +def get_serie_tiempo(datetime_start,num_dias=30,pendiente=0.005,amplitud=5,ruido_amplitud=1): 
 +    np.random.seed(7) 
 + 
 +    num_datos = num_dias*24 
 +     
 + 
 + 
 +    x = np.linspace(0, num_dias * 2 * np.pi, num_datos)  # Eje x (progresión del tiempo
 +    fechas = pd.date_range(start=datetime_start, periods=num_datos, freq="h"
 +    tendencia = np.linspace(0, pendiente * num_datos, num_datos)  # Tendencia ascendente 
 +    onda = amplitud * np.sin(x)  # Onda sinusoidal 
 +    ruido = np.random.normal(0, ruido_amplitud, num_datos)  # Ruido aleatorio 
 + 
 +    datos = tendencia + onda + ruido 
 + 
 +    return fechas,datos 
 + 
 +fechas,temperaturas=get_serie_tiempo(datetime(2025, 1, 1, 10, 0, 0),num_dias=200,ruido_amplitud=0.5) 
 + 
 +figure=plt.figure(figsize=(20,10)) 
 + 
 +axes = figure.add_subplot(2,1,1) 
 +axes.plot(fechas,temperaturas) 
 +axes_configure_labels(axes,"Datos originales","Tiempo","Temperatura"
 +</sxh> 
 + 
 +{{:clase:iabd:pia:2eval:ejemplo1_gru_datos_originales.png|}} 
 + 
 +  * Ahora los transformamos en la estructura que quiere Keras que es una matriz para cada dato. Fijarse que la ''y'' también es una matriz. 
 + 
 + 
 +<sxh python> 
 + 
 + 
 +def get_datos(serie_datos,tamanyo_ventana=24,adelanto_prediccion=12): 
 +    size=len(serie_datos) 
 + 
 + 
 + 
 +    x=[] 
 +    y=[] 
 +    for i in range(size-tamanyo_ventana-adelanto_prediccion): 
 +        x.append(serie_datos[i:i+tamanyo_ventana]) 
 +        y.append(serie_datos[i+tamanyo_ventana+adelanto_prediccion]) 
 + 
 +     
 + 
 +    x=np.array(x) 
 +    y=np.array(y) 
 + 
 + 
 + 
 +    size_entrenamiento=math.floor(x.shape[0]*0.8) 
 + 
 +    x_entrenamiento=x[0:size_entrenamiento] 
 +    x_validacion=x[size_entrenamiento:
 +    y_entrenamiento=y[0:size_entrenamiento] 
 +    y_validacion=y[size_entrenamiento:
 + 
 + 
 +    return x_entrenamiento.reshape(-1,tamanyo_ventana,1), y_entrenamiento.reshape(-1,1), x_validacion.reshape(-1,tamanyo_ventana,1), y_validacion.reshape(-1,1) 
 + 
 + 
 +scaler = MinMaxScaler() 
 +temperaturas_scaled = scaler.fit_transform(temperaturas.reshape(-1,1)).reshape(temperaturas.shape) 
 +x_entrenamiento, y_entrenamiento, x_validacion, y_validacion=get_datos(temperaturas_scaled,tamanyo_ventana=24,adelanto_prediccion=12) 
 + 
 +</sxh> 
 + 
 +En nuestro ejemplo lo que hemos hecho es que para cada 24 temperaturas (''tamanyo_ventana=24'') , obtener la temperatura que habrá 12 horas después (''adelanto_prediccion=12''). 
 +Tambien hemos escalado los datos, lo cual es importante para que la red funcione mejor. Por último fíjate que tanto la ''x'' como la ''y'' son matrices ''x_entrenamiento.reshape(-1,tamanyo_ventana,1)'' y ''y_entrenamiento.reshape(-1,1)'' 
 + 
 +  * Ahora vamos a crear la red y entrenarla 
 + 
 +<sxh python> 
 +def get_model(shape): 
 +    model=Sequential() 
 +    model.add(Input(shape=shape)) 
 +    model.add(GRU(24, activation='swish', return_sequences=True)) 
 +    model.add(Dropout(0.1))        
 +    model.add(GRU(50, activation='swish', return_sequences=True )) 
 +    model.add(Dropout(0.1))   
 +    model.add(GRU(24, activation='swish', return_sequences=False)) 
 +    model.add(Dropout(0.1))     
 +    model.add(Dense(1, activation='linear')) 
 +    model.compile(loss='mean_squared_error',optimizer="adam"
 + 
 +    return model 
 + 
 +def fit(model,x_entrenamiento, y_entrenamiento, x_validacion, y_validacion,epochs): 
 +    history=model.fit(x_entrenamiento,y_entrenamiento,validation_data=(x_validacion,y_validacion),epochs=epochs,verbose=False) 
 + 
 +    return history   
 + 
 +model=get_model(shape=x_entrenamiento.shape[1:]) 
 +history=fit(model,x_entrenamiento, y_entrenamiento, x_validacion, y_validacion,30) 
 +</sxh> 
 +Fijarse que en las capas ''GRU'' hay que indicar ''return_sequences=True'' excepto en la última que debe ser ''return_sequences=False'' 
 + 
 + 
 +  * Vamos a mostrar la gráfica de la pérdida en cada época 
 + 
 +<sxh python> 
 +figure=plt.figure(figsize=(6,4)) 
 +axes = figure.add_subplot(1,1,1) 
 +axes.plot(history.history['loss'],label=f"Loss:{history.history['loss'][-1]:.3f}"
 +axes.plot(history.history['val_loss'],label=f"Val Loss:{history.history['val_loss'][-1]:.3f}"
 +axes_configure_labels(axes,"Loss por época","Épocas","MSE"
 +</sxh> 
 + 
 +{{:clase:iabd:pia:2eval:ejemplo1_gru_loss.png|}} 
 + 
 +  * Para acabar vamos a mostrar 4 gráficos en la que se va a sobreponer los datos verdaderos y los predichos, tanto en entrenamiento como en validación. 
 + 
 +<sxh python> 
 + 
 + 
 +y_pred_entrenamiento=model.predict(x_entrenamiento) 
 +y_entrenamiento_inverse_transform=scaler.inverse_transform(y_entrenamiento) 
 +y_pred_entrenamiento_inverse_transform=scaler.inverse_transform(y_pred_entrenamiento) 
 + 
 + 
 + 
 +y_pred_validacion=model.predict(x_validacion) 
 +y_validacion_inverse_transform=scaler.inverse_transform(y_validacion) 
 +y_pred_validacion_inverse_transform=scaler.inverse_transform(y_pred_validacion) 
 + 
 + 
 +figure=plt.figure(figsize=(20,25)) 
 + 
 + 
 +axes = figure.add_subplot(4,1,1) 
 +axes.plot(y_entrenamiento_inverse_transform,label="Real"
 +axes.plot(y_pred_entrenamiento_inverse_transform,label="Predicha"
 +axes_configure_labels(axes,"Todos Entrenamiento","Tiempo","Temperatura"
 +axes.set_xlim(xmin=0,xmax=y_entrenamiento_inverse_transform.shape[0]) 
 +axes.set_ylim(ymin=-6,ymax=16) 
 + 
 +axes = figure.add_subplot(4,1,2) 
 +axes.plot(y_validacion_inverse_transform,label="Real"
 +axes.plot(y_pred_validacion_inverse_transform,label="Predicha"
 +axes_configure_labels(axes,"Todos Validacion","Tiempo","Temperatura"
 +axes.set_xlim(xmin=0,xmax=y_entrenamiento_inverse_transform.shape[0]) 
 +axes.set_ylim(ymin=-6,ymax=16) 
 + 
 + 
 +axes = figure.add_subplot(4,1,3) 
 +axes.plot(y_entrenamiento_inverse_transform,label="Real"
 +axes.plot(y_pred_entrenamiento_inverse_transform,label="Predicha"
 +axes_configure_labels(axes,"Últimos Entrenamiento","Tiempo","Temperatura"
 +axes.set_xlim(xmin=y_entrenamiento_inverse_transform.shape[0]-500,xmax=y_entrenamiento_inverse_transform.shape[0]) 
 +axes.set_ylim(ymin=-6,ymax=16) 
 + 
 +axes = figure.add_subplot(4,1,4) 
 +axes.plot(y_validacion_inverse_transform,label="Real"
 +axes.plot(y_pred_validacion_inverse_transform,label="Predicha"
 +axes_configure_labels(axes,"Últimos Validacion","Tiempo","Temperatura"
 +axes.set_xlim(xmin=y_validacion_inverse_transform.shape[0]-500,xmax=y_validacion_inverse_transform.shape[0]) 
 +axes.set_ylim(ymin=-6,ymax=16) 
 +</sxh> 
 + 
 +{{:clase:iabd:pia:2eval:ejemplo1_gru_resultados.png|}}
  
-[[https://omdena.com/blog/time-series-classification-model-tutorial/|Time Series Classification Tutorial with LSTM Recurrent Neural Networks]] 
clase/iabd/pia/2eval/tema10.1641389620.txt.gz · Última modificación: 2022/01/05 14:33 por admin