Evaluating Multi-Horizon Forecasts with Custom Loss Functions in PyTorch

Forecasting is a key element in many areas such as finance, meteorology, and supply chain management. Multi-horizon forecasting involves predicting a range of future time points instead of a single point, thus providing a more comprehensive understanding of future trends. One powerful library for handling such computations is PyTorch, which is known for its flexibility and dynamic computational graph.

When it comes to multi-horizon forecasting, selecting the right loss function is crucial. Standard loss functions might not be suitable for certain applications that require custom handling of errors at different horizons. In this article, we will explore how to implement custom loss functions in PyTorch to evaluate multi-horizon forecasts.

Why Custom Loss Functions?

Custom loss functions allow us to apply domain-specific knowledge to the prediction model. For instance, in stock price predictions, errors in predicting the next day's price might be more critical than errors in long-term predictions. Custom loss functions enable you to emphasize prediction accuracy at specific horizons by assigning different weights to errors at different points in time.

Setting Up PyTorch

To demonstrate implementing custom loss functions, we'll first set up PyTorch and define a basic model. Make sure you have PyTorch installed using the following command:

pip install torch

Once installed, let's create a simple PyTorch model.

import torch
import torch.nn as nn

class SimpleModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)

    def forward(self, x):
        return self.linear(x)

Creating a Custom Loss Function

In this example, we will create a custom loss function called WeightedMSELoss, where we apply different weights to mean squared errors at different horizons.

class WeightedMSELoss(nn.Module):
    def __init__(self, weights):
        super(WeightedMSELoss, self).__init__()
        self.weights = weights

    def forward(self, outputs, targets):
        loss = 0.0
        for i in range(len(self.weights)):
            loss += self.weights[i] * ((outputs[:, i] - targets[:, i]) ** 2).mean()
        return loss

An example instantiation of this loss function would require specifying the weights, such as:

# Example: Emphasizing the importance of the first horizon
target_weights = torch.tensor([0.7, 0.2, 0.1]) # Must sum to 1.0
custom_loss = WeightedMSELoss(weights=target_weights)

This custom loss function allows for focusing more on the initial time steps or any horizon deemed important for the application if desired.

Training with Custom Loss

Here's a sample training loop that integrates our custom loss function.

# Assume data_loader, model, and optimizer are predefined
model = SimpleModel(input_dim, len(target_weights))
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(num_epochs):
    for inputs, targets in data_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = custom_loss(outputs, targets)
        loss.backward()
        optimizer.step()
    print(f'Epoch {epoch}, Loss: {loss.item()}')

Here, each element from data_loader provides inputs and true targets, for which predictions are made. The custom loss function calculates the weighted sum of mean squared errors, influencing how updates are applied to the model parameters.

Conclusion

Custom loss functions in PyTorch provide a scalable way to incorporate nuanced error assessments, which are crucial for multi-horizon forecasting tasks. Leveraging PyTorch's extensibility, we’re able to implement these functions so our models reflect real-world priorities more accurately. Experimenting with different weightings is key to finding the most suitable model for your specific forecasts.