Cara Menjalankan Mistral Timestral Secara Lokal untuk Peramalan Deret Waktu

Bagaimana jika Anda bisa meramalkan harga saham dengan model AI kecil yang berjalan secara lokal, mengembalikan prediksi dalam hitungan milidetik, dan tidak memerlukan pelatihan tambahan?

Peramalan deret waktu biasanya berarti metode statistik seperti ARIMA, pipeline machine learning, atau model yang dilatih pada dataset tertentu. Timestral, sebuah keluarga model peramalan open-weight yang dirilis oleh Mistral AI pada 15 Oktober 2026, mengambil pendekatan berbeda. Model ini memprediksi nilai masa depan dari data historis tanpa fine-tuning, dan menurut Mistral, model terbesarnya menempati peringkat pertama di antara model zero-shot pralatih pada tiga tolok ukur publik.

Meski berukuran kecil, model-model ini memberikan akurasi yang kompetitif di berbagai tolok ukur peramalan dan dapat diterapkan pada segala hal mulai dari pasar keuangan hingga konsumsi energi dan permintaan ritel.

Dalam tutorial ini, kita akan melihat apa itu Timestral dan bagaimana cara kerjanya, menyiapkannya secara lokal dengan Python dan uv, serta mengujinya pada data saham Apple (AAPL) yang nyata. Kita akan menghasilkan peramalan bergulir satu hari, membandingkannya dengan harga penutupan aktual dan baseline naif, serta mengubah prediksi menjadi sinyal Beli, Jual, atau Tahan yang sederhana. Anda juga dapat melihat tutorial kami tentang peramalan deret waktu dengan TimeGPT dan ARIMA untuk peramalan deret waktu.

Apa Itu Mistral Timestral?

Timestral adalah keluarga model fondasi deret waktu open-weight dari Mistral AI untuk peramalan cepat dan serbaguna. Model fondasi deret waktu dilatih sekali pada kumpulan besar seri yang beragam, sehingga dapat meramalkan data yang belum pernah dilihatnya.

Berbeda dengan model peramalan tradisional yang perlu dilatih pada dataset spesifik, Timestral mendukung peramalan zero-shot. Model ini memprediksi nilai masa depan langsung dari data historis, tanpa pelatihan atau fine-tuning tambahan.

Timestral adalah transformer kausal berbasis patch yang sebagian besar dilatih pada data sintetis, diikuti tahap pelatihan kedua pada campuran data nyata dan sintetis. Model ini menangani harga saham, permintaan energi, penjualan, dan pengukuran sensor. Mistral menjelaskan arsitektur dan pelatihannya dalam laporan teknis.

Mistral merilis empat ukuran, masing-masing dengan kompromi berbeda antara ukuran model, kecepatan, dan akurasi:

Menurut tolok ukur yang dipublikasikan Mistral, Timestral-209M menempati peringkat pertama di antara model pralatih dan zero-shot pada GIFT-Eval, TIME, dan fev-bench. Model ini mengalahkan model yang lebih besar seperti TimesFM-3 dan Falcon-2.0 dalam perbandingan yang dilaporkan. Ini adalah hasil milik Mistral sendiri, yang dikirimkan ke papan peringkat GIFT-Eval dan TIME, jadi periksa papan peringkat tersebut untuk konfirmasi independen.

Kecepatan adalah keunggulan lainnya. Pada CPU server standar dengan 8 thread, Mistral melaporkan bahwa Timestral-209M meramalkan satu hari ke depan dari tiga minggu riwayat 15 menit dalam 113 milidetik, dan model 5M memerlukan 17 milidetik. GPU tidak diperlukan.

Timestral mendukung fitur-fitur peramalan berikut:

• Konteks historis panjang: Menerima hingga 32.768 langkah waktu historis.
• Peramalan multivariat: Meramalkan beberapa deret waktu terkait secara bersamaan untuk meningkatkan prediksi.
• Prediksi probabilistik: Mengembalikan 21 kuantil untuk memperkirakan ketidakpastian ramalan, bukan satu nilai tunggal.
• Kovariat: Menerima variabel masa lalu saja dan masa depan yang diketahui, numerik atau kategorikal, yang dapat memengaruhi ramalan.
• Inferensi lokal: Berjalan pada CPU dan GPU tanpa API berbayar. Kode dirilis di bawah Apache 2.0 dan bobot di bawah lisensi MIT yang dimodifikasi.

