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

Introducció a les RNNs

Següent ►
►

Les Xarxes Neuronals Recurrents (RNNs) són un tipus de xarxa neuronal especialment dissenyada per treballar amb dades seqüencials. A diferència de les xarxes neuronals tradicionals, les RNNs tenen connexions recurrents que permeten mantenir una "memòria" de les entrades anteriors, cosa que les fa ideals per a tasques com el processament de llenguatge natural, la traducció automàtica, la predicció de sèries temporals, entre d'altres.

Conceptes Clau

  1. Estructura d'una RNN

Una RNN es compon de nodes que estan connectats de manera que cada node no només rep l'entrada actual, sinó també la sortida del node anterior. Això permet que la xarxa tingui en compte la informació de les entrades anteriors.

  1. Funció d'Activació

Les RNNs utilitzen funcions d'activació com tanh o ReLU per introduir no linealitat en el model, permetent que la xarxa aprengui relacions complexes en les dades.

  1. Propagació cap endavant i cap enrere

  • Propagació cap endavant: En una RNN, la sortida de cada node es calcula utilitzant l'entrada actual i la sortida del node anterior.
  • Propagació cap enrere (Backpropagation Through Time - BPTT): L'entrenament d'una RNN implica ajustar els pesos de la xarxa per minimitzar l'error de predicció. Això es fa mitjançant una variant de la retropropagació anomenada BPTT, que té en compte les dependències temporals.

Exemples Pràctics

Exemple 1: Implementació d'una RNN Simple amb TensorFlow

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

# Definim el model
model = Sequential()
model.add(SimpleRNN(50, input_shape=(10, 1)))  # 50 unitats recurrents, seqüències de longitud 10 amb 1 característica
model.add(Dense(1))  # Capa de sortida

# Compilació del model
model.compile(optimizer='adam', loss='mse')

# Resum del model
model.summary()

Explicació del codi:

  1. Importació de llibreries: Importem TensorFlow i els mòduls necessaris per construir el model.
  2. Definició del model: Utilitzem Sequential per crear un model seqüencial. Afegim una capa SimpleRNN amb 50 unitats recurrents i una capa d'entrada amb seqüències de longitud 10 i 1 característica. Finalment, afegim una capa Dense per a la sortida.
  3. Compilació del model: Compilem el model utilitzant l'optimitzador 'adam' i la funció de pèrdua 'mse' (error quadràtic mitjà).
  4. Resum del model: Mostrem un resum del model per veure la seva estructura.

Exemple 2: Entrenament d'una RNN amb dades seqüencials

import numpy as np

# Generació de dades d'exemple
X_train = np.random.rand(1000, 10, 1)  # 1000 mostres, seqüències de longitud 10, 1 característica
y_train = np.random.rand(1000, 1)  # 1000 etiquetes

# Entrenament del model
model.fit(X_train, y_train, epochs=10, batch_size=32)

Explicació del codi:

  1. Generació de dades d'exemple: Creem dades d'entrenament aleatòries amb 1000 mostres, seqüències de longitud 10 i 1 característica.
  2. Entrenament del model: Entrenem el model amb les dades generades durant 10 èpoques amb un batch size de 32.

Exercicis Pràctics

Exercici 1: Construir una RNN per predir sèries temporals

Descripció: Utilitza una RNN per predir els valors futurs d'una sèrie temporal sintètica.

Passos:

  1. Genera una sèrie temporal sintètica.
  2. Divideix les dades en seqüències d'entrada i sortides esperades.
  3. Construeix i entrena una RNN per predir els valors futurs.

Solució:

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, Dense

# Generació de sèrie temporal sintètica
time_steps = np.linspace(0, 100, 1000)
data = np.sin(time_steps)

# Preparació de 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))

# Definició del model
model = Sequential()
model.add(SimpleRNN(50, input_shape=(seq_length, 1)))
model.add(Dense(1))

# Compilació del model
model.compile(optimizer='adam', loss='mse')

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

# Predicció
predictions = model.predict(X)

Explicació del codi:

  1. Generació de sèrie temporal sintètica: Creem una sèrie temporal utilitzant la funció sinus.
  2. Preparació de les dades: Dividim la sèrie temporal en seqüències d'entrada i sortides esperades.
  3. Definició del model: Construïm una RNN amb 50 unitats recurrents i una capa de sortida.
  4. Compilació i entrenament del model: Compilem i entrenem el model amb les dades preparades.
  5. Predicció: Utilitzem el model entrenat per fer prediccions sobre les dades.

Resum

En aquesta secció, hem introduït les Xarxes Neuronals Recurrents (RNNs) i hem explorat la seva estructura i funcionament. Hem vist com implementar una RNN simple amb TensorFlow i com entrenar-la amb dades seqüencials. També hem proporcionat un exercici pràctic per reforçar els conceptes apresos. En el següent tema, aprofundirem en la construcció d'una RNN més complexa i explorarem les seves aplicacions en diferents àmbits.

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