Como executar o Mistral Timestral localmente para previsão de séries temporais

E se você pudesse prever preços de ações com um modelo de IA pequeno, que roda localmente, entrega previsões em milissegundos e não precisa de treinamento adicional?

Previsão de séries temporais geralmente envolve métodos estatísticos como ARIMA, pipelines de machine learning ou modelos treinados em um conjunto de dados específico. O Timestral, uma família de modelos de previsão de pesos abertos lançada pela Mistral AI em 15 de outubro de 2026, segue outro caminho. Ele prevê valores futuros com base em dados históricos sem fine-tuning e, segundo a Mistral, seu maior modelo lidera entre os modelos pré-treinados em zero-shot em três benchmarks públicos.

Apesar do tamanho reduzido, os modelos entregam acurácia competitiva em diversos benchmarks de previsão e podem ser aplicados desde mercados financeiros até consumo de energia e demanda no varejo.

Neste tutorial, vamos ver o que é o Timestral e como ele funciona, configurá-lo localmente com Python e o uv, e testá-lo com dados reais da Apple (AAPL). Vamos gerar previsões rolantes de um dia, compará-las com os preços de fechamento reais e com um baseline ingênuo, e transformar as previsões em sinais simples de compra (Buy), venda (Sell) ou manter (Hold). Você também pode conferir nossos tutoriais sobre previsão de séries temporais com TimeGPT e ARIMA para séries temporais.

O que é o Mistral Timestral?

Timestral é uma família de modelos foundation de séries temporais, de pesos abertos, da Mistral AI, para previsões rápidas e de uso geral. Um modelo foundation de séries temporais é pré-treinado uma única vez em uma coleção grande e variada de séries, para conseguir prever dados que nunca viu.

Diferente de modelos tradicionais de previsão que precisam de treinamento em um dataset específico, o Timestral permite previsão zero-shot. Ele prevê valores futuros diretamente a partir dos dados históricos, sem treinamento ou fine-tuning adicionais.

O Timestral é um transformer causal, baseado em patches, treinado majoritariamente em dados sintéticos, seguido de uma segunda etapa de treinamento com uma mistura de dados reais e sintéticos. Ele lida com preços de ações, demanda de energia, vendas e medições de sensores. A Mistral descreve a arquitetura e o treinamento em seu relatório técnico.

A Mistral lançou quatro tamanhos, cada um com um equilíbrio diferente entre tamanho do modelo, velocidade e acurácia:

De acordo com os benchmarks publicados pela Mistral, o Timestral-209M fica em primeiro lugar entre modelos pré-treinados e zero-shot no GIFT-Eval, TIME e fev-bench. Ele supera modelos maiores como o TimesFM-3 e o Falcon-2.0 nas comparações reportadas. Esses são resultados da própria Mistral, enviados aos leaderboards do GIFT-Eval e do TIME, então confira os leaderboards para confirmações independentes.

Velocidade é outro ponto forte. Em uma CPU de servidor padrão com 8 threads, a Mistral reporta que o Timestral-209M prevê um dia à frente a partir de três semanas de histórico em janelas de 15 minutos em 113 milissegundos, e o modelo de 5M leva 17 milissegundos. Não é necessário GPU.

O Timestral oferece estes recursos de previsão:

• Contexto histórico longo: aceita até 32.768 passos históricos.
• Previsão multivariada: prevê múltiplas séries relacionadas em conjunto para melhorar as estimativas.
• Previsões probabilísticas: retorna 21 quantis para estimar a incerteza, em vez de um único valor.
• Covariáveis: aceita variáveis apenas do passado e conhecidas no futuro, numéricas ou categóricas, que podem influenciar a previsão.
• Inferência local: roda em CPUs e GPUs sem API paga. O código é liberado sob Apache 2.0 e os pesos sob uma licença MIT modificada.

