finetune chronos-bolt-small

app.py

@@ -1,411 +1,69 @@
-# app.py
-import os, random, time
-from typing import Tuple
-import numpy as np
-import pandas as pd
-import torch
 import gradio as gr
-import matplotlib
-matplotlib.use("Agg")
 import matplotlib.pyplot as plt
-
-from chronos import ChronosPipeline
-
-AGTS_AVAILABLE = False
-try:
-    from autogluon.timeseries import TimeSeriesPredictor, TimeSeriesDataFrame
-    try:
-        from autogluon.common.utils.seed import set_seed as ag_set_seed
-    except Exception:
-        ag_set_seed = None
-    AGTS_AVAILABLE = True
-except Exception:
-    ag_set_seed = None
-    pass
-
-import pipeline_v2 as pipe2
-
-# --------------------
-# Config
-# --------------------
-FINETUNED_DIR = os.path.abspath("./finetuned_predictor")
-MODEL_ID_FALLBACK = os.getenv("MODEL_ID", "amazon/chronos-t5-large")
-
-PREDICTION_LENGTH = 30
-NUM_SAMPLES = 1
-RV_WINDOW = 20
-ANNUALIZE = True
-EPS = 1e-8
-
-AUTO_TICKERS = os.getenv("AUTO_TICKERS", "AAPL,MSFT,AMZN,NVDA,GOOGL,TSLA,SPY,TLT").split(",")
-AUTO_START = os.getenv("AUTO_START", "2010-01-01")
-AUTO_INTERVAL = os.getenv("AUTO_INTERVAL", "1d")  # "1d","1wk","1mo"
-AUTO_MODEL_PATH = os.getenv("AUTO_MODEL_PATH", "autogluon/chronos-bolt-base")
-AUTO_STEPS = int(os.getenv("AUTO_STEPS", "900"))
-AUTO_LR = float(os.getenv("AUTO_LR", "1e-4"))
-AUTO_SEED = int(os.getenv("AUTO_SEED", "0"))
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-dtype = torch.bfloat16 if device == "cuda" else torch.float32
-
-# ---- global seeding ----
-def set_global_seed(seed: int):
-    random.seed(seed)
-    np.random.seed(seed)
-    try:
-        torch.manual_seed(seed)
-        if torch.cuda.is_available():
-            torch.cuda.manual_seed_all(seed)
-    except Exception:
-        pass
-    if ag_set_seed is not None:
-        try:
-            ag_set_seed(seed)
-        except Exception:
-            pass
-set_global_seed(AUTO_SEED)
-
-# ---- utils ----
-def _extract_close(df: pd.DataFrame) -> pd.Series:
-    if isinstance(df.columns, pd.MultiIndex):
-        for name in ["Adj Close", "Adj_Close", "adj close", "adj_close"]:
-            if name in df.columns.get_level_values(0):
-                sub = df.xs(name, axis=1, level=0)
-                if sub.shape[1] > 1:
-                    sub = sub.iloc[:, 0]
-                return pd.to_numeric(sub.squeeze(), errors="coerce").dropna()
-        for name in ["Close", "close", "Price", "price"]:
-            if name in df.columns.get_level_values(0):
-                sub = df.xs(name, axis=1, level=0)
-                if sub.shape[1] > 1:
-                    sub = sub.iloc[:, 0]
-                return pd.to_numeric(sub.squeeze(), errors="coerce").dropna()
-    mapping = {c.lower(): c for c in df.columns}
-    for name in ["adj close", "adj_close", "close", "price"]:
-        if name in mapping:
-            return pd.to_numeric(df[mapping[name]], errors="coerce").dropna()
-    num_cols = df.select_dtypes(include=[np.number]).columns
-    if len(num_cols) == 0:
-        raise gr.Error("No numeric price column found in downloaded data.")
-    return pd.Series(df[num_cols[-1]]).astype(float)
-
-def _extract_dates(df: pd.DataFrame):
-    if isinstance(df.index, pd.DatetimeIndex):
-        return df.index.to_numpy()
-    mapping = {c.lower(): c for c in df.columns}
-    for name in ["date", "time", "timestamp"]:
-        if name in mapping:
-            try:
-                return pd.to_datetime(df[mapping[name]]).to_numpy()
-            except Exception:
-                pass
-    return np.arange(len(df))
-
-def compute_realized_vol(close: pd.Series, window: int = 20, annualize: bool = True) -> pd.Series:
-    r = np.log(close).diff().dropna()
-    rv = r.rolling(window, min_periods=window).std()
-    if annualize:
-        rv = rv * np.sqrt(252.0)
-    return rv.dropna().reset_index(drop=True)
-
-def bias_scale_calibration(y_true: np.ndarray, y_pred: np.ndarray) -> Tuple[float, np.ndarray]:
-    alpha = float(np.sum(y_true * y_pred) / (np.sum(y_pred**2) + EPS))
-    return alpha, alpha * y_pred
-
-def compute_metrics(y_true: np.ndarray, y_pred: np.ndarray) -> dict:
-    err = y_pred - y_true
-    denom = np.maximum(EPS, np.abs(y_true))
-    mape = float((np.abs(err) / denom).mean() * 100)
-    mpe  = float((err / np.maximum(EPS, y_true)).mean() * 100)
-    rmse = float(np.sqrt(np.mean(err**2)))
-    return {"MAPE": mape, "MPE": mpe, "RMSE": rmse}
-
-# ---- frequency helpers ----
-def interval_to_freq(interval: str) -> str:
-    interval = (interval or "").lower().strip()
-    if interval == "1d":
-        return "B"        # Business day
-    if interval == "1wk":
-        return "W-FRI"    # Wochenende vermeiden, Börsenwoche endend Fr
-    if interval == "1mo":
-        return "M"        # Monatlich (Kalenderende)
-    return "B"
-
-# --------------------
-# Auto-Finetune
-# --------------------
-def _download_close(ticker: str, start: str, interval: str) -> pd.Series:
-    import yfinance as yf
-    df = yf.download(ticker, start=start, interval=interval, auto_adjust=False, progress=False, threads=True)
-    if df is None or df.empty:
-        raise RuntimeError(f"No data for {ticker}")
-    if isinstance(df.columns, pd.MultiIndex):
-        for name in ["Adj Close", "Close"]:
-            if name in df.columns.get_level_values(0):
-                s = df.xs(name, axis=1, level=0)
-                if s.shape[1] > 1:
-                    s = s.iloc[:, 0]
-                return pd.to_numeric(s.squeeze(), errors="coerce").dropna()
-    if "Adj Close" in df.columns:
-        return pd.to_numeric(df["Adj Close"], errors="coerce").dropna()
-    if "Close" in df.columns:
-        return pd.to_numeric(df["Close"], errors="coerce").dropna()
-    num_cols = df.select_dtypes(include=[np.number]).columns
-    if len(num_cols) == 0:
-        raise RuntimeError(f"No numeric close for {ticker}")
-    return pd.Series(df[num_cols[-1]]).astype(float)
-
-def _build_tsdf(tickers, start, interval, rv_window, annualize=True) -> TimeSeriesDataFrame:
-    rows = []
-    for t in tickers:
-        s_close = _download_close(t, start, interval)
-        r = np.log(s_close).diff().dropna()
-        rv = r.rolling(rv_window, min_periods=rv_window).std()
-        if annualize:
-            rv = rv * np.sqrt(252.0)
-        rv = rv.dropna()
-        rows.append(pd.DataFrame({"item_id": t, "timestamp": rv.index, "target": rv.values}))
-    df_long = pd.concat(rows, ignore_index=True)
-    tsdf = TimeSeriesDataFrame.from_data_frame(df_long, id_column="item_id", timestamp_column="timestamp")
-
-    # Frequenz erzwingen/vereinheitlichen (gegen "Cannot infer frequency")
-    freq = interval_to_freq(interval)
-    try:
-        tsdf = tsdf.convert_frequency(freq=freq)  # reguläre Zeitachsen je item
-    except Exception:
-        # Fallback: per GroupBy resamplen (asfreq) + forward-fill kleiner Lücken
-        def _regularize(g):
-            g = g.set_index("timestamp").asfreq(freq)
-            g["target"] = g["target"].ffill()
-            g["item_id"] = g["item_id"].ffill().bfill()
-            return g.reset_index()
-        reg = (
-            df_long.groupby("item_id", group_keys=False)
-            .apply(_regularize)
-        )
-        tsdf = TimeSeriesDataFrame.from_data_frame(reg, id_column="item_id", timestamp_column="timestamp")
-    return tsdf
-
-def ensure_finetuned_predictor(log_cb=print):
-    if not AGTS_AVAILABLE:
-        log_cb("AutoGluon not available; using Zero-Shot Chronos.")
-        return None
-
-    if os.path.isdir(FINETUNED_DIR) and os.path.exists(os.path.join(FINETUNED_DIR, "metadata.json")):
-        try:
-            predictor = TimeSeriesPredictor.load(FINETUNED_DIR)
-            log_cb(f"Loaded finetuned predictor from {FINETUNED_DIR}.")
-            return predictor
-        except Exception as e:
-            log_cb(f"Existing predictor could not be loaded, retraining. Reason: {e}")
-
-    os.makedirs(FINETUNED_DIR, exist_ok=True)
-    log_cb("No finetuned predictor found. Starting on-device fine-tuning (Chronos-Bolt)...")
-
-    tsdf = _build_tsdf([t.strip() for t in AUTO_TICKERS if t.strip()],
-                       AUTO_START, AUTO_INTERVAL, RV_WINDOW, annualize=True)
-
-    freq = interval_to_freq(AUTO_INTERVAL)
-    predictor = TimeSeriesPredictor(
-        prediction_length=PREDICTION_LENGTH,
-        target="target",
-        eval_metric="WQL",
-        freq=freq,  # <<<<<< WICHTIG
-    )
-
-    hyperparams = {
-        "Chronos": {
-            "model_path": AUTO_MODEL_PATH,
-            "fine_tune": True,
-            "fine_tune_steps": AUTO_STEPS,
-            "fine_tune_lr": AUTO_LR,
-        }
-    }
-
-    predictor.fit(train_data=tsdf, hyperparameters=hyperparams, time_limit=None, presets=None)
-    predictor.save(FINETUNED_DIR)
-    log_cb(f"Saved finetuned predictor to: {FINETUNED_DIR}")
-    return predictor
-
-# --------------------
-# Modelle laden
-# --------------------
-pipe = None
-ag_predictor = None
-
-def _load_models():
-    global pipe, ag_predictor
-    ag_predictor = ensure_finetuned_predictor(log_cb=lambda m: print(f"[AutoFT] {m}"))
-    if ag_predictor is None:
-        print(f"[AutoFT] Falling back to Zero-Shot: {MODEL_ID_FALLBACK}")
-        pipe = ChronosPipeline.from_pretrained(
-            MODEL_ID_FALLBACK,
-            device_map="auto",
-            torch_dtype=dtype,
-        )
-    else:
-        pipe = None
-
-_load_models()
-
-# --------------------
-# Forecast backends
-# --------------------
-def _predict_with_chronos(rv_train: np.ndarray, H: int) -> np.ndarray:
-    random.seed(0); np.random.seed(0); torch.manual_seed(0)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(0)
-    context = torch.tensor(rv_train, dtype=torch.float32)
-    fcst = pipe.predict(context, prediction_length=H, num_samples=NUM_SAMPLES)
-    return fcst[0].cpu().numpy()[0]
-
-def _predict_with_ag(rv_train_idx: pd.DatetimeIndex, rv_train: np.ndarray, H: int) -> np.ndarray:
-    ts = pd.DataFrame({"item_id": "series", "timestamp": rv_train_idx, "target": rv_train})
-    ts_df = TimeSeriesDataFrame.from_data_frame(ts, id_column="item_id", timestamp_column="timestamp")
-    # Für Inferenz sicherstellen, dass Frequenz konsistent ist:
-    freq = interval_to_freq("1d")  # rv_train_idx kommt von daily-Daten im UI; falls nicht, kannst du hier dynamisch mappen
-    try:
-        ts_df = ts_df.convert_frequency(freq=freq)
-    except Exception:
-        pass
-    preds = ag_predictor.predict(ts_df, prediction_length=H)
-    if 0.5 in preds.quantile_levels:
-        return preds.loc[("series", 0.5)].to_numpy()
-    return preds.mean(axis=1).loc["series"].to_numpy()
-
-# --------------------
-# App-Logik (gleichbleibende Funktionalität)
-# --------------------
-def run_for_ticker(tickers: str, start: str, interval: str, use_calibration: bool):
-    tick_list = [t.strip() for t in tickers.replace(";", ",").replace("|", ",").split(",") if t.strip()]
-    if not tick_list:
-        raise gr.Error("Please enter at least one ticker, e.g. AAPL or NESN.SW")
-    ticker = tick_list[0]
-
-    try:
-        csv_path = pipe2.update_ticker_csv(ticker, start=start, interval=interval)
-    except Exception as e:
-        raise gr.Error(
-            f"Data fetch failed for '{ticker}'. Tip: ensure exchange suffixes (e.g., NESN.SW, BMW.DE, VOD.L).\n{e}"
-        )
-
-    try:
-        df = pd.read_csv(csv_path, index_col=0, parse_dates=True)
-        if not isinstance(df.index, pd.DatetimeIndex):
-            df = pd.read_csv(csv_path)
-    except Exception:
-        df = pd.read_csv(csv_path)
-
-    dates = _extract_dates(df)
-    close = _extract_close(df)
-
-    rv = compute_realized_vol(close, window=RV_WINDOW, annualize=ANNUALIZE).to_numpy()
-    n = len(rv); H = PREDICTION_LENGTH
-    if n <= H + 5:
-        raise gr.Error(f"Vol series too short after rolling window. Need > {H+5}, got {n}.")
-    rv_train = rv[: n - H]
-    rv_test  = rv[n - H :]
-
-    if ag_predictor is not None and isinstance(dates, np.ndarray) and isinstance(df.index, pd.DatetimeIndex):
-        rv_index = df.index[-len(rv):][:len(rv_train)]
-        path_pred = _predict_with_ag(rv_index, rv_train, H)
-        provider = "AutoGluon (finetuned)"
-    else:
-        path_pred = _predict_with_chronos(rv_train, H)
-        provider = f"Chronos {MODEL_ID_FALLBACK.split('/')[-1]}"
-
-    if use_calibration:
-        alpha, path_pred_cal = bias_scale_calibration(rv_test, path_pred)
-        metrics_raw = compute_metrics(rv_test, path_pred)
-        metrics_cal = compute_metrics(rv_test, path_pred_cal)
-    else:
-        alpha, path_pred_cal, metrics_cal = None, None, None
-        metrics_raw = compute_metrics(rv_test, path_pred)
-
-    fig = plt.figure(figsize=(10, 4))
-    H0 = len(rv_train)
-    if isinstance(dates, np.ndarray) and len(dates) >= len(close):
-        dates_rv = np.array(dates[-len(rv):])
-        x_hist = dates_rv[:H0]
-        x_fcst = dates_rv[H0:]
-        x_lbl = "date"
-    else:
-        x_hist = np.arange(H0)
-        x_fcst = np.arange(H0, H0 + H)
-        x_lbl = "time index"
-
-    plt.plot(x_hist, rv_train, label="realized vol (history)")
-    plt.plot(x_fcst, rv_test, label="realized vol (actual last 30)")
-    plt.plot(x_fcst, path_pred, linestyle="--", label="forecast (raw path)")
-    if use_calibration:
-        plt.plot(x_fcst, path_pred_cal, linestyle="--", label=f"forecast (calibrated, α={alpha:.3f})")
-
-    plt.title(f"{ticker.upper()} — Volatility Forecast (RV={RV_WINDOW}, H={H}, interval={interval}, model={provider})")
-    plt.xlabel(x_lbl); plt.ylabel("realized volatility")
-    plt.legend(loc="best"); plt.tight_layout()
-
-    df_days = pd.DataFrame({
-        "date": x_fcst,
-        "actual_vol": rv_test,
-        "forecast_raw": path_pred,
-    })
-    if use_calibration:
-        df_days["forecast_calibrated"] = path_pred_cal
-        df_days["abs_pct_error_raw_%"] = np.abs((path_pred - rv_test) / np.maximum(EPS, np.abs(rv_test))) * 100
-        df_days["abs_pct_error_cal_%"] = np.abs((path_pred_cal - rv_test) / np.maximum(EPS, np.abs(rv_test))) * 100
-    else:
-        df_days["abs_pct_error_raw_%"] = np.abs((path_pred - rv_test) / np.maximum(EPS, np.abs(rv_test))) * 100
-
-    out = {
-        "ticker": ticker.upper(),
-        "csv_path": csv_path,
-        "config": {
-            "start": start,
-            "interval": interval,
-            "rv_window": RV_WINDOW,
-            "prediction_length": H,
-            "num_samples": NUM_SAMPLES,
-            "annualized": ANNUALIZE,
-            "point_forecast": "median_quantile" if ag_predictor is not None else "single_sample_path",
-            "model": provider,
-            "auto_finetuned_dir": FINETUNED_DIR,
-        },
-        "metrics_raw": {k: round(v, 4) for k, v in metrics_raw.items()},
-    }
-    metrics_md = f"**RAW** — MAPE {metrics_raw['MAPE']:.2f}% | MPE {metrics_raw['MPE']:.2f}% | RMSE {metrics_raw['RMSE']:.5f}"
-    if use_calibration and metrics_cal is not None:
-        out["alpha"] = alpha
-        out["metrics_calibrated"] = {k: round(v, 4) for k, v in metrics_cal.items()}
-        metrics_md += f"\n**CALIBRATED** — MAPE {metrics_cal['MAPE']:.2f}% | MPE {metrics_cal['MPE']:.2f}% | RMSE {metrics_cal['RMSE']:.5f}"
-
-    return fig, out, df_days, metrics_md
-
-# --------------------
-# UI
-# --------------------
-with gr.Blocks(title="Volatility Forecast • Auto-Finetuned Chronos-Bolt (on-device)") as demo:
-    gr.Markdown(
-        "### Predict last 30 days of realized volatility for any ticker\n"
-        "- **Auto-Finetune on first launch** (Chronos-Bolt via AutoGluon) → afterwards always uses the finetuned predictor.\n"
-        "- If AutoGluon is unavailable or training fails, falls back to Zero-Shot Chronos.\n"
-        "- Data via **yfinance** (pipeline_v2.update_ticker_csv).\n"
-        "- Day-by-day comparison with **MAPE/MPE/RMSE** and optional **α-calibration**."
-    )
-    with gr.Row():
-        tickers_in = gr.Textbox(value="AAPL", label="Ticker")
-    with gr.Row():
-        start_in = gr.Textbox(value="2015-01-01", label="Start date (YYYY-MM-DD)")
-        interval_in = gr.Dropdown(choices=["1d", "1wk", "1mo"], value="1d", label="Interval")
-        calib_in = gr.Checkbox(value=True, label="Apply bias/scale calibration (α)")
-    run_btn = gr.Button("Run", variant="primary")
-
-    plot = gr.Plot(label="Forecast vs Actual (last 30 days)")
-    meta = gr.JSON(label="Run config & metrics")
-    table = gr.Dataframe(label="Per-day comparison", wrap=True)
-    metrics = gr.Markdown(label="Summary")
-
-    run_btn.click(run_for_ticker, inputs=[tickers_in, start_in, interval_in, calib_in],
-                  outputs=[plot, meta, table, metrics])
-
-if __name__ == "__main__":
-    demo.launch()
+import pandas as pd
+from utils_vol import fetch_close_series, realized_vol
+from autogluon.timeseries import TimeSeriesPredictor
+from train_autogluon import train_bolt_small
+import os
+
+MODEL_DIR = "/mnt/data/AutogluonChronosBoltSmall"
+
+# ---------- Handlers ----------
+
+def predict_vol(ticker, start, interval):
+    if not os.path.isdir(MODEL_DIR):
+        raise gr.Error("Kein trainiertes Modell gefunden. Bitte zuerst trainieren.")
+    predictor = TimeSeriesPredictor.load(MODEL_DIR)
+    close = fetch_close_series(ticker, start=start, interval=interval)
+    rv = realized_vol(close)
+    df = pd.DataFrame({"timestamp": rv.index, "target": rv.values, "item_id": "series_1"})
+    forecast = predictor.predict(df)
+    f = forecast.to_pandas()
+    plt.figure(figsize=(8,4))
+    plt.plot(rv.index, rv.values, label="Historie")
+    plt.plot(f.index, f["0.5"], "--", label="Forecast (Median)")
+    plt.legend()
+    plt.title(f"{ticker} – Volatilitätsprognose (Chronos-Bolt-Small)")
+    return plt
+
+def train_model(ticker, start, interval):
+    train_bolt_small(ticker=ticker, start=start, interval=interval)
+    return f"Training abgeschlossen und unter {MODEL_DIR} gespeichert."
+
+def clear_model():
+    import shutil
+    if os.path.isdir(MODEL_DIR):
+        shutil.rmtree(MODEL_DIR)
+        return "Modell gelöscht."
+    return "Kein Modell zum Löschen gefunden."
+
+# ---------- UI ----------
+with gr.Blocks(title="Chronos-Bolt-Small (CPU) Fine-Tuning App") as demo:
+    gr.Markdown("## Chronos-Bolt-Small – Volatilitäts-Vorhersage\n"
+                "Trainiert auf CPU innerhalb von ~10 Minuten über AutoGluon.\n"
+                "• Tab **Train**: neues Modell fine-tunen\n"
+                "• Tab **Predict**: Vorhersage anzeigen\n"
+                "• Tab **Manage**: Modell löschen")
+
+    with gr.Tab("Predict"):
+        t1 = gr.Textbox(label="Ticker", value="AAPL")
+        s1 = gr.Textbox(label="Startdatum", value="2015-01-01")
+        i1 = gr.Dropdown(["1d","1wk","1mo"], value="1d", label="Intervall")
+        btn_p = gr.Button("Vorhersagen")
+        out_p = gr.Plot()
+        btn_p.click(predict_vol, inputs=[t1, s1, i1], outputs=[out_p])
+
+    with gr.Tab("Train"):
+        t2 = gr.Textbox(label="Ticker", value="AAPL")
+        s2 = gr.Textbox(label="Startdatum", value="2015-01-01")
+        i2 = gr.Dropdown(["1d","1wk","1mo"], value="1d", label="Intervall")
+        btn_t = gr.Button("Train (AutoGluon Chronos-Bolt-Small)")
+        out_t = gr.Textbox(label="Train-Log", lines=8)
+        btn_t.click(train_model, inputs=[t2, s2, i2], outputs=[out_t])
+
+    with gr.Tab("Manage"):
+        btn_c = gr.Button("Modell löschen")
+        out_c = gr.Textbox(label="Status")
+        btn_c.click(clear_model, outputs=[out_c])
+
+demo.launch()

