टाइम सीरीज़ फ़ोरकास्टिंग के लिए Mistral Timestral को लोकल पर कैसे चलाएँ

क्या होगा यदि आप एक छोटे से AI मॉडल से, जो लोकल पर चलता है, मिलीसेकंड्स में प्रेडिक्शन देता है, और किसी अतिरिक्त प्रशिक्षण की ज़रूरत नहीं होती, स्टॉक की कीमतों का पूर्वानुमान लगा सकें?

टाइम-सीरीज़ फ़ोरकास्टिंग आमतौर पर ARIMA जैसे सांख्यिकीय तरीकों, मशीन लर्निंग पाइपलाइनों, या किसी विशिष्ट डेटासेट पर प्रशिक्षित मॉडलों का मतलब होती है। Timestral, जो Mistral AI द्वारा 15 अक्टूबर, 2026 को जारी ओपन-वेट फ़ोरकास्टिंग मॉडलों का परिवार है, एक अलग दृष्टिकोण अपनाता है। यह बिना फाइन-ट्यूनिंग के ऐतिहासिक डेटा से भविष्य के मानों की भविष्यवाणी करता है, और Mistral के अनुसार, इसका सबसे बड़ा मॉडल तीन सार्वजनिक बेंचमार्क्स पर प्रीट्रेन किए गए ज़ीरो-शॉट मॉडलों में पहले स्थान पर है।

छोटे आकार के बावजूद, ये मॉडल कई फ़ोरकास्टिंग बेंचमार्क्स पर प्रतिस्पर्धी सटीकता देते हैं और इन्हें वित्तीय बाज़ारों से लेकर ऊर्जा खपत और रिटेल मांग तक हर चीज़ पर लागू किया जा सकता है।

इस ट्यूटोरियल में, हम देखेंगे कि Timestral क्या है और यह कैसे काम करता है, इसे Python और uv के साथ लोकल पर सेट अप करेंगे, और वास्तविक Apple (AAPL) स्टॉक डेटा पर परीक्षण करेंगे। हम रोलिंग एक-দিন के फ़ोरकास्ट बनाएँगे, उन्हें वास्तविक क्लोज़िंग कीमतों और एक साधारण बेसलाइन से तुलना करेंगे, और प्रेडिक्शन को सरल Buy, Sell, या Hold संकेतों में बदलेंगे। आप हमारे TimeGPT के साथ टाइम सीरीज़ फ़ोरकास्टिंग और टाइम सीरीज़ फ़ोरकास्टिंग के लिए ARIMA पर ट्यूटोरियल भी देख सकते हैं।

Mistral Timestral क्या है?

Timestral, तेज़ और जनरल-पर्पज़ फ़ोरकास्टिंग के लिए Mistral AI का ओपन-वेट टाइम-सीरीज़ फ़ाउंडेशन मॉडल परिवार है। टाइम-सीरीज़ फ़ाउंडेशन मॉडल एक बार बड़े और विविध सीरीज़ संग्रह पर प्रीट्रेन किया जाता है, ताकि वह पहले न देखे गए डेटा का भी फ़ोरकास्ट कर सके।

पारंपरिक फ़ोरकास्टिंग मॉडलों के विपरीत जिन्हें किसी विशिष्ट डेटासेट पर प्रशिक्षण की आवश्यकता होती है, Timestral ज़ीरो-शॉट फ़ोरकास्टिंग का समर्थन करता है। यह बिना किसी अतिरिक्त प्रशिक्षण या फाइन-ट्यूनिंग के सीधे ऐतिहासिक डेटा से भविष्य के मानों की भविष्यवाणी करता है।

Timestral एक कॉज़ल, पैच-आधारित ट्रांसफॉर्मर है जिसे मुख्यतः सिंथेटिक डेटा पर प्रशिक्षित किया गया है, और फिर वास्तविक एवं सिंथेटिक डेटा के मिश्रण पर दूसरे प्रशिक्षण चरण से गुजारा गया है। यह स्टॉक कीमतें, ऊर्जा मांग, बिक्री, और सेंसर मापन संभालता है। Mistral अपनी टेक्निकल रिपोर्ट में आर्किटेक्चर और प्रशिक्षण का वर्णन करता है।

Mistral ने चार साइज जारी किए हैं, जिनमें मॉडल आकार, गति, और सटीकता के बीच अलग-अलग संतुलन हैं:

Mistral के प्रकाशित बेंचमार्क्स के अनुसार, Timestral-209M प्रीट्रेन और ज़ीरो-शॉट मॉडलों में GIFT-Eval, TIME, और fev-bench पर पहले स्थान पर है। रिपोर्ट की गई तुलना में यह TimesFM-3 और Falcon-2.0 जैसे बड़े मॉडलों को पछाड़ता है। ये Mistral के अपने परिणाम हैं, जो GIFT-Eval और TIME लीडरबोर्ड्स को सबमिट किए गए हैं, इसलिए स्वतंत्र पुष्टि के लिए लीडरबोर्ड्स देखें।