Para este tutorial, vamos usar o Timestral-209M, o maior e mais preciso da família segundo os benchmarks publicados pela Mistral. Vamos rodá-lo localmente em uma NVIDIA RTX 4070 para prever preços de ações e avaliar o desempenho em dados reais de mercado.

Configure o Timestral no Linux

O Timestral requer Python 3.10 ou superior e PyTorch 2.4 ou superior. Vamos usar Python 3.12, PyTorch 2.7.0 e uv para criar um ambiente leve de desenvolvimento em uma máquina Linux. O Timestral também suporta inferência em CPU, portanto a GPU é opcional.

Primeiro, verifique se sua GPU NVIDIA é detectada e se os drivers estão funcionando:

nvidia-smiTecnologia

Esse comando exibe informações da GPU, versão do driver e compatibilidade com CUDA. Se sua GPU aparecer na saída, você pode seguir em frente.

Em seguida, instale o uv, um gerenciador rápido de pacotes e ambientes Python:

curl -LsSf https://astral.sh/uv/install.sh | shTecnologia

Reinicie o terminal após instalar o uv para que o comando fique disponível no seu shell.

Agora, crie um diretório de projeto e um ambiente virtual Python 3.12:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateTecnologia

Depois, instale o PyTorch 2.7.0 com suporte a CUDA 12.6:

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Tecnologia

Durante os testes, a build CUDA 12.8 gerou um erro de compatibilidade de driver na nossa RTX 4070. Migrar para o PyTorch 2.7.0 com CUDA 12.6 resolveu sem atualizar o driver. Dependendo da sua GPU e driver NVIDIA, você pode precisar de outra build CUDA.

Se você não tiver GPU, instale a build para CPU substituindo a URL do index por https://download.pytorch.org/whl/cpu. O código mais adiante faz fallback automático para CPU.

Agora instale o Timestral diretamente do repositório oficial no GitHub:

uv pip install git+https://github.com/mistralai/timestral.gitTecnologia

Instale as demais bibliotecas para baixar dados de mercado, processar previsões, criar visualizações e rodar notebooks:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmTecnologia

Usamos yfinance para obter preços históricos, pandas e NumPy para processamento de dados e Matplotlib para plotar preços reais versus previstos. Também limitamos a versão do pandas ao intervalo usado nos testes para evitar avisos de compatibilidade.

Antes de continuar, verifique se o PyTorch consegue acessar sua GPU:

python -c "import torch; print(torch.__version__); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'No CUDA GPU available')"Tecnologia

Nossa saída:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Tecnologia

O valor True confirma que o CUDA está disponível para o PyTorch, e a última linha identifica a GPU. Agora estamos prontos para começar a experimentar o Timestral.

Em vez de scripts Python separados, vamos usar o JupyterLab para rodar o código passo a passo, inspecionar valores de previsão e comparar com dados reais de mercado. Inicie o JupyterLab a partir do diretório do projeto:

python -m jupyter labTecnologia

Abra a URL exibida no terminal, normalmente http://localhost:8888/lab, e crie um novo notebook Python usando o ambiente que acabamos de configurar. Vamos usar esse notebook para carregar o Timestral, gerar previsões e avaliar o desempenho do modelo.

Preveja preços das ações da Apple com o Timestral

Em vez de gerar dados sintéticos, vamos usar preços históricos reais da Apple e medir o quão bem o Timestral prevê o preço de fechamento do próximo pregão.

Para deixar o experimento mais realista, vamos usar previsões rolantes de um dia. Para cada dia de negociação no período de teste, o Timestral recebe os 500 fechamentos anteriores e prevê apenas o fechamento do dia seguinte.

Também vamos comparar dois métodos:

• Previsão em preço bruto: prever diretamente o próximo preço de fechamento.
• Previsão em log-retorno: prever a próxima variação logarítmica do preço e convertê-la de volta para um preço de fechamento.

1. Baixe preços históricos

Abra um notebook e importe as bibliotecas necessárias. Também definimos o ticker, o número de dias de teste, a janela de contexto e o nome do modelo.