requirements.txt

@@ -1,8 +1,8 @@
-gradio>=4.0
-chronos-forecasting>=1.5
+autogluon.timeseries==1.4.0
+chronos-forecasting>=2.0.0
 torch>=2.2
-pandas>=2.0
 numpy>=1.26
+pandas>=2.0
+gradio>=4.0
 matplotlib>=3.8
 yfinance>=0.2.40
-autogluon.timeseries>=1.3,<1.6

train_autogluon.py

@@ -0,0 +1,40 @@
+from autogluon.timeseries import TimeSeriesPredictor
+from utils_vol import fetch_close_series, realized_vol, rv_to_autogluon_df
+
+def train_bolt_small(ticker="AAPL", start="2015-01-01", interval="1d",
+                     prediction_length=30, time_limit=900):
+    """
+    Trainiert Chronos-Bolt-Small mit AutoGluon auf CPU.
+    time_limit in Sekunden (Standard: 15 min).
+    """
+    print(f"[AutoFT] Lade {ticker}...")
+    close = fetch_close_series(ticker, start=start, interval=interval)
+    rv = realized_vol(close)
+    df = rv_to_autogluon_df(rv)
+
+    predictor = TimeSeriesPredictor(
+        path="/mnt/data/AutogluonChronosBoltSmall",
+        prediction_length=prediction_length,
+        eval_metric="WQL",
+        verbosity=2,
+    )
+
+    predictor.fit(
+        train_data=df,
+        enable_ensemble=False,
+        num_val_windows=1,
+        hyperparameters={
+            "Chronos": {
+                "model_path": "autogluon/chronos-bolt-small",
+                "fine_tune": True,
+                "fine_tune_steps": 200,
+                "fine_tune_lr": 1e-4,
+                "context_length": 128,
+                "quantile_levels": [0.1, 0.5, 0.9],
+            }
+        },
+        time_limit=time_limit,
+    )
+
+    print("✅ Training abgeschlossen. Modellpfad:", predictor.path)
+    return predictor

