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

Projecte de Predicció de Sèries Temporals

Següent ►
►

En aquest projecte, aplicarem els coneixements adquirits sobre PyTorch per construir un model de predicció de sèries temporals. Les sèries temporals són dades que es recullen en intervals de temps regulars, com ara preus d'accions, temperatures diàries, etc. Utilitzarem una xarxa neuronal recurrent (RNN) per predir els valors futurs d'una sèrie temporal.

Objectius del Projecte

  1. Càrrega i Preprocessament de Dades: Aprendre a carregar i preprocessar dades de sèries temporals.
  2. Construcció del Model: Construir una RNN per a la predicció de sèries temporals.
  3. Entrenament del Model: Entrenar la RNN amb les dades de sèries temporals.
  4. Avaluació del Model: Avaluar el rendiment del model i fer prediccions.

  1. Càrrega i Preprocessament de Dades

1.1. Importació de Llibreries

import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler

1.2. Càrrega de les Dades

Per a aquest projecte, utilitzarem un conjunt de dades de preus d'accions. Pots descarregar un conjunt de dades de Yahoo Finance o utilitzar qualsevol altre conjunt de dades de sèries temporals.

# Carregar les dades
data = pd.read_csv('stock_prices.csv')
data.head()

1.3. Preprocessament de les Dades

Normalitzarem les dades per assegurar-nos que totes les característiques tinguin la mateixa escala.

# Normalitzar les dades
scaler = MinMaxScaler(feature_range=(-1, 1))
data_normalized = scaler.fit_transform(data['Close'].values.reshape(-1, 1))

# Convertir les dades a tensors
data_normalized = torch.FloatTensor(data_normalized).view(-1)

1.4. Creació de Seqüències de Dades

Dividirem les dades en seqüències per entrenar la nostra RNN.

def create_inout_sequences(input_data, tw):
    inout_seq = []
    L = len(input_data)
    for i in range(L-tw):
        train_seq = input_data[i:i+tw]
        train_label = input_data[i+tw:i+tw+1]
        inout_seq.append((train_seq, train_label))
    return inout_seq

train_window = 12
train_inout_seq = create_inout_sequences(data_normalized, train_window)

  1. Construcció del Model

2.1. Definició de la Xarxa Neuronal

Crearem una RNN simple utilitzant PyTorch.

class LSTM(nn.Module):
    def __init__(self, input_size=1, hidden_layer_size=100, output_size=1):
        super(LSTM, self).__init__()
        self.hidden_layer_size = hidden_layer_size
        self.lstm = nn.LSTM(input_size, hidden_layer_size)
        self.linear = nn.Linear(hidden_layer_size, output_size)
        self.hidden_cell = (torch.zeros(1,1,self.hidden_layer_size),
                            torch.zeros(1,1,self.hidden_layer_size))

    def forward(self, input_seq):
        lstm_out, self.hidden_cell = self.lstm(input_seq.view(len(input_seq) ,1, -1), self.hidden_cell)
        predictions = self.linear(lstm_out.view(len(input_seq), -1))
        return predictions[-1]

  1. Entrenament del Model

3.1. Definició de la Funció de Pèrdua i l'Optimitzador

model = LSTM()
loss_function = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

3.2. Entrenament

Entrenarem el model amb les seqüències de dades creades anteriorment.

epochs = 150

for i in range(epochs):
    for seq, labels in train_inout_seq:
        optimizer.zero_grad()
        model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
                        torch.zeros(1, 1, model.hidden_layer_size))

        y_pred = model(seq)

        single_loss = loss_function(y_pred, labels)
        single_loss.backward()
        optimizer.step()

    if i%25 == 1:
        print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')

print(f'epoch: {i:3} loss: {single_loss.item():10.10f}')

  1. Avaluació del Model

4.1. Predicció

Utilitzarem el model entrenat per fer prediccions sobre les dades de test.

fut_pred = 12

test_inputs = data_normalized[-train_window:].tolist()

model.eval()

for i in range(fut_pred):
    seq = torch.FloatTensor(test_inputs[-train_window:])
    with torch.no_grad():
        test_inputs.append(model(seq).item())

actual_predictions = scaler.inverse_transform(np.array(test_inputs[train_window:] ).reshape(-1, 1))

plt.title('Predicció de Sèries Temporals')
plt.ylabel('Preu de les Accions')
plt.grid(True)
plt.autoscale(axis='x', tight=True)
plt.plot(data['Close'])
plt.plot(range(len(data['Close']), len(data['Close']) + fut_pred), actual_predictions)
plt.show()

Conclusió

En aquest projecte, hem après a carregar i preprocessar dades de sèries temporals, construir una RNN utilitzant PyTorch, entrenar el model i fer prediccions. Aquest projecte proporciona una base sòlida per a la predicció de sèries temporals amb PyTorch, i es pot ampliar per abordar problemes més complexos i utilitzar conjunts de dades més grans.

Errors Comuns i Consells:

  • Normalització de Dades: Assegura't de normalitzar les dades correctament per evitar problemes durant l'entrenament.
  • Seqüències de Dades: La longitud de les seqüències de dades (train_window) pot afectar el rendiment del model. Experimenta amb diferents valors.
  • Overfitting: Si el model s'ajusta massa a les dades d'entrenament, considera utilitzar tècniques de regularització o augmentar la quantitat de dades d'entrenament.

Amb aquests coneixements, estàs preparat per abordar projectes més avançats i personalitzats en el camp de la predicció de sèries temporals.

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