import numpy as np
import pandas as pd
import torch
import yfinance as yf
import matplotlib.pyplot as plt
from tqdm.auto import tqdm
from IPython.display import display
from timestral import TimestralForecaster

TICKER = "AAPL"
DAYS = 60
WINDOW = 500
MODEL = "mistralai/Timestral-209M"Tecnologia

Agora, baixe cinco anos de dados diários da Apple. Definir auto_adjust=True retorna preços ajustados por desdobramentos e dividendos.

data = yf.download(
    TICKER,
    period="5y",
    interval="1d",
    auto_adjust=True,
    multi_level_index=False,
    progress=False,
)

close = data["Close"].dropna().astype(float)

assert len(close) >= WINDOW + DAYS
assert (close > 0).all()
display(data.tail())Tecnologia

Usamos as últimas 60 sessões de negociação para teste e as 500 observações anteriores como contexto para cada previsão.

2. Carregue o Timestral na sua GPU

Carregue o modelo de 209M na GPU, com fallback para CPU se o CUDA não estiver disponível. Os 837 MB de pesos são baixados do Hugging Face na primeira execução.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = TimestralForecaster.from_pretrained(
    MODEL,
    device=device,
)

print(f"Loaded {MODEL} on {device}")Tecnologia

Nosso modelo carregou com sucesso na RTX 4070:

Loaded mistralai/Timestral-209M on cudaTecnologia

3. Gere previsões rolantes de um dia

Agora vamos gerar duas previsões para cada dia de negociação: uma a partir dos preços de fechamento históricos e outra a partir dos log-retornos. Um log-retorno é a variação diária no logaritmo do preço; convertimos cada retorno previsto de volta em preço usando o fechamento anterior.

actual = []
price_predictions = []
return_predictions = []
previous_prices = []
lower_bounds = []
upper_bounds = []
dates = []

for i in tqdm(range(DAYS), desc="Forecasting"):
    pos = len(close) - DAYS + i
    history = close.iloc[pos - WINDOW:pos].to_numpy(dtype=np.float32)
    previous = float(history[-1])

    with torch.inference_mode():
        # Forecast raw prices
        price_fc = model.forecast(
            history,
            prediction_length=1,
        )
        price_pred = float(price_fc.median.squeeze())

        # Forecast log returns
        returns = np.diff(np.log(history))
        return_fc = model.forecast(
            returns.astype(np.float32),
            prediction_length=1,
        )
        return_pred = previous * np.exp(
            float(return_fc.median.squeeze())
        )

    actual.append(float(close.iloc[pos]))
    previous_prices.append(previous)
    price_predictions.append(price_pred)
    return_predictions.append(return_pred)
    lower_bounds.append(float(price_fc.quantile(0.1).squeeze()))
    upper_bounds.append(float(price_fc.quantile(0.9).squeeze()))
    dates.append(close.index[pos])

actual = np.array(actual)
previous_prices = np.array(previous_prices)
price_predictions = np.array(price_predictions)
return_predictions = np.array(return_predictions)
lower_bounds = np.array(lower_bounds)
upper_bounds = np.array(upper_bounds)

results = pd.DataFrame({
    "Previous Close": previous_prices,
    "Actual": actual,
    "Raw Prediction": price_predictions,
    "Return Prediction": return_predictions,
    "Lower 10%": lower_bounds,
    "Upper 90%": upper_bounds,
}, index=pd.DatetimeIndex(dates, name="Date"))

display(results.tail())Tecnologia

O modelo gera 60 previsões rolantes de um dia, usando os 500 fechamentos anteriores para cada uma. Cada previsão usa apenas dados disponíveis antes do dia alvo, evitando vazamento de informações futuras nas entradas do modelo.

4. Avalie a acurácia das previsões

