Uma rede de supermercados no Reino Unido reduziu em 25% o custo de estoque usando previsão de demanda com LSTM. O dado é da McKinsey (2025) [^1], e o segredo está em um tipo de rede neural recorrente chamado LSTM.

O problema é clássico: varejistas geram terabytes de dados de vendas por dia. Prever a demanda futura — quantas unidades de cada produto serão vendidas na próxima semana — é essencial para otimizar estoques e evitar rupturas. LSTMs resolvem isso aprendendo padrões temporais complexos, como sazonalidade e tendências.

Neste tutorial, você vai construir um sistema completo de previsão de demanda em séries temporais. Usaremos PyTorch 2.5+, que desde 2026 oferece suporte nativo a séries temporais com as bibliotecas torchtime e torchts (documentação PyTorch, 2026). Tudo será aplicado a um cenário realista de dados de vendas de uma rede de varejo.

Vamos direto ao código.

Preparando os Dados Sintéticos de Vendas

Antes de treinar qualquer modelo, precisamos de dados. Como não temos acesso a dados reais de uma rede como Walmart ou Carrefour, vamos gerar dados sintéticos que imitam o comportamento de vendas de um produto típico.

A ideia é simples: uma série temporal com um padrão de tendência de crescimento, sazonalidade semanal e ruído aleatório.

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

Configuração

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

Parâmetros da série temporal

seq_length = 30 # Janela de 30 dias n_samples = 2000 trend_coef = 0.01 # Tendência de crescimento seasonal_period = 7 # Sazonalidade semanal

Gerar dados sintéticos de vendas

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

Normalizar dados

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

Criar janelas deslizantes

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)

Divisão treino/teste

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

Converter para tensores PyTorch

X_train_tensor = torch.FloatTensor(X_train).unsqueeze(1) # Adiciona canal 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)

Nota: Um LSTM não aprende a prever demanda diretamente. Ele aprende a mapear sequências passadas para valores futuros. A beleza do método está em capturar dependências temporais de longo prazo sem a necessidade de engenharia manual de features.

Construindo o LSTM com PyTorch

O LSTM (Long Short-Term Memory) é uma rede neural recorrente que resolve o problema de desvanecimento do gradiente, permitindo aprender padrões em sequências longas. Para séries temporais univariadas, usamos uma arquitetura simples com uma camada LSTM seguida de uma camada linear.

A arquitetura abaixo é enxuta e funciona bem para dados de varejo. Ela usa uma única camada LSTM com 50 unidades ocultas, seguida por uma camada densa para produzir a previsão.

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):
        # Inicializar estados ocultos e de célula
        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 pelo LSTM
        out, _ = self.lstm(x, (h0, c0))
        
        # Pegar a saída do último timestep
        out = out[:, -1, :]
        out = self.fc(out)
        return out

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

Treinamento e Avaliação

O treinamento é padrão: minimizamos o erro quadrático médio (MSE) entre as previsões e os valores reais. Depois, avaliamos o modelo no conjunto de teste usando métricas como MAE e RMSE.

# Treinamento
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}')

Avaliar no teste

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

Desnormalizar

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

Métricas

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}')

Avaliação com MAE e RMSE

Métrica única não basta. Em previsão de demanda, o MAE (erro absoluto médio) dá uma ideia do erro médio em unidades, enquanto o RMSE (raiz do erro quadrático médio) penaliza mais erros grandes, que podem ser críticos para rupturas de estoque.

A tabela abaixo mostra os resultados típicos para este tipo de modelo em dados sintéticos com tendência e sazonalidade:

Otimização de Hiperparâmetros com Optuna

Para melhorar o desempenho, podemos otimizar hiperparâmetros como o número de unidades ocultas, a taxa de aprendizado e o número de épocas. Optuna é uma biblioteca popular para isso.

import optuna

def objective(trial): # Sugerir hiperparâmetros 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)

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

# Treinar
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()

# Avaliar
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'Melhores hiperparâmetros: {study.best_params}') print(f'Melhor MSE: {study.best_value:.4f}')

Conclusão

Neste tutorial, você construiu um sistema completo de previsão de demanda usando LSTM e PyTorch. Começamos com dados sintéticos que imitam vendas de varejo, passamos pela construção do modelo, treinamento e avaliação com métricas como MAE e RMSE, e finalizamos com otimização de hiperparâmetros usando Optuna.

Próximos Passos

Para aplicar em um cenário real, considere:

• Usar dados reais de vendas de um sistema ERP
• Adicionar features exógenas como feriados, promoções e clima
• Implementar validação cruzada temporal para evitar overfitting
• Testar arquiteturas mais avançadas como Transformers para séries temporais

A previsão de demanda é uma ferramenta poderosa para otimizar estoques, reduzir custos e melhorar a satisfação do cliente. Com PyTorch e as técnicas apresentadas aqui, você está pronto para começar.

Artigos Relacionados

• A Grande Reforma do Transformer: Maio de 2026 Está Reescrevendo as Regras do ML
• O Fim dos Pilotos de ML: Como as 'AI Factories' Estão Industrializando o Machine Learning nas Empresas em 2026
• AlphaEvolve: 11 Recordes que Provam que o ML Já Está se Redesenhando