Untuk tutorial ini, kita akan menggunakan Timestral-209M, model terbesar dan paling akurat dalam keluarga ini menurut tolok ukur yang dipublikasikan Mistral. Kita akan menjalankannya secara lokal pada GPU NVIDIA RTX 4070 untuk meramalkan harga saham dan mengevaluasi kinerjanya pada data pasar nyata.

Menyiapkan Timestral di Linux

Timestral memerlukan Python 3.10 atau lebih baru dan PyTorch 2.4 atau lebih baru. Kita akan menggunakan Python 3.12, PyTorch 2.7.0, dan uv untuk membuat lingkungan pengembangan ringan di mesin Linux. Timestral juga mendukung inferensi CPU, jadi GPU bersifat opsional.

Pertama, pastikan GPU NVIDIA Anda terdeteksi dan drivernya berfungsi:

nvidia-smiDidukung oleh

Perintah ini menampilkan informasi GPU, versi driver, dan kompatibilitas CUDA. Jika GPU Anda muncul di output, Anda bisa lanjut.

Selanjutnya, instal uv, manajer paket dan lingkungan Python yang cepat:

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

Mulai ulang terminal Anda setelah memasang uv agar perintahnya tersedia di shell.

Sekarang buat direktori proyek dan lingkungan virtual Python 3.12:

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

Selanjutnya, pasang PyTorch 2.7.0 dengan dukungan CUDA 12.6:

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

Selama pengujian, build CUDA 12.8 memunculkan kesalahan kompatibilitas driver pada RTX 4070 kami. Beralih ke PyTorch 2.7.0 dengan CUDA 12.6 memperbaikinya tanpa pembaruan driver. Bergantung pada GPU dan driver NVIDIA Anda, Anda mungkin memerlukan build CUDA yang berbeda.

Jika Anda tidak memiliki GPU, pasang build CPU dengan mengganti index URL menjadi https://download.pytorch.org/whl/cpu. Kode nanti dalam tutorial ini akan otomatis menggunakan CPU sebagai cadangan.

Sekarang pasang Timestral langsung dari repositori GitHub resminya:

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

Pasang pustaka lainnya untuk mengunduh data pasar saham, memproses prediksi, membuat visualisasi, dan menjalankan notebook:

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

Kami menggunakan yfinance untuk mengambil harga saham historis, pandas dan NumPy untuk pemrosesan data, serta Matplotlib untuk memplot harga aktual versus prediksi. Kami juga membatasi versi pandas ke rentang yang digunakan selama pengujian untuk menghindari peringatan terkait kompatibilitas.

Sebelum melanjutkan, pastikan PyTorch dapat mengakses GPU Anda:

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')"Didukung oleh

Output kami:

2.7.0+cu126
True
NVIDIA GeForce RTX 4070Didukung oleh

Nilai True mengonfirmasi bahwa CUDA tersedia untuk PyTorch, dan baris terakhir mengidentifikasi GPU. Kita kini siap mulai bereksperimen dengan Timestral.

Alih-alih skrip Python terpisah, kita akan menggunakan JupyterLab agar dapat menjalankan kode selangkah demi selangkah, memeriksa nilai ramalan, dan membandingkan prediksi dengan data pasar aktual. Luncurkan JupyterLab dari direktori proyek Anda:

python -m jupyter labDidukung oleh

Buka URL yang ditampilkan di terminal Anda, biasanya http://localhost:8888/lab, dan buat notebook Python baru menggunakan lingkungan yang baru saja kita konfigurasikan. Kita akan menggunakan notebook ini untuk memuat Timestral, menghasilkan prediksi, dan mengevaluasi performa model.

Meramalkan Harga Saham Apple dengan Timestral

Alih-alih membuat data sintetis, kita akan menggunakan harga saham Apple historis yang nyata dan mengukur seberapa akurat Timestral memprediksi harga penutupan hari perdagangan berikutnya.

