Forecasting energy consumption involves predicting future energy usage patterns, which is crucial for energy management and sustainable planning. PyTorch, an open-source machine learning library, offers robust functionalities for developing sequences models like Recurrent Neural Networks (RNNs) and Long Short-Term Memory networks (LSTMs) that can be highly effective for time-series data used in energy forecasts.
Setting Up the Environment
Before implementing our sequence model, we need to set up the Python environment with necessary libraries. Make sure to install PyTorch and other required libraries such as numpy and matplotlib using pip.
# Install necessary libraries
pip install torch numpy matplotlib
Data Preparation
For sequence models to be effective, preparing the data correctly is critical. Energy consumption data typically consists of time-stamped entries that need to be normalized and split into sequences.
import numpy as np
import pandas as pd
# Example of loading data
energy_data = pd.read_csv('energy_consumption.csv')
def normalize_data(df):
return (df - df.min()) / (df.max() - df.min())
# Normalize energy data
normalized_data = normalize_data(energy_data["Consumption"]) # Assuming CSV contains 'Consumption'
# Create sequences
sequence_length = 24 # Using past 24 hours (e.g., days) for prediction
def create_sequences(data, seq_length):
sequences = []
targets = []
for i in range(len(data) - seq_length):
seq = data[i:i + seq_length]
target = data[i + seq_length]
sequences.append(seq)
targets.append(target)
return np.array(sequences), np.array(targets)
sequences, targets = create_sequences(normalized_data, sequence_length)
Building the Model
In this section, we'll define our energy consumption forecasting model using an LSTM architecture.
import torch
from torch import nn, optim
from torch.utils.data import DataLoader, Dataset
class EnergyDataset(Dataset):
def __init__(self, sequences, targets):
self.sequences = torch.tensor(sequences, dtype=torch.float32)
self.targets = torch.tensor(targets, dtype=torch.float32)
def __len__(self):
return len(self.sequences)
def __getitem__(self, index):
return self.sequences[index], self.targets[index]
train_dataset = EnergyDataset(sequences, targets)
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
class LSTMForecaster(nn.Module):
def __init__(self, input_size, hidden_layer_size, output_size):
super(LSTMForecaster, 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)
def forward(self, input_seq):
lstm_out, _ = self.lstm(input_seq.view(len(input_seq), 1, -1))
predictions = self.linear(lstm_out.view(len(input_seq), -1))
return predictions[-1] # taking last time step
model = LSTMForecaster(input_size=1, hidden_layer_size=100, output_size=1)
Training the Model
Now let's train our model. We’ll use the mean squared error as our loss criterion, and stochastic gradient descent as our optimizer. A few training epochs should provide a roughly fitting model, although more may be desirable for greater accuracy.
loss_function = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
for epoch in range(100): # 100 epochs for training
for seq, target in train_loader:
optimizer.zero_grad()
y_pred = model(seq)
loss = loss_function(y_pred, target)
loss.backward()
optimizer.step()
if epoch % 10 == 0:
print(f'Epoch {epoch}, Loss: {loss.item()}')
Evaluating and Using the Model
Once trained, you can use the model to forecast energy consumption based on your input sequences. Below is a simple demonstration of generating predictions from the trained model.
# Function to predict future energy consumption
def predict(model, input_data):
with torch.no_grad():
input_tensor = torch.tensor(input_data, dtype=torch.float32)
model.eval()
return model(input_tensor).item()
# Example of making a prediction
sample_sequence = sequences[0] # Select a sample input sequence
predicted_value = predict(model, sample_sequence)
print("Predicted energy consumption:", predicted_value)
This pipeline demonstrates a fundamental approach for forecasting energy consumption using PyTorch. Adjusting sequence length, tuning model hyperparameters, or expanding the database can lead to refinements of the model’s accuracy.
