Cómo ejecutar Mistral Timestral en local para predicción de series temporales

¿Y si pudieras predecir precios de acciones con un modelo de IA pequeño que corre en local, devuelve predicciones en milisegundos y no necesita entrenamiento adicional?

La predicción de series temporales suele implicar métodos estadísticos como ARIMA, pipelines de machine learning o modelos entrenados en un conjunto de datos específico. Timestral, una familia de modelos de predicción con pesos abiertos lanzada por Mistral AI el 15 de octubre de 2026, plantea un enfoque distinto. Predice valores futuros a partir de datos históricos sin fine-tuning y, según Mistral, su modelo más grande encabeza los rankings entre los modelos preentrenados zero-shot en tres benchmarks públicos.

A pesar de su tamaño reducido, los modelos ofrecen una precisión competitiva en múltiples benchmarks de predicción y pueden aplicarse a todo: desde mercados financieros hasta consumo energético y demanda en retail.

En este tutorial veremos qué es Timestral y cómo funciona, cómo configurarlo en local con Python y uv, y lo probaremos con datos reales de Apple (AAPL). Generaremos predicciones rodantes a un día, las compararemos con los cierres reales y con un baseline ingenuo, y convertiremos las predicciones en señales simples de compra (Buy), venta (Sell) o mantener (Hold). También puedes ver nuestros tutoriales sobre predicción de series temporales con TimeGPT y ARIMA para series temporales.

¿Qué es Mistral Timestral?

Timestral es una familia de modelos base de series temporales de Mistral AI para predicción rápida y de propósito general. Un modelo base de series temporales se preentrena una sola vez en una colección amplia y diversa de series para poder predecir datos nunca vistos.

A diferencia de los modelos tradicionales que requieren entrenamiento en un dataset específico, Timestral admite predicción zero-shot. Predice valores futuros directamente a partir de los datos históricos, sin entrenamiento ni ajuste adicional.

Timestral es un transformer causal basado en parches, entrenado principalmente con datos sintéticos y con una segunda fase de entrenamiento en una mezcla de datos reales y sintéticos. Maneja precios de acciones, demanda energética, ventas y mediciones de sensores. Mistral describe la arquitectura y el entrenamiento en su informe técnico.

Mistral lanzó cuatro tamaños, cada uno con un equilibrio distinto entre tamaño, velocidad y precisión:

Según los benchmarks publicados por Mistral, Timestral-209M ocupa el primer puesto entre los modelos preentrenados y zero-shot en GIFT-Eval, TIME y fev-bench. Supera a modelos más grandes como TimesFM-3 y Falcon-2.0 en las comparativas reportadas. Estos son resultados de Mistral, enviados a los leaderboards de GIFT-Eval y TIME, así que consulta los leaderboards para confirmación independiente.

La velocidad es otra ventaja. En una CPU de servidor estándar con 8 hilos, Mistral informa de que Timestral-209M predice un día por delante a partir de tres semanas de histórico con resolución de 15 minutos en 113 milisegundos, y el modelo de 5M tarda 17 milisegundos. No se requiere GPU.

Timestral admite estas funcionalidades de predicción:

• Contexto histórico largo: acepta hasta 32.768 pasos temporales históricos.
• Predicción multivariante: predice varias series relacionadas de forma conjunta para mejorar las estimaciones.
• Predicciones probabilísticas: devuelve 21 cuantiles para estimar la incertidumbre de la predicción, en lugar de un único valor.
• Covariables: acepta variables solo del pasado y conocidas en el futuro, numéricas o categóricas, que pueden influir en la predicción.
• Inferencia local: se ejecuta en CPUs y GPUs sin API de pago. El código se publica bajo Apache 2.0 y los pesos con una licencia MIT modificada.

Para este tutorial usaremos Timestral-209M, el modelo más grande y preciso de la familia según los benchmarks publicados por Mistral. Lo ejecutaremos en local en una NVIDIA RTX 4070 para predecir precios de acciones y evaluar su rendimiento con datos reales de mercado.

Configura Timestral en Linux

Timestral necesita Python 3.10 o posterior y PyTorch 2.4 o posterior. Usaremos Python 3.12, PyTorch 2.7.0 y uv para crear un entorno de desarrollo ligero en una máquina Linux. Timestral también admite inferencia en CPU, así que la GPU es opcional.

Primero, comprueba que tu GPU de NVIDIA se detecta y que los controladores funcionan:

nvidia-smiCon la tecnología de

Este comando muestra información sobre tu GPU, la versión del driver y la compatibilidad con CUDA. Si tu GPU aparece en la salida, puedes continuar.