गति एक और लाभ है। 8 थ्रेड्स वाले स्टैंडर्ड सर्वर CPU पर, Mistral रिपोर्ट करता है कि Timestral-209M तीन हफ्तों की 15-मिनट हिस्ट्री से एक दिन आगे का फ़ोरकास्ट 113 मिलीसेकंड में देता है, और 5M मॉडल 17 मिलीसेकंड लेता है। GPU आवश्यक नहीं है।

Timestral इन फ़ोरकास्टिंग सुविधाओं का समर्थन करता है:

• लंबा ऐतिहासिक संदर्भ: अधिकतम 32,768 ऐतिहासिक टाइम स्टेप स्वीकार करता है।
• मल्टीवेरिएट फ़ोरकास्टिंग: बेहतर प्रेडिक्शन के लिए कई संबंधित टाइम सीरीज़ का साथ में फ़ोरकास्ट करता है।
• प्रॉबेबिलिस्टिक प्रेडिक्शन: एकल मान के बजाय अनिश्चितता आकलन के लिए 21 क्वांटाइल लौटाता है।
• कोवेरिएट्स: ऐसे पास्ट-ओनली और नोन-फ्यूचर वेरिएबल (संख्यात्मक या श्रेणीबद्ध) स्वीकार करता है जो फ़ोरकास्ट को प्रभावित कर सकते हैं।
• लोकल इन्फ़रेंस: बिना किसी पेड API के CPU और GPU पर चलता है। कोड Apache 2.0 के अंतर्गत और वेट्स संशोधित MIT लाइसेंस के अंतर्गत जारी किए गए हैं।

इस ट्यूटोरियल में, हम Timestral-209M का उपयोग करेंगे, जो Mistral के प्रकाशित बेंचमार्क्स के अनुसार परिवार का सबसे बड़ा और सबसे सटीक मॉडल है। हम इसे NVIDIA RTX 4070 GPU पर लोकल चलाएँगे ताकि स्टॉक कीमतों का फ़ोरकास्ट कर सकें और वास्तविक मार्केट डेटा पर इसके प्रदर्शन का मूल्यांकन कर सकें।

Linux पर Timestral सेट अप करें

Timestral को Python 3.10 या बाद का और PyTorch 2.4 या बाद का चाहिए। हम Python 3.12, PyTorch 2.7.0, और uv का उपयोग करके Linux मशीन पर एक हल्का डेवलपमेंट वातावरण बनाएँगे। Timestral CPU इन्फ़रेंस का भी समर्थन करता है, इसलिए GPU वैकल्पिक है।

पहले, जाँचें कि आपका NVIDIA GPU डिटेक्ट हो रहा है और उसके ड्राइवर्स काम कर रहे हैं:

nvidia-smiसंचालित द्वारा

यह कमांड आपके GPU की जानकारी, ड्राइवर वर्ज़न, और CUDA संगतता दिखाता है। यदि आउटपुट में आपका GPU दिखाई देता है, तो आप आगे बढ़ सकते हैं।

अगला, तेज़ Python पैकेज और एनवायरनमेंट मैनेजर uv इंस्टॉल करें:

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संचालित द्वारा

इसके बाद, CUDA 12.6 सपोर्ट के साथ PyTorch 2.7.0 इंस्टॉल करें:

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 नहीं है, तो इंडेक्स URL को https://download.pytorch.org/whl/cpu से बदलकर 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 के साथ प्रयोग शुरू करने के लिए तैयार हैं।

अलग-अलग Python स्क्रिप्ट्स की जगह, हम JupyterLab का उपयोग करेंगे ताकि हम कोड को चरण-दर-चरण चला सकें, फ़ोरकास्ट मानों का निरीक्षण कर सकें, और प्रेडिक्शन को वास्तविक मार्केट डेटा से तुलना कर सकें। अपने प्रोजेक्ट डायरेक्टरी से JupyterLab लॉन्च करें:

python -m jupyter labसंचालित द्वारा

अपने टर्मिनल में दिखाए गए URL को खोलें, आमतौर पर http://localhost:8888/lab, और अभी कॉन्फ़िगर किए गए एनवायरनमेंट का उपयोग करते हुए एक नया Python नोटबुक बनाएँ। हम इस नोटबुक का उपयोग Timestral लोड करने, प्रेडिक्शन जनरेट करने, और यह मूल्यांकन करने के लिए करेंगे कि मॉडल कितना अच्छा प्रदर्शन करता है।

Timestral से Apple स्टॉक कीमतों का फ़ोरकास्ट करें

सिंथेटिक डेटा जनरेट करने के बजाय, हम वास्तविक ऐतिहासिक 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 पर लोड करें, और यदि CUDA उपलब्ध नहीं है तो CPU पर फॉल बैक करें। इस सेल को पहली बार चलाने पर 837 MB वेट्स 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. फ़ोरकास्ट सटीकता का मूल्यांकन करें