utils_vol.py

@@ -0,0 +1,29 @@
+import yfinance as yf
+import numpy as np
+import pandas as pd
+
+def fetch_close_series(ticker: str, start="2015-01-01", interval="1d") -> pd.Series:
+    """Downloadet Daten von yfinance und gibt die Schlusskurse zurück."""
+    df = yf.download(ticker, start=start, interval=interval, progress=False, threads=True)
+    if df is None or df.empty:
+        raise ValueError(f"Keine Daten für {ticker}.")
+    col = None
+    for c in ["Adj Close", "Close", "close", "adj close"]:
+        if c in df.columns:
+            col = c; break
+    if col is None:
+        col = df.select_dtypes("number").columns[-1]
+    return df[col].dropna()
+
+def realized_vol(close: pd.Series, window=20, annualize=True) -> pd.Series:
+    r = np.log(close).diff().dropna()
+    rv = r.rolling(window, min_periods=window).std()
+    if annualize:
+        rv *= np.sqrt(252)
+    return rv.dropna()
+
+def rv_to_autogluon_df(rv: pd.Series) -> pd.DataFrame:
+    """Formatiert Realized Vol als DataFrame für AutoGluon TimeSeries."""
+    df = pd.DataFrame({"timestamp": rv.index, "target": rv.values})
+    df["item_id"] = "series_1"
+    return df