Después, instala uv, un gestor rápido de entornos y paquetes de Python:

curl -LsSf https://astral.sh/uv/install.sh | shCon la tecnología de

Reinicia la terminal tras instalar uv para que el comando esté disponible en tu shell.

Ahora crea un directorio de proyecto y un entorno virtual de Python 3.12:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateCon la tecnología de

A continuación, instala PyTorch 2.7.0 con soporte CUDA 12.6:

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Con la tecnología de

Durante las pruebas, la build de CUDA 12.8 arrojó un error de compatibilidad del driver en nuestra RTX 4070. Cambiar a PyTorch 2.7.0 con CUDA 12.6 lo solucionó sin actualizar el driver. Según tu GPU y driver de NVIDIA, podrías necesitar otra build de CUDA.

Si no tienes GPU, instala la build para CPU sustituyendo la URL del índice por https://download.pytorch.org/whl/cpu. El código más adelante en este tutorial recurrirá automáticamente a la CPU.

Ahora instala Timestral directamente desde su repositorio oficial en GitHub:

uv pip install git+https://github.com/mistralai/timestral.gitCon la tecnología de

Instala el resto de librerías para descargar datos de mercado, procesar predicciones, crear visualizaciones y ejecutar notebooks:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmCon la tecnología de

Usamos yfinance para obtener precios históricos, pandas y NumPy para el procesamiento y Matplotlib para representar precios reales frente a predichos. También acotamos la versión de pandas al rango usado en nuestras pruebas para evitar avisos de compatibilidad.

Antes de seguir, verifica que PyTorch puede acceder a tu 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')"Con la tecnología de

Nuestra salida:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Con la tecnología de

El valor True confirma que CUDA está disponible para PyTorch y la última línea identifica la GPU. Ya podemos empezar a experimentar con Timestral.

En lugar de scripts separados, usaremos JupyterLab para ejecutar código paso a paso, inspeccionar valores y comparar predicciones con datos reales de mercado. Lanza JupyterLab desde tu directorio de proyecto:

python -m jupyter labCon la tecnología de

Abre la URL que aparece en tu terminal, normalmente http://localhost:8888/lab, y crea un nuevo notebook de Python usando el entorno que acabamos de configurar. Usaremos este notebook para cargar Timestral, generar predicciones y evaluar el rendimiento del modelo.

Predice precios de Apple con Timestral

En lugar de generar datos sintéticos, usaremos precios históricos reales de Apple y mediremos cuán bien Timestral predice el cierre del siguiente día de negociación.

Para que el experimento sea más realista, usaremos predicciones rodantes a un día. Para cada jornada del periodo de prueba, Timestral recibe los 500 cierres anteriores y predice solo el cierre del día siguiente.

También compararemos dos métodos:

• Predicción en precios: predecir directamente el próximo precio de cierre.
• Predicción en rendimientos logarítmicos: predecir el siguiente cambio logarítmico del precio y convertirlo de nuevo a un precio de cierre.

1. Descarga precios históricos

Abre un notebook e importa las librerías necesarias. También fijamos el ticker, el número de días de prueba, la ventana de contexto y el nombre del 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"Con la tecnología de

Ahora descarga cinco años de datos diarios de Apple. Con auto_adjust=True obtendrás precios de cierre ajustados por splits y 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())Con la tecnología de

Usamos las últimas 60 sesiones para probar y las 500 observaciones previas como contexto para cada predicción.

2. Carga Timestral en tu GPU

Carga el modelo de 209M en la GPU, con reserva en CPU si CUDA no está disponible. Los 837 MB de pesos se descargan de Hugging Face la primera vez que ejecutes esta celda.

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

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

print(f"Loaded {MODEL} on {device}")Con la tecnología de

El modelo se cargó correctamente en la RTX 4070:

Loaded mistralai/Timestral-209M on cudaCon la tecnología de

3. Genera predicciones rodantes a un día

Ahora generamos dos predicciones por jornada: una a partir de precios de cierre históricos y otra a partir de rendimientos logarítmicos. Un rendimiento logarítmico es el cambio diario del logaritmo del precio; convertimos cada rendimiento previsto de vuelta a precio usando el cierre previo.

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())Con la tecnología de

El modelo genera 60 predicciones rodantes a un día, usando los 500 cierres anteriores para cada una. Cada predicción usa solo datos disponibles antes del día objetivo, de modo que no hay fuga de información futura en las entradas del modelo.

4. Evalúa la precisión

Medimos MAE (error absoluto medio), RMSE (raíz del error cuadrático medio), MAPE (error porcentual absoluto medio) y precisión direccional. También comparamos Timestral con un baseline ingenuo que asume que el cierre de mañana será igual al de hoy.

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}%")Con la tecnología de