Medimos erro absoluto médio (MAE), raiz do erro quadrático médio (RMSE), erro percentual absoluto médio (MAPE) e acurácia direcional. Também comparamos o Timestral contra um baseline ingênuo que assume que o fechamento de amanhã será igual ao de hoje.

actual = results["Actual"].to_numpy()
previous = results["Previous Close"].to_numpy()
raw = results["Raw Prediction"].to_numpy()
ret = results["Return Prediction"].to_numpy()

def evaluate(prediction, baseline=False):
    metrics = {
        "MAE ($)": np.mean(np.abs(actual - prediction)),
        "RMSE ($)": np.sqrt(np.mean((actual - prediction) ** 2)),
        "MAPE (%)": np.mean(np.abs((actual - prediction) / actual)) * 100,
    }
    metrics["Direction (%)"] = (
        np.nan if baseline
        else np.mean(np.sign(actual - previous) == np.sign(prediction - previous)) * 100
    )
    return metrics

metrics = pd.DataFrame({
    "Baseline": evaluate(previous, baseline=True),
    "Raw Prices": evaluate(raw),
    "Log Returns": evaluate(ret),
}).T

coverage = (
    (actual >= results["Lower 10%"].to_numpy())
    & (actual <= results["Upper 90%"].to_numpy())
).mean() * 100

display(metrics.round(2))
print(f"Raw-price 10-90% interval coverage: {coverage:.1f}%")Tecnologia

Nossos resultados mostram que o Timestral performa um pouco melhor ao prever log-retornos do que preços brutos. 

A abordagem por log-retornos obteve os menores MAE (US$ 3,05), RMSE (US$ 3,84) e MAPE (0,93%), superando por pouco o nosso baseline. 

Mais importante, a acurácia direcional subiu de 41,67% com preços brutos para 55% com log-retornos, sugerindo melhor desempenho para prever se os preços vão subir ou cair. 

O modelo em preço bruto também alcançou 81,7% de cobertura do intervalo de previsão, próximo aos 80% esperados, indicando estimativas de incerteza razoavelmente calibradas. No geral, o Timestral gerou previsões de preço bem decentes, mas sua melhora sobre o baseline simples foi mínima, e mais testes são necessários para saber se suas previsões sustentam decisões de trade com confiança.

5. Visualize as previsões do Timestral

Vamos plotar os preços de fechamento reais versus as duas abordagens usando Matplotlib.

fig, axes = plt.subplots(
    2, 1,
    figsize=(14, 9),
    gridspec_kw={"height_ratios": [2, 1]},
    sharex=True,
)

# Actual vs predicted prices
axes[0].plot(
    dates, actual,
    label="Actual Price",
    color="green",
    linewidth=2.5,
)
axes[0].plot(
    dates, price_predictions,
    label="Timestral Raw Price",
    color="orange",
    linestyle="--",
)
axes[0].plot(
    dates, return_predictions,
    label="Timestral Log Returns",
    color="royalblue",
    linestyle="--",
)
axes[0].fill_between(
    dates,
    lower_bounds,
    upper_bounds,
    color="orange",
    alpha=0.12,
    label="10-90% Forecast Range",
)
axes[0].set_title(f"Timestral-209M | {TICKER} Rolling One-Day Forecast")
axes[0].set_ylabel("Adjusted Close (USD)")
axes[0].legend()
axes[0].grid(alpha=0.2)

# Prediction errors
axes[1].plot(
    dates,
    price_predictions - actual,
    label="Raw Price Error",
    color="orange",
)
axes[1].plot(
    dates,
    return_predictions - actual,
    label="Log Return Error",
    color="royalblue",
)
axes[1].axhline(0, color="black", linestyle=":")
axes[1].set_ylabel("Error ($)")
axes[1].set_xlabel("Date")
axes[1].legend()
axes[1].grid(alpha=0.2)

fig.autofmt_xdate()
plt.tight_layout()
fig.savefig("aapl_improved.png", dpi=180, bbox_inches="tight")
plt.show()Tecnologia

