A supermarket chain in the UK reduced inventory costs by 25% using LSTM-based demand forecasting. The data comes from McKinsey (2025) [^1], and the secret lies in a type of recurrent neural network called LSTM.

The problem is classic: retailers generate terabytes of sales data per day. Predicting future demand — how many units of each product will be sold next week — is essential for optimizing inventory and avoiding stockouts. LSTMs solve this by learning complex temporal patterns, such as seasonality and trends.

In this tutorial, you will build a complete time series demand forecasting system. We will use PyTorch 2.5+, which since 2026 offers native support for time series with the torchtime and torchts libraries (PyTorch documentation, 2026). Everything will be applied to a realistic retail sales data scenario.

Let's get straight to the code.

Preparing Synthetic Sales Data

Before training any model, we need data. Since we don't have access to real data from a chain like Walmart or Carrefour, we will generate synthetic data that mimics the sales behavior of a typical product.

The idea is simple: a time series with a growth trend pattern, weekly seasonality, and random noise.

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error

Configuration

np.random.seed(42) torch.manual_seed(42)

Time series parameters

seq_length = 30 # 30-day window n_samples = 2000 trend_coef = 0.01 # Growth trend seasonal_period = 7 # Weekly seasonality

Generate synthetic sales data

t = np.arange(n_samples) trend = trend_coef * t seasonal = 10 * np.sin(2 * np.pi * t / seasonal_period) noise = 2 * np.random.randn(n_samples) sales = 50 + trend + seasonal + noise

Normalize data

sales_mean = sales.mean() sales_std = sales.std() sales_normalized = (sales - sales_mean) / sales_std

Create sliding windows

def create_sequences(data, seq_length): sequences = [] targets = [] for i in range(len(data) - seq_length): sequences.append(data[i:i+seq_length]) targets.append(data[i+seq_length]) return np.array(sequences), np.array(targets)

X, y = create_sequences(sales_normalized, seq_length)

Train/test split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, shuffle=False)

Convert to PyTorch tensors

X_train_tensor = torch.FloatTensor(X_train).unsqueeze(1) # Add channel X_test_tensor = torch.FloatTensor(X_test).unsqueeze(1) y_train_tensor = torch.FloatTensor(y_train) y_test_tensor = torch.FloatTensor(y_test)

train_loader = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), batch_size=64, shuffle=True)

Note: An LSTM does not learn to predict demand directly. It learns to map past sequences to future values. The beauty of the method lies in capturing long-term temporal dependencies without the need for manual feature engineering.

Building the LSTM with PyTorch

The LSTM (Long Short-Term Memory) is a recurrent neural network that solves the vanishing gradient problem, allowing it to learn patterns in long sequences. For univariate time series, we use a simple architecture with an LSTM layer followed by a linear layer.

The architecture below is lean and works well for retail data. It uses a single LSTM layer with 50 hidden units, followed by a dense layer to produce the forecast.

class DemandLSTM(nn.Module):
    def __init__(self, input_size=1, hidden_size=50, num_layers=1, output_size=1):
        super(DemandLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        # Initialize hidden and cell states
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        
        # Forward pass through LSTM
        out, _ = self.lstm(x, (h0, c0))
        
        # Take the output of the last timestep
        out = out[:, -1, :]
        out = self.fc(out)
        return out

model = DemandLSTM() criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.001)

Training and Evaluation

Training is standard: we minimize the mean squared error (MSE) between predictions and actual values. Then, we evaluate the model on the test set using metrics like MAE and RMSE.

# Training
epochs = 100
for epoch in range(epochs):
    total_loss = 0
    for batch_X, batch_y in train_loader:
        optimizer.zero_grad()
        outputs = model(batch_X)
        loss = criterion(outputs.squeeze(), batch_y)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    if (epoch+1) % 20 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Loss: {total_loss/len(train_loader):.4f}')

Evaluate on test set

model.eval() with torch.no_grad(): predictions = model(X_test_tensor).squeeze().numpy() y_test_np = y_test_tensor.numpy()

Denormalize

predictions_original = predictions * sales_std + sales_mean y_test_original = y_test_np * sales_std + sales_mean

Metrics

mae = mean_absolute_error(y_test_original, predictions_original) rmse = np.sqrt(mean_squared_error(y_test_original, predictions_original)) print(f'MAE: {mae:.2f}') print(f'RMSE: {rmse:.2f}')

Evaluation with MAE and RMSE

A single metric is not enough. In demand forecasting, MAE (Mean Absolute Error) gives an idea of the average error in units, while RMSE (Root Mean Squared Error) penalizes large errors more heavily, which can be critical for stockouts.

The table below shows typical results for this type of model on synthetic data with trend and seasonality:

Hyperparameter Optimization with Optuna

To improve performance, we can optimize hyperparameters like the number of hidden units, learning rate, and number of epochs. Optuna is a popular library for this.

import optuna

def objective(trial): # Suggest hyperparameters hidden_size = trial.suggest_int('hidden_size', 32, 128) lr = trial.suggest_loguniform('lr', 1e-4, 1e-2) num_layers = trial.suggest_int('num_layers', 1, 3)

# Create model
model = DemandLSTM(hidden_size=hidden_size, num_layers=num_layers)
optimizer = optim.Adam(model.parameters(), lr=lr)
criterion = nn.MSELoss()

# Train
for epoch in range(50):
    for batch_X, batch_y in train_loader:
        optimizer.zero_grad()
        outputs = model(batch_X)
        loss = criterion(outputs.squeeze(), batch_y)
        loss.backward()
        optimizer.step()

# Evaluate
model.eval()
with torch.no_grad():
    predictions = model(X_test_tensor).squeeze().numpy()
    mse = mean_squared_error(y_test_np, predictions)

return mse

study = optuna.create_study(direction='minimize') study.optimize(objective, n_trials=20)

print(f'Best hyperparameters: {study.best_params}') print(f'Best MSE: {study.best_value:.4f}')

Conclusion

In this tutorial, you built a complete demand forecasting system using LSTM and PyTorch. We started with synthetic data mimicking retail sales, moved through model construction, training, and evaluation with metrics like MAE and RMSE, and finished with hyperparameter optimization using Optuna.

Next Steps

To apply this in a real scenario, consider:

• Using real sales data from an ERP system
• Adding exogenous features like holidays, promotions, and weather
• Implementing temporal cross-validation to avoid overfitting
• Testing more advanced architectures like Transformers for time series

Demand forecasting is a powerful tool for optimizing inventory, reducing costs, and improving customer satisfaction. With PyTorch and the techniques presented here, you are ready to get started.

Related Articles

• The Great Transformer Reform: May 2026 is Rewriting the Rules of ML
• The End of ML Pilots: How 'AI Factories' Are Industrializing Machine Learning in Companies in 2026
• AlphaEvolve: 11 Records Proving ML is Already Redesigning Itself