Untuk membuat eksperimen lebih realistis, kita akan menggunakan peramalan bergulir satu hari. Untuk setiap hari perdagangan dalam periode uji, Timestral menerima 500 harga penutupan sebelumnya dan hanya memprediksi penutupan hari berikutnya.

Kita juga akan membandingkan dua metode:

• Peramalan harga mentah: Memrediksi harga penutupan berikutnya secara langsung.
• Peramalan log-return: Memrediksi perubahan harga logaritmik berikutnya dan mengonversinya kembali menjadi harga penutupan.

1. Unduh harga saham historis

Mulai sebuah notebook dan impor pustaka yang diperlukan. Kita juga menetapkan ticker, jumlah hari uji, jendela konteks, dan nama model.

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"Didukung oleh

Sekarang unduh data harian saham Apple selama lima tahun. Menetapkan auto_adjust=True mengembalikan harga penutupan yang telah disesuaikan untuk pemecahan saham dan dividen.

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())Didukung oleh

Kita menggunakan 60 sesi perdagangan terakhir untuk pengujian dan 500 observasi sebelumnya sebagai konteks untuk setiap prediksi.

2. Muat Timestral pada GPU Anda

Muat model 209M ke GPU, dengan cadangan CPU jika CUDA tidak tersedia. Bobot sebesar 837 MB diunduh dari Hugging Face saat pertama kali Anda menjalankan sel ini.

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

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

print(f"Loaded {MODEL} on {device}")Didukung oleh

Model kami berhasil dimuat pada RTX 4070:

Loaded mistralai/Timestral-209M on cudaDidukung oleh

3. Hasilkan peramalan bergulir satu hari

Sekarang kita menghasilkan dua prediksi untuk setiap hari perdagangan: satu dari harga penutupan historis dan satu dari log return. Log return adalah perubahan hari ke hari pada logaritma harga, dan kita mengonversi setiap return yang diprediksi kembali menjadi harga menggunakan penutupan sebelumnya.

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())Didukung oleh

Model menghasilkan 60 peramalan bergulir satu hari, menggunakan 500 harga penutupan sebelumnya untuk masing-masing. Setiap ramalan hanya menggunakan data yang tersedia sebelum hari target, sehingga harga di masa depan tidak dapat bocor ke masukan model.

4. Evaluasi akurasi ramalan

Kita mengukur mean absolute error (MAE), root mean squared error (RMSE), mean absolute percentage error (MAPE), dan akurasi arah. Kita juga membandingkan Timestral dengan baseline naif yang mengasumsikan harga penutupan besok akan sama dengan hari ini.

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}%")Didukung oleh

Hasil kami menunjukkan bahwa Timestral berkinerja sedikit lebih baik saat meramalkan log return daripada harga saham mentah. 

Pendekatan log-return mencapai MAE terendah ($3,05), RMSE ($3,84), dan MAPE (0,93%), sedikit mengungguli model baseline kami. 

Yang lebih penting, akurasi arah meningkat dari 41,67% dengan harga mentah menjadi 55% dengan log return, yang menunjukkan kinerja lebih baik dalam memprediksi apakah harga saham akan naik atau turun. 

Model harga mentah juga mencapai cakupan interval prediksi 81,7%, mendekati 80% yang diharapkan, yang menunjukkan estimasi ketidakpastian yang cukup terkalibrasi. Secara keseluruhan, Timestral menghasilkan ramalan harga yang cukup akurat, tetapi peningkatannya dibanding baseline sederhana minimal, dan pengujian lebih lanjut diperlukan untuk menentukan apakah prediksinya dapat secara andal mendukung keputusan perdagangan.

5. Visualisasikan prediksi Timestral

Mari plot harga penutupan aktual terhadap kedua metode peramalan menggunakan 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()Didukung oleh

Grafik menunjukkan seberapa dekat Timestral mengikuti harga aktual Apple selama 60 hari perdagangan. Kedua pendekatan menangkap tren naik, dan area oranye berbayang adalah interval prediksi 10-90% dari model harga mentah. Panel bawah memplot kesalahan prediksi harian.