O gráfico mostra como o Timestral acompanha de perto os preços reais da Apple ao longo dos 60 dias úteis. As duas abordagens capturam a tendência de alta, e a área laranja é o intervalo de previsão de 10-90% do modelo em preço bruto. O painel inferior plota os erros diários.

A maioria dos erros fica em torno de US$ 5, com alguns desvios maiores de US$ 9 a US$ 11 durante movimentos bruscos. Os dois métodos geram previsões quase idênticas, com pequena vantagem para log-retornos. As linhas de previsão também ficam cerca de um dia atrás do preço real, o que condiz com a diferença pequena para o baseline ingênuo.

6. Gere sinais de Buy, Hold e Sell

Agora vamos converter as previsões em preço bruto em sinais experimentais de Buy, Hold e Sell. Usamos um limiar de 1% na variação de preço prevista:

• BUY: aumento previsto maior que 1%.
• SELL: queda prevista maior que 1%.
• HOLD: variação prevista entre -1% e +1%.

Podemos implementar essas regras com NumPy:

THRESHOLD = 1.0

change_pct = (
    price_predictions / previous_prices - 1
) * 100

signals = np.where(
    change_pct > THRESHOLD,
    "BUY",
    np.where(change_pct < -THRESHOLD, "SELL", "HOLD"),
)

results["Expected Change (%)"] = change_pct
results["Signal"] = signals

display(results.tail(10).round(2))
display(results["Signal"].value_counts())

results.to_csv("aapl_signals.csv")Tecnologia

Todos os 60 dias geraram sinais HOLD, sem recomendações de BUY ou SELL. Nas últimas 10 linhas mostradas, a variação esperada nunca passa de 0,15% em qualquer direção, bem abaixo do nosso limiar de 1%.

Esses sinais vêm das previsões em preço bruto, que tiveram a acurácia direcional mais fraca (41,67%). Para ver sinais a partir das previsões em log-retorno, troque price_predictions por return_predictions no cálculo de change_pct. Um limiar menor geraria mais sinais de BUY e SELL, mas também aumentaria a sensibilidade a erros de previsão e ao ruído do mercado.

Esses sinais são para experimentação, não para operações ao vivo, e nada neste tutorial é aconselhamento financeiro. Seriam necessários mais backtests, ajuste de limiares e análise de custos de transação para saber se podem sustentar uma estratégia lucrativa.

Considerações finais

No geral, o Timestral me impressionou bastante. 

A configuração foi simples, a inferência foi rápida e consegui rodar tudo localmente na minha RTX 4070 sem depender de APIs externas. 

O que torna tudo ainda mais atrativo é que esses modelos leves também rodam em CPU, tornando-os acessíveis sem hardware caro.

Em termos de acurácia de previsão, nossos resultados foram mistos. 

O Timestral acompanhou os preços de forma razoável, mas mal superou um baseline simples.

Eu não sou especialista em previsão financeira nem em trading, então provavelmente dá para melhorar com preparação de dados, estratégias de previsão e ajuste de parâmetros.

Já usei serviços hospedados de previsão, como o TimeGPT, mas o Timestral tornou a previsão local muito mais atrativa. Desde o lançamento, tenho migrado mais cargas de trabalho de previsão para modelos locais porque são rápidos, leves e livres de chamadas de API e de taxas por uso.

Para mim, o maior diferencial do Timestral não é só a acurácia, mas o quão fácil e barato ele torna a previsão.

Você consegue rodar um modelo de séries temporais competente no seu próprio hardware, experimentar à vontade e embuti-lo em aplicações sem depender de serviços externos. Mesmo que nossas previsões de ações não tenham sido impressionantes, considero o Timestral uma ótima opção para quem está construindo aplicações de previsão locais.

Se quiser se aprofundar em previsão, recomendo nosso curso Time Series Analysis in Python. Para modelagem voltada a finanças, experimente Machine Learning for Finance in Python.