Как запустить Mistral Timestral локально для прогнозирования временных рядов

А что, если вы могли бы прогнозировать цены акций с помощью небольшой модели ИИ, которая работает локально, выдаёт предсказания за миллисекунды и не требует дополнительного обучения?

Прогнозирование временных рядов обычно подразумевает статистические методы вроде ARIMA, ML-конвейеры или модели, обученные на конкретном наборе данных. Timestral — это семейство моделей с открытыми весами от Mistral AI, представленное 15 октября 2026 года, которое предлагает другой подход. Она предсказывает будущие значения по историческим данным без дообучения, и, по словам Mistral, её самая крупная модель занимает первое место среди предобученных zero-shot моделей в трёх открытых бенчмарках.

Несмотря на небольшой размер, модели демонстрируют конкурентную точность на множестве бенчмарков по прогнозированию и применимы ко всему — от финансовых рынков до энергопотребления и розничного спроса.

В этом руководстве мы разберём, что такое Timestral и как она работает, настроим локальный запуск на Python и uv, а затем протестируем её на реальных данных по акциям Apple (AAPL). Мы сгенерируем скользящие прогнозы на один день, сравним их с фактическими ценами закрытия и наивной базовой моделью, а предсказания превратим в простые сигналы «Покупать», «Продавать» или «Держать». Также вы можете посмотреть наши руководства по прогнозированию временных рядов с TimeGPT и по ARIMA для прогнозирования временных рядов.

Что такое Mistral Timestral?

Timestral — это семейство базовых моделей временных рядов с открытыми весами от Mistral AI для быстрого прогнозирования общего назначения. Базовая модель временных рядов один раз предобучается на большой и разнородной коллекции рядов, чтобы уметь предсказывать данные, которых она ранее не видела.

В отличие от традиционных моделей, которым требуется обучение на конкретном наборе данных, Timestral поддерживает zero-shot прогнозирование. Она предсказывает будущие значения напрямую из исторических данных, без дополнительного обучения или тонкой настройки.

Timestral — это причинно-следственный трансформер с патчами, обученный в основном на синтетических данных, после чего следует второй этап обучения на смеси реальных и синтетических данных. Она обрабатывает цены акций, энергопотребление, продажи и показания датчиков. Mistral описывает архитектуру и обучение в техническом отчёте.

Mistral выпустила четыре размера модели с разным балансом между размером, скоростью и точностью:

Согласно опубликованным бенчмаркам Mistral, Timestral-209M занимает первое место среди предобученных и zero-shot моделей в GIFT-Eval, TIME и fev-bench. В представленных сравнениях она обходит более крупные модели, такие как TimesFM-3 и Falcon-2.0. Это собственные результаты Mistral, отправленные в таблицы лидеров GIFT-Eval и TIME, так что для независимого подтверждения сверяйтесь с лидерами.

Скорость — ещё одно преимущество. На стандартном серверном CPU с 8 потоками, по данным Mistral, Timestral-209M предсказывает один день вперёд на основе трёх недель истории с шагом 15 минут за 113 миллисекунд, а модель на 5M — за 17 миллисекунд. GPU не требуется.

Timestral поддерживает следующие возможности прогнозирования:

• Длинный исторический контекст: Принимает до 32 768 исторических шагов.
• Мультивариантное прогнозирование: Совместно предсказывает несколько связанных временных рядов для улучшения точности.
• Вероятностные предсказания: Возвращает 21 квантиль для оценки неопределённости прогноза, а не одно значение.
• Ковариаты: Принимает только-прошлые и известные-на-будущее переменные, числовые или категориальные, которые могут влиять на прогноз.
• Локальный вывод: Работает на CPU и GPU без платного API. Код выпущен под Apache 2.0, а веса — под модифицированной лицензией MIT.

В этом руководстве мы используем Timestral-209M, самую крупную и точную модель в семействе согласно опубликованным бенчмаркам Mistral. Мы запустим её локально на NVIDIA RTX 4070 для прогнозирования цен акций и оценим качество на реальных рыночных данных.

Настройка Timestral на Linux

Timestral требуется Python 3.10 или новее и PyTorch 2.4 или новее. Мы используем Python 3.12, PyTorch 2.7.0 и uv, чтобы создать лёгкую среду разработки на Linux. Timestral также поддерживает вывод на CPU, так что GPU необязателен.

Сначала убедитесь, что ваш GPU NVIDIA определяется и драйверы работают:

nvidia-smiРаботает на

Эта команда выводит информацию о GPU, версию драйвера и совместимость с CUDA. Если ваш GPU виден в выводе, можно продолжать.

Далее установите uv — быстрый менеджер Python-пакетов и сред:

curl -LsSf https://astral.sh/uv/install.sh | shРаботает на