Kebanyakan kesalahan berada dalam kisaran sekitar $5, dengan beberapa miss yang lebih besar $9 hingga $11 saat terjadi pergerakan harga mendadak. Kedua metode menghasilkan ramalan yang hampir identik, dengan log return sedikit unggul. Kedua garis ramalan juga tertinggal dari harga aktual sekitar satu hari, yang sesuai dengan kecilnya selisih terhadap baseline naif.

6. Hasilkan sinyal Beli, Tahan, dan Jual

Sekarang mari konversi prediksi harga mentah menjadi sinyal Beli, Tahan, dan Jual eksperimental. Kita menggunakan ambang 1% pada perubahan harga yang diprediksi:

• BUY: Kenaikan harga yang diprediksi lebih besar dari 1%.
• SELL: Penurunan harga yang diprediksi lebih besar dari 1%.
• HOLD: Pergerakan harga yang diprediksi di antara -1% hingga +1%.

Kita dapat menerapkan aturan ini dengan 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")Didukung oleh

Seluruh 60 hari perdagangan menghasilkan sinyal HOLD, tanpa rekomendasi BUY atau SELL. Pada 10 baris terakhir yang ditampilkan, perubahan yang diharapkan tidak pernah melebihi 0,15% ke salah satu arah, jauh di bawah ambang 1% kami.

Sinyal ini berasal dari prediksi harga mentah, yang memiliki akurasi arah lebih lemah (41,67%). Untuk melihat sinyal dari peramalan log-return, ganti price_predictions dengan return_predictions dalam perhitungan change_pct. Ambang yang lebih rendah akan menghasilkan lebih banyak sinyal BUY dan SELL, tetapi juga akan membuatnya lebih sensitif terhadap kesalahan peramalan dan noise pasar.

Sinyal-sinyal ini untuk eksperimen, bukan perdagangan langsung, dan tidak ada dalam tutorial ini yang merupakan nasihat keuangan. Diperlukan backtesting lebih lanjut, penyesuaian ambang, dan analisis biaya transaksi untuk mengetahui apakah sinyal tersebut dapat mendukung strategi yang menguntungkan.

Pikiran Akhir

Secara keseluruhan, saya sangat terkesan dengan Timestral. 

Seluruh proses penyiapan berjalan mudah, inferensi cepat, dan saya bisa menjalankan semuanya secara lokal di RTX 4070 saya tanpa bergantung pada API eksternal. 

Yang membuatnya semakin menarik adalah model-model ringan ini juga dapat berjalan di CPU, sehingga dapat diakses tanpa perangkat keras mahal.

Dalam hal akurasi peramalan, hasil kami campuran. 

Timestral mengikuti harga saham dengan cukup baik, tetapi hanya sedikit lebih baik daripada baseline sederhana.

Saya bukan ahli peramalan keuangan atau perdagangan, jadi mungkin masih banyak yang bisa saya lakukan dengan persiapan data, strategi peramalan, dan penalaan parameter untuk mendapatkan hasil yang lebih baik.

Saya sebelumnya menggunakan layanan peramalan terkelola seperti TimeGPT, tetapi Timestral membuat peramalan lokal jauh lebih menarik. Sejak dirilis, saya mulai memindahkan lebih banyak beban kerja peramalan saya ke model lokal karena cepat, ringan, dan bebas dari panggilan API serta biaya berbasis penggunaan.

Bagi saya, kekuatan terbesar Timestral bukan hanya akurasi, melainkan betapa mudah dan murahnya ia membuat proses peramalan.

Anda dapat menjalankan model deret waktu yang mumpuni pada perangkat keras Anda sendiri, bereksperimen secara leluasa, dan membangunnya ke dalam aplikasi tanpa bergantung pada layanan eksternal. Meski prediksi saham kami tidak mengesankan, saya pikir Timestral adalah opsi yang sangat baik bagi siapa pun yang membangun aplikasi peramalan lokal.

Jika Anda ingin mempelajari lebih lanjut tentang peramalan, saya sarankan melihat kursus Time Series Analysis in Python kami. Untuk pemodelan khusus keuangan, coba Machine Learning for Finance in Python.