El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Unitats recurrents amb porta (GRUs)

Següent ►
►

Introducció

Les Unitats recurrents amb porta (GRUs) són una variant de les xarxes neuronals recurrents (RNNs) dissenyades per abordar alguns dels problemes associats amb les RNNs tradicionals, com ara el gradient que desapareix. Les GRUs són similars a les Memòries a llarg termini (LSTM), però tenen una estructura més simple i menys paràmetres, cosa que les fa més eficients en termes de càlcul.

Conceptes clau

  1. Components de les GRUs

Les GRUs tenen dos components principals:

  • Porta de restabliment (reset gate): Controla quanta informació del passat ha de ser oblidada.
  • Porta de l'actualització (update gate): Decideix quanta informació del passat ha de ser transmesa al futur.

  1. Funcionament de les GRUs

Les GRUs combinen l'estat de la cel·la i l'estat ocult en una sola unitat, simplificant així el model. La fórmula matemàtica per a una GRU és la següent:

r_t = σ(W_r * [h_{t-1}, x_t])
z_t = σ(W_z * [h_{t-1}, x_t])
h'_t = tanh(W_h * [r_t * h_{t-1}, x_t])
h_t = (1 - z_t) * h_{t-1} + z_t * h'_t

On:

  • r_t és la porta de restabliment.
  • z_t és la porta de l'actualització.
  • h'_t és l'estat candidat.
  • h_t és l'estat ocult actual.
  • σ és la funció sigmoide.
  • tanh és la funció tangencial hiperbòlica.

Implementació de GRUs amb TensorFlow

  1. Importar les llibreries necessàries

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import GRU, Dense

  1. Preparar les dades

Per a aquest exemple, utilitzarem dades sintètiques. En un cas real, hauríem de carregar i pre-processar les dades adequadament.

import numpy as np

# Generar dades sintètiques
def generate_data(seq_length, num_samples):
    X = np.random.rand(num_samples, seq_length, 1)
    y = np.random.rand(num_samples, 1)
    return X, y

seq_length = 10
num_samples = 1000
X, y = generate_data(seq_length, num_samples)

  1. Construir el model

model = Sequential()
model.add(GRU(50, input_shape=(seq_length, 1)))
model.add(Dense(1))

model.compile(optimizer='adam', loss='mse')
model.summary()

  1. Entrenar el model

model.fit(X, y, epochs=20, batch_size=32)

  1. Avaluar el model

loss = model.evaluate(X, y)
print(f'Loss: {loss}')

Exercicis pràctics

Exercici 1: Construir una GRU per a la predicció de sèries temporals

  1. Carrega un conjunt de dades de sèries temporals (per exemple, dades de temperatura).
  2. Pre-processa les dades per a que siguin adequades per a una GRU.
  3. Construeix i entrena una GRU per predir els valors futurs de la sèrie temporal.

Exercici 2: Comparar GRUs amb LSTMs

  1. Construeix un model amb una LSTM per al mateix conjunt de dades de l'exercici anterior.
  2. Compara el rendiment de la GRU i la LSTM en termes de precisió i temps d'entrenament.

Solucions

Solució a l'Exercici 1

import pandas as pd

# Carregar dades de temperatura
data = pd.read_csv('temperature_data.csv')
data = data['temperature'].values

# Pre-processar les dades
def create_sequences(data, seq_length):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i+seq_length])
        y.append(data[i+seq_length])
    return np.array(X), np.array(y)

seq_length = 10
X, y = create_sequences(data, seq_length)
X = X.reshape((X.shape[0], X.shape[1], 1))

# Construir el model
model = Sequential()
model.add(GRU(50, input_shape=(seq_length, 1)))
model.add(Dense(1))

model.compile(optimizer='adam', loss='mse')
model.summary()

# Entrenar el model
model.fit(X, y, epochs=20, batch_size=32)

# Avaluar el model
loss = model.evaluate(X, y)
print(f'Loss: {loss}')

Solució a l'Exercici 2

# Construir el model amb LSTM
model_lstm = Sequential()
model_lstm.add(tf.keras.layers.LSTM(50, input_shape=(seq_length, 1)))
model_lstm.add(Dense(1))

model_lstm.compile(optimizer='adam', loss='mse')
model_lstm.summary()

# Entrenar el model amb LSTM
model_lstm.fit(X, y, epochs=20, batch_size=32)

# Avaluar el model amb LSTM
loss_lstm = model_lstm.evaluate(X, y)
print(f'Loss LSTM: {loss_lstm}')

# Comparar amb el model GRU
loss_gru = model.evaluate(X, y)
print(f'Loss GRU: {loss_gru}')

Conclusió

Les GRUs són una eina poderosa per treballar amb dades seqüencials, oferint una alternativa més simple i eficient a les LSTMs. En aquest tema, hem après sobre la seva estructura, el seu funcionament i com implementar-les amb TensorFlow. A més, hem realitzat exercicis pràctics per consolidar els coneixements adquirits. En el següent mòdul, explorarem tècniques avançades de TensorFlow per millorar encara més els nostres models.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats