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

Unitats Recurrents Gated (GRUs)

Següent ►
►

Introducció a les GRUs

Les Unitats Recurrents Gated (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 vanishing i el gradient exploding. Les GRUs són similars a les Xarxes de Memòria a Llarg i Curt Termini (LSTM), però amb una estructura més simple i menys paràmetres, cosa que les fa més eficients en termes de càlcul.

Característiques Clau de les GRUs

  • Gates (Portes): Les GRUs utilitzen dues portes principals: la porta d'actualització (update gate) i la porta de restabliment (reset gate).
  • Més Simples que les LSTM: Les GRUs tenen menys paràmetres que les LSTM, ja que no tenen una cel·la de memòria separada.
  • Eficients en Càlcul: A causa de la seva simplicitat, les GRUs són més ràpides d'entrenar i requereixen menys recursos computacionals.

Arquitectura de les GRUs

Les GRUs tenen una estructura recurrent que inclou dues portes principals:

  1. Porta d'Actualització (Update Gate): Controla la quantitat d'informació de l'estat anterior que es manté en l'estat actual.
  2. Porta de Restabliment (Reset Gate): Decideix quanta informació de l'estat anterior es descarta.

Fórmules Matemàtiques

Les operacions dins d'una GRU es poden descriure amb les següents fórmules:

  1. Porta d'Actualització: \[ z_t = \sigma(W_z \cdot [h_{t-1}, x_t]) \] On \(z_t\) és la porta d'actualització, \(W_z\) són els pesos associats, \(h_{t-1}\) és l'estat anterior, \(x_t\) és l'entrada actual, i \(\sigma\) és la funció sigmoide.

  2. Porta de Restabliment: \[ r_t = \sigma(W_r \cdot [h_{t-1}, x_t]) \] On \(r_t\) és la porta de restabliment i \(W_r\) són els pesos associats.

  3. Estat Candidat: \[ \tilde{h}t = \tanh(W \cdot [r_t * h{t-1}, x_t]) \] On \(\tilde{h}_t\) és l'estat candidat, \(W\) són els pesos associats, i \(\tanh\) és la funció tangencial hiperbòlica.

  4. Estat Actual: \[ h_t = (1 - z_t) * h_{t-1} + z_t * \tilde{h}_t \] On \(h_t\) és l'estat actual.

Implementació de GRUs amb PyTorch

A continuació, es mostra com implementar una GRU utilitzant PyTorch.

Exemple de Codi

import torch
import torch.nn as nn

class GRUNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(GRUNet, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.gru(x, h0)
        out = self.fc(out[:, -1, :])
        return out

# Paràmetres
input_size = 10
hidden_size = 20
num_layers = 2
output_size = 1

# Creació del model
model = GRUNet(input_size, hidden_size, num_layers, output_size)

# Mostra del model
print(model)

Explicació del Codi

  1. Definició de la Classe GRUNet:

    • __init__: Inicialitza els paràmetres del model, incloent les capes GRU i la capa lineal final.
    • forward: Defineix el pas endavant del model. Inicialitza l'estat ocult, passa les dades a través de la capa GRU i després a través de la capa lineal.

  2. Paràmetres:

    • input_size: La dimensió de les dades d'entrada.
    • hidden_size: La dimensió de l'estat ocult.
    • num_layers: El nombre de capes GRU.
    • output_size: La dimensió de la sortida final.

  3. Creació del Model:

    • Es crea una instància del model GRUNet amb els paràmetres especificats.

Exercici Pràctic

Exercici

Implementa una GRU per predir la seqüència següent en una sèrie temporal. Utilitza les dades de la sèrie temporal proporcionades i entrena el model per predir el valor següent.

Solució

import numpy as np
import torch.optim as optim

# Dades de la sèrie temporal (exemple)
data = np.sin(np.linspace(0, 100, 1000))

# Preprocessament de les dades
def create_sequences(data, seq_length):
    xs, ys = [], []
    for i in range(len(data)-seq_length):
        x = data[i:i+seq_length]
        y = data[i+seq_length]
        xs.append(x)
        ys.append(y)
    return np.array(xs), np.array(ys)

seq_length = 10
X, y = create_sequences(data, seq_length)

# Convertir a tensors
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.float32)

# Dividir en entrenament i prova
train_size = int(len(X) * 0.8)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

# Creació del model
model = GRUNet(input_size=1, hidden_size=20, num_layers=2, output_size=1)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Entrenament del model
num_epochs = 100
for epoch in range(num_epochs):
    model.train()
    outputs = model(X_train.unsqueeze(-1))
    loss = criterion(outputs.squeeze(), y_train)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# Avaluació del model
model.eval()
with torch.no_grad():
    test_outputs = model(X_test.unsqueeze(-1))
    test_loss = criterion(test_outputs.squeeze(), y_test)
    print(f'Test Loss: {test_loss.item():.4f}')

Explicació de la Solució

  1. Preprocessament de les Dades:

    • create_sequences: Crea seqüències de longitud seq_length a partir de les dades de la sèrie temporal.
    • Les dades es converteixen a tensors i es divideixen en conjunts d'entrenament i prova.

  2. Entrenament del Model:

    • Es defineixen el model, la funció de pèrdua (MSELoss) i l'optimitzador (Adam).
    • El model s'entrena durant num_epochs èpoques, actualitzant els pesos en cada època.

  3. Avaluació del Model:

    • Després de l'entrenament, el model es prova amb el conjunt de prova i es calcula la pèrdua de prova.

Conclusió

En aquesta secció, hem après sobre les Unitats Recurrents Gated (GRUs), la seva arquitectura i com implementar-les utilitzant PyTorch. Les GRUs són una eina poderosa per treballar amb dades seqüencials i poden ser utilitzades en una àmplia varietat d'aplicacions, des de la predicció de sèries temporals fins al processament del llenguatge natural. Amb els coneixements adquirits, ara estàs preparat per aplicar GRUs als teus propis projectes.

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