Nuestros resultados muestran que Timestral rinde ligeramente mejor al predecir rendimientos logarítmicos que precios brutos. 

El enfoque con rendimientos logarítmicos logró el MAE más bajo (3,05 $), el RMSE más bajo (3,84 $) y el MAPE más bajo (0,93 %), superando por poco a nuestro baseline. 

Aún más importante, la precisión direccional mejoró del 41,67 % con precios brutos al 55 % con rendimientos logarítmicos, lo que sugiere un mejor acierto al predecir si el precio subirá o bajará. 

El modelo en precios también alcanzó una cobertura del intervalo de predicción del 81,7 % para el 10-90 %, cerca del 80 % esperado, lo que indica estimaciones de incertidumbre razonablemente calibradas. En conjunto, Timestral generó previsiones de precio bastante precisas, pero su mejora frente al baseline simple fue mínima, y se necesitan más pruebas para determinar si sus predicciones pueden respaldar decisiones de trading de forma fiable.

5. Visualiza las predicciones de Timestral

Representemos los cierres reales frente a ambos métodos de predicción con 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()Con la tecnología de

El gráfico muestra lo cerca que Timestral sigue los precios reales de Apple a lo largo de los 60 días. Ambos enfoques capturan la tendencia alcista y el área naranja sombreada es el intervalo de predicción 10-90 % del modelo en precios. El panel inferior muestra los errores diarios.

La mayoría de los errores se mantienen en torno a 5 $, con algunos fallos mayores de 9 a 11 $ durante movimientos bruscos. Los dos métodos generan predicciones casi idénticas, con ligera ventaja de los rendimientos logarítmicos. Ambas líneas de predicción también van con aproximadamente un día de retraso respecto al precio real, lo que encaja con la pequeña diferencia frente al baseline ingenuo.

6. Genera señales de Buy, Hold y Sell

Ahora convirtamos las predicciones en precios en señales experimentales de Buy, Hold y Sell. Usamos un umbral del 1 % en el cambio previsto:

• BUY: aumento previsto superior al 1 %.
• SELL: descenso previsto superior al 1 %.
• HOLD: movimiento previsto entre -1 % y +1 %.

Podemos implementar estas reglas con 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")Con la tecnología de

Los 60 días generaron señales HOLD, sin recomendaciones de BUY o SELL. En las 10 últimas filas mostradas, el cambio esperado nunca supera el 0,15 % en ningún sentido, muy por debajo del umbral del 1 %.

Estas señales provienen de las predicciones en precio, que tuvieron peor precisión direccional (41,67 %). Para ver señales a partir de rendimientos logarítmicos, sustituye price_predictions por return_predictions en el cálculo de change_pct. Un umbral menor produciría más señales de BUY y SELL, pero también serían más sensibles a errores de predicción y al ruido del mercado.

Estas señales son para experimentación, no para operativa en vivo, y nada en este tutorial constituye asesoramiento financiero. Haría falta más backtesting, ajuste de umbrales y análisis de costes de transacción para saber si podrían sostener una estrategia rentable.

Reflexiones finales

En general, Timestral me ha sorprendido gratamente. 

La configuración fue sencilla, la inferencia rápida y pude ejecutarlo todo en local en mi RTX 4070 sin depender de APIs externas. 

Además, estos modelos ligeros también pueden ejecutarse en CPU, lo que los hace accesibles sin hardware caro.

En cuanto a precisión, los resultados fueron mixtos. 

Timestral siguió razonablemente bien los precios, pero apenas superó a un baseline sencillo.

No soy experto en predicción financiera ni en trading, así que probablemente podría mejorar con más preparación de datos, estrategias de predicción y ajuste de parámetros.

He usado servicios alojados como TimeGPT, pero Timestral hace que la predicción en local sea mucho más atractiva. Desde su lanzamiento, he empezado a migrar más cargas de trabajo de predicción a modelos locales porque son rápidos, ligeros y no dependen de llamadas a APIs ni de tarifas por uso.

Para mí, la mayor fortaleza de Timestral no es solo la precisión, sino lo fácil y económico que hace predecir.

Puedes ejecutar un modelo capaz de series temporales en tu propio hardware, experimentar libremente e integrarlo en aplicaciones sin depender de servicios externos. Aunque nuestras predicciones de acciones no fueran brillantes, creo que Timestral es una opción excelente para cualquiera que esté creando aplicaciones de predicción en local.

Si te apetece profundizar en predicción, te recomiendo nuestro curso Time Series Analysis in Python. Para modelado financiero específico, prueba Machine Learning for Finance in Python.