Перезапустите терминал после установки uv, чтобы команда стала доступна в вашей оболочке.

Теперь создайте директорию проекта и виртуальную среду Python 3.12:

mkdir timestral-project
cd timestral-project
uv venv --python 3.12
source .venv/bin/activateРаботает на

Далее установите PyTorch 2.7.0 с поддержкой CUDA 12.6:

uv pip install torch==2.7.0 \
  --index-url https://download.pytorch.org/whl/cu126Работает на

Во время тестирования сборка под CUDA 12.8 выдавала ошибку совместимости драйвера на нашей RTX 4070. Переход на PyTorch 2.7.0 с CUDA 12.6 решил проблему без обновления драйвера. В зависимости от вашего GPU и драйвера NVIDIA может потребоваться иная сборка CUDA.

Если у вас нет GPU, установите сборку для CPU, заменив адрес индекса на https://download.pytorch.org/whl/cpu. Код далее в этом руководстве автоматически переключается на CPU при необходимости.

Теперь установите Timestral напрямую из её официального репозитория GitHub:

uv pip install git+https://github.com/mistralai/timestral.gitРаботает на

Установите оставшиеся библиотеки для загрузки рыночных данных, обработки предсказаний, построения визуализаций и работы с ноутбуками:

uv pip install numpy "pandas>=2.2,<3.1" matplotlib \
  yfinance jupyterlab ipykernel tqdmРаботает на

Мы используем yfinance для получения исторических цен акций, pandas и NumPy — для обработки данных, а Matplotlib — для построения графиков фактических и предсказанных цен. Версию pandas ограничиваем диапазоном, использованным при нашем тестировании, чтобы избежать предупреждений о совместимости.

Перед продолжением проверьте, что PyTorch видит ваш 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')"Работает на

Наш вывод:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Работает на

Значение True подтверждает доступность CUDA для PyTorch, а последняя строка указывает модель GPU. Теперь можно начинать эксперименты с Timestral.

Вместо отдельных скриптов мы используем JupyterLab, чтобы запускать код по шагам, изучать значения прогнозов и сравнивать предсказания с фактическими рыночными данными. Запустите JupyterLab из директории проекта:

python -m jupyter labРаботает на

Откройте URL, показанный в терминале, обычно http://localhost:8888/lab, и создайте новый Python-ноутбук, используя только что настроенную среду. Мы будем использовать этот ноутбук, чтобы загрузить Timestral, сгенерировать предсказания и оценить качество модели.

Прогнозирование цен акций Apple с Timestral

Вместо синтетических данных мы используем реальные исторические цены акций Apple и измерим, насколько точно Timestral предсказывает цену закрытия следующего торгового дня.

Чтобы эксперимент был реалистичнее, применим скользящее прогнозирование на один день. Для каждого торгового дня в тестовом периоде Timestral получает 500 предыдущих цен закрытия и предсказывает только следующую цену закрытия.

Также сравним два подхода:

• Прогноз по «сырым» ценам: Непосредственное предсказание следующей цены закрытия.
• Прогноз лог-доходностей: Предсказание следующего логарифмического изменения цены с обратным преобразованием в цену закрытия.

1. Загрузите исторические цены акций

Запустите ноутбук и импортируйте необходимые библиотеки. Также зададим тикер, число тестовых дней, окно контекста и имя модели.

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"Работает на

Теперь загрузим пять лет дневных данных по акциям Apple. Параметр auto_adjust=True возвращает цены закрытия, скорректированные на сплиты и дивиденды.

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())Работает на

Для тестирования используем последние 60 торговых сессий, а в качестве контекста для каждого прогноза — предшествующие 500 наблюдений.

2. Загрузите Timestral на ваш GPU

Загрузите модель 209M на GPU с резервом на CPU, если CUDA недоступна. 837 МБ весов загрузятся с Hugging Face при первом запуске этой ячейки.

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

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

print(f"Loaded {MODEL} on {device}")Работает на

Модель успешно загрузилась на RTX 4070:

Loaded mistralai/Timestral-209M on cudaРаботает на

3. Сгенерируйте скользящие прогнозы на один день

Теперь для каждого торгового дня создадим два предсказания: по историческим ценам закрытия и по лог-доходностям. Лог-доходность — это посуточное изменение логарифма цены; каждую предсказанную доходность мы преобразуем обратно в цену по предыдущей цене закрытия.

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())Работает на

Модель генерирует 60 скользящих прогнозов на один день, используя для каждого предыдущие 500 цен закрытия. Каждый прогноз опирается только на данные, доступные до целевого дня, поэтому будущие цены не «просачиваются» во входные данные модели.

4. Оцените точность прогноза