हम mean absolute error (MAE), root mean squared error (RMSE), mean absolute percentage error (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% प्रेडिक्शन इंटरवल कवरेज भी हासिल किया, जो अपेक्षित 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()संचालित द्वारा

चार्ट दिखाता है कि 60 ट्रेडिंग दिनों में Timestral Apple की वास्तविक कीमतों का कितना नज़दीकी अनुसरण करता है। दोनों तरीक़े ऊपर की ओर रुझान को पकड़ते हैं, और शेडेड ऑरेंज क्षेत्र रॉ-प्राइस मॉडल का 10-90% प्रेडिक्शन इंटरवल है। नीचे का पैनल दैनिक प्रेडिक्शन त्रुटियाँ प्लॉट करता है।

अधिकांश त्रुटियाँ लगभग $5 के भीतर रहती हैं, और अचानक प्राइस मूवमेंट के दौरान $9 से $11 के कुछ बड़े मिसेज़ दिखते हैं। दोनों तरीक़े लगभग एक जैसे फ़ोरकास्ट देते हैं, जिनमें लॉग रिटर्न थोड़ा आगे रहता है। दोनों फ़ोरकास्ट लाइनें वास्तविक कीमत से लगभग एक दिन पीछे भी चलती हैं, जो साधारण बेसलाइन से छोटे अंतर के अनुरूप है।

6. Buy, Hold, और Sell संकेत जनरेट करें

अब रॉ-प्राइस प्रेडिक्शन को प्रायोगिक Buy, Hold, और Sell संकेतों में बदलते हैं। हम अनुमानित प्राइस परिवर्तन पर 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%) थी। लॉग-रिटर्न फ़ोरकास्ट से संकेत देखने के लिए, change_pct की गणना में price_predictions की जगह return_predictions डालें। कम थ्रेशोल्ड अधिक BUY और SELL संकेत पैदा करेगा, लेकिन इससे वे फ़ोरकास्टिंग त्रुटियों और मार्केट शोर के प्रति अधिक संवेदनशील भी हो जाएँगे।

ये संकेत प्रयोग के लिए हैं, लाइव ट्रेडिंग के लिए नहीं, और इस ट्यूटोरियल में कुछ भी वित्तीय सलाह नहीं है। यह जानने के लिए कि क्या ये लाभदायक रणनीति का समर्थन कर सकते हैं, और बैकटेस्टिंग, थ्रेशोल्ड ट्यूनिंग, और ट्रांज़ैक्शन कॉस्ट विश्लेषण आवश्यक होंगे।

अंतिम विचार

कुल मिलाकर, मैं Timestral से काफ़ी प्रभावित हूँ। 

पूरा सेटअप सीधा-सादा था, इन्फ़रेंस तेज़ था, और मैं बाहरी API पर निर्भर हुए बिना अपना सब कुछ RTX 4070 पर लोकल चला सका। 

और भी आकर्षक यह है कि ये हल्के मॉडल CPU पर भी चल सकते हैं, जिससे इन्हें महंगे हार्डवेयर के बिना भी सुलभ बनाया जा सकता है।

जहाँ तक फ़ोरकास्टिंग सटीकता की बात है, हमारे परिणाम मिले-जुले रहे। 

Timestral ने स्टॉक कीमतों का ठीक-ठाक अनुसरण किया, लेकिन यह मुश्किल से ही साधारण बेसलाइन से आगे निकला।

मैं वित्तीय फ़ोरकास्टिंग या ट्रेडिंग का विशेषज्ञ नहीं हूँ, इसलिए बेहतर परिणाम पाने के लिए डेटा तैयारी, फ़ोरकास्टिंग रणनीतियों, और पैरामीटर ट्यूनिंग में शायद मैं और कुछ कर सकता हूँ।

मैंने पहले TimeGPT जैसी होस्टेड फ़ोरकास्टिंग सेवाओं का उपयोग किया है, लेकिन Timestral ने लोकल फ़ोरकास्टिंग को कहीं अधिक आकर्षक बना दिया है। इसके रिलीज़ के बाद से, मैंने अपनी अधिक फ़ोरकास्टिंग वर्कलोड्स को लोकल मॉडलों पर स्थानांतरित करना शुरू कर दिया है क्योंकि वे तेज़, हल्के, और API कॉल्स व उपयोग-आधारित फीस से मुक्त हैं।

मेरे लिए, Timestral की सबसे बड़ी ताकत केवल सटीकता नहीं, बल्कि फ़ोरकास्टिंग को आसान और कम-खर्चीला बनाना है।

आप अपने हार्डवेयर पर एक सक्षम टाइम-सीरीज़ मॉडल चला सकते हैं, स्वतंत्र रूप से प्रयोग कर सकते हैं, और इसे एप्लिकेशंस में बना सकते हैं—वो भी बाहरी सेवाओं पर निर्भर हुए बिना। भले ही हमारे स्टॉक प्रेडिक्शन प्रभावशाली नहीं थे, मुझे लगता है कि लोकल फ़ोरकास्टिंग एप्लिकेशन बनाने वाले किसी भी व्यक्ति के लिए Timestral एक उत्कृष्ट विकल्प है।

यदि आप फ़ोरकास्टिंग के बारे में और सीखने के इच्छुक हैं, तो हमारा Time Series Analysis in Python कोर्स देखें। वित्त-विशिष्ट मॉडलिंग के लिए, Machine Learning for Finance in Python आज़माएँ।