Мы измерим среднюю абсолютную ошибку (MAE), корень из среднеквадратичной ошибки (RMSE), среднюю абсолютную процентную ошибку (MAPE) и направленную точность. Также сравним Timestral с наивной базовой моделью, предполагающей, что завтрашняя цена закрытия равна сегодняшней.

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}%")Работает на

Наши результаты показывают, что Timestral работает немного лучше при прогнозировании лог-доходностей, а не «сырых» цен акций. 

Подход с лог-доходностями дал наименьшие MAE (3,05 $), RMSE (3,84 $) и MAPE (0,93%), немного опередив нашу базовую модель. 

Что ещё важнее, направленная точность улучшилась с 41,67% для «сырых» цен до 55% для лог-доходностей, что указывает на лучшую способность предсказывать, вырастут или упадут цены. 

Модель по «сырым» ценам также показала покрытие интервальной оценки 81,7% для диапазона 10–90%, близкое к ожидаемым 80%, что говорит о разумно откалиброванной неопределённости. В целом Timestral выдала довольно точные ценовые прогнозы, но её преимущество над простой базовой моделью было минимальным; для выводов о пригодности для торговли нужны дополнительные тесты.

5. Визуализируйте предсказания Timestral

Построим график фактических цен закрытия и обоих вариантов прогноза с помощью 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()Работает на

График показывает, насколько близко Timestral следует за фактическими ценами Apple на протяжении 60 торговых дней. Оба подхода улавливают восходящий тренд, а затенённая оранжевая область — это интервал прогноза 10–90% модели по «сырым» ценам. На нижней панели показаны ежедневные ошибки прогноза.

Большинство ошибок укладываются примерно в 5 $, с несколькими более крупными промахами на 9–11 $ во время резких движений цены. Оба метода дают почти идентичные прогнозы, с небольшим преимуществом лог-доходностей. Обе прогнозные линии также отстают от фактической примерно на один день, что соответствует небольшой разнице с наивным базисом.

6. Сгенерируйте сигналы «Покупать», «Держать» и «Продавать»

Теперь превратим предсказания по «сырым» ценам в экспериментальные сигналы «Покупать», «Держать» и «Продавать». Используем порог 1% для ожидаемого изменения цены:

• BUY: Ожидаемый рост цены более чем на 1%.
• SELL: Ожидаемое падение цены более чем на 1%.
• HOLD: Ожидаемое движение в диапазоне от -1% до +1%.

Реализуем правила на 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")Работает на

Все 60 торговых дней дали сигнал HOLD, без рекомендаций BUY или SELL. В последних 10 строках ожидаемое изменение ни разу не превысило 0,15% ни в одну сторону — значительно ниже нашего порога 1%.

Эти сигналы получены из предсказаний по «сырым» ценам, у которых была более слабая направленная точность (41,67%). Чтобы увидеть сигналы на основе лог-доходностей, замените price_predictions на return_predictions в расчёте change_pct. Более низкий порог даст больше сигналов BUY и SELL, но сделает их чувствительнее к ошибкам прогноза и рыночному шуму.

Эти сигналы предназначены для экспериментов, а не для реальной торговли, и ничто в этом руководстве не является финансовой рекомендацией. Для оценки пригодности стратегии потребуется дополнительное бэктестирование, настройка порогов и учёт транзакционных издержек.

Итоги

В целом Timestral произвела очень хорошее впечатление. 

Настройка оказалась простой, вывод — быстрым, и всё удалось запустить локально на RTX 4070 без внешних API. 

Дополнительный плюс — эти лёгкие модели могут работать и на CPU, что делает их доступными без дорогого оборудования.

Что касается точности, результаты получились неоднозначными. 

Timestral достаточно неплохо следовала за ценами акций, но лишь немного превзошла простую базовую модель.

Мы не являемся экспертами по финансовому прогнозированию или трейдингу, так что вероятно, с подготовкой данных, стратегиями прогнозирования и подбором параметров можно добиться лучших результатов.

Ранее мы использовали размещённые сервисы прогнозирования, такие как TimeGPT, но Timestral сделала локальное прогнозирование гораздо привлекательнее. С момента её выхода мы начали переносить больше рабочих нагрузок на локальные модели: они быстрые, лёгкие и не требуют API-вызовов и оплаты по факту использования.

На наш взгляд, главная сила Timestral — не только точность, но и простота и низкая стоимость прогнозирования.

Вы можете запускать полноценную модель временных рядов на своём оборудовании, свободно экспериментировать и встраивать её в приложения без зависимости от внешних сервисов. Даже если наши прогнозы цен не впечатляют, Timestral — отличный вариант для тех, кто строит локальные системы прогнозирования.

Если вы хотите глубже разобраться в прогнозировании, рекомендуем наш курс Time Series Analysis in Python. Для финансового моделирования попробуйте Machine Learning for Finance in Python.