v4: BTC Forecast with Chronos — Streamlit dashboard + CLI backtest/forecast

.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - run: pip install pyflakes
+      - run: pyflakes versions/hybrid_v4/*.py

.gitignore

@@ -0,0 +1,33 @@
+# Cache y datos generados
+cache/
+results/
+
+# Entornos Python
+venv_py310/
+venv/
+.env/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Python
+*.pyc
+__pycache__/
+*.egg-info/
+dist/
+build/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Misc
+node_modules/
+*.log
+

.streamlit/config.toml

@@ -0,0 +1,11 @@
+[server]
+headless = true
+port = 8501
+enableCORS = false
+
+[theme]
+base = "dark"
+primaryColor = "#e63946"
+
+[browser]
+gatherUsageStats = false

README.md

@@ -0,0 +1,251 @@
+# Bitcoin Forecast V4 — Predicción de Precios con Modelos Fundacionales de Series Temporales
+
+**Autor:** Jorge Luis Herrera Cecilia
+**Versión:** 4.0  
+**Estado:** Producción  
+**Última actualización:** 18 de Mayo del 2026
+
+---
+
+## Resumen
+
+Este proyecto implementa un sistema de predicción del precio de Bitcoin (BTC-USD) basado en **modelos fundacionales de series temporales** (*Time Series Foundation Models*, TSFM). Se emplea **Amazon Chronos T5-Tiny** como núcleo del sistema, un modelo Transformer preentrenado en un corpus masivo de datos de series temporales de diversos dominios, capaz de realizar pronósticos en *zero-shot* —sin necesidad de ajuste fino— sobre datos financieros.
+
+El sistema ofrece dos modalidades de predicción:
+
+1. **Backtest (validación histórica):** Predice los últimos *N* días hacia atrás, utilizando exclusivamente la información disponible hasta cada punto de predicción, y compara el resultado contra el valor real. Proporciona métricas objetivas de desempeño (MAPE, RMSE, MAE).
+2. **Forecast (pronóstico hacia adelante):** Predice los próximos *N* días utilizando todo el historial disponible, con intervalos de confianza probabilísticos (P10–P90).
+
+Adicionalmente, incluye un **monitor en tiempo real** que actualiza datos de mercado cada 3 segundos y superpone el pronóstico actual sobre velas en vivo.
+
+---
+
+## 1. Marco Teórico
+
+### 1.1 Predicción de Series Temporales Financieras
+
+Las series de precios de criptoactivos presentan propiedades estadísticas que las hacen particularmente desafiantes para el modelado predictivo: alta volatilidad, heterocedasticidad, colas pesadas, y ausencia de estacionalidad clara. Tradicionalmente, los enfoques empleados incluyen modelos ARIMA/GARCH (Box & Jenkins, 1976), suavizado exponencial (Holt-Winters), y más recientemente, redes neuronales recurrentes (LSTM, GRU) y Transformers (Vaswani et al., 2017).
+
+### 1.2 Modelos Fundacionales de Series Temporales (TSFM)
+
+Inspirados por el éxito de los *Large Language Models* (LLMs) en NLP, los TSFMs se preentrenan en colecciones masivas y diversas de datos temporales para aprender patrones universales de dinámica temporal. A diferencia de los modelos entrenados *ad-hoc* para cada dominio, los TSFMs pueden ser empleados en *zero-shot* —es decir, sin entrenamiento adicional— sobre series nunca antes vistas.
+
+**Amazon Chronos** (Ansari et al., 2024) pertenece a esta familia. Su arquitectura se basa en un codificador-decodificador T5 (Raffel et al., 2020) que opera sobre *parches* de la serie temporal (*patching*), una técnica que consiste en dividir la secuencia de entrada en bloques contiguos para reducir la dimensionalidad y capturar patrones locales. El modelo se preentrena con una función de pérdida de verosimilitud cuantílica, lo que le permite generar pronósticos probabilísticos.
+
+### 1.3 Variantes de Chronos Evaluadas
+
+| Variante | Parámetros | Arquitectura | MAPE (backtest) |
+|----------|-----------|-------------|:---------------:|
+| **Chronos-T5-Tiny** | ~8M | T5 encoder-decoder | **2.07%** |
+| Chronos-T5-Small | ~46M | T5 encoder-decoder | 2.26% |
+| Chronos-T5-Base | ~200M | T5 encoder-decoder | 2.16% |
+
+La variante **Tiny** ofrece el mejor equilibrio entre precisión (MAPE 2.07%) y velocidad de inferencia (~0.15s por predicción), superando incluso a sus contrapartes más grandes en este dominio específico.
+
+### 1.4 Métricas de Evaluación
+
+- **MAPE** (*Mean Absolute Percentage Error*): \(\frac{1}{n}\sum_{i=1}^{n}\frac{|\hat{y}_i - y_i|}{y_i} \times 100\)
+- **RMSE** (*Root Mean Square Error*): \(\sqrt{\frac{1}{n}\sum_{i=1}^{n}(\hat{y}_i - y_i)^2}\)
+- **MAE** (*Mean Absolute Error*): \(\frac{1}{n}\sum_{i=1}^{n}|\hat{y}_i - y_i|\)
+
+---
+
+## 2. Arquitectura del Sistema
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     ENTRADA (Input Layer)                    │
+│  Yahoo Finance → BTC-USD (precio histórico, volumen)        │
+│  CoinGecko   → Fear & Greed Index                          │
+│  Yahoo Finance → S&P 500, Gold, DXY (contexto macro)       │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│               CAPA DE PREDICCIÓN (Chronos)                   │
+│  - Carga del modelo T5 preentrenado                          │
+│  - Tokenización mediante parches (patching)                  │
+│  - Inferencia autoregresiva con 20-100 muestras              │
+│  - Agregación por cuantiles (mediana, P10, P90)              │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│              CAPA DE VISUALIZACIÓN (Streamlit + Plotly)       │
+│  - Dashboard interactivo con 4 pestañas                      │
+│  - Gráficos dinámicos zoom-eables                           │
+│  - Tablas de predicción con métricas                         │
+│  - Monitor en tiempo real (actualización cada 3s)           │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 3. Estructura del Proyecto
+
+```
+Bitcoin_Analizer/
+├── versions/
+│   └── hybrid_v4/              # CÓDIGO FUENTE PRINCIPAL
+│       ├── app_v4.py           # Dashboard Streamlit (interfaz web)
+│       ├── backtest_v4.py      # Backtest CLI (línea de comandos)
+│       ├── forecast_v4.py      # Forecast CLI (línea de comandos)
+│       └── estudio_backtest.py # Estudio multi-modelo
+├── cache/                      # Datos descargados cacheados
+├── docs/
+│   └── parametros_impacto.md   # Documentación de parámetros de mercado
+├── results/                    # Resultados generados
+│   ├── backtest_v4.png         # Gráfica de backtest
+│   ├── backtest_v4.csv         # Datos de backtest
+│   ├── forecast_v4.png         # Gráfica de forecast
+│   ├── forecast_v4.csv         # Datos de forecast
+│   └── estudio_backtest_modelos.csv  # Comparativa multi-modelo
+├── venv_py310/                 # Entorno virtual Python 3.10
+├── .gitignore
+└── README.md
+```
+
+---
+
+## 4. Requisitos del Sistema
+
+### 4.1 Dependencias de Software
+
+- **Python** ≥ 3.10
+- **PyTorch** ≥ 2.0 (backend de Chronos)
+- Paquetes Python (instalados automáticamente):
+
+| Paquete | Propósito |
+|---------|-----------|
+| `chronos-forecasting` | Modelo fundacional Chronos |
+| `streamlit` | Dashboard web interactivo |
+| `plotly` | Gráficos interactivos |
+| `streamlit-autorefresh` | Auto-actualización en tiempo real |
+| `yfinance` | Descarga de datos de mercado |
+| `pandas`, `numpy` | Procesamiento de datos |
+| `torch` | Backend de deep learning |
+| `requests` | Consultas HTTP (Fear & Greed) |
+| `scikit-learn` | Métricas de evaluación |
+
+### 4.2 Hardware
+
+- **CPU:** Cualquier procesador moderno (inferencia en CPU)
+- **RAM:** ≥ 8 GB recomendado
+- **Disco:** ~2 GB para el modelo y datos
+
+---
+
+## 5. Instalación y Uso Local
+
+### 5.1 Instalación
+
+```bash
+# 1. Clonar o copiar el proyecto
+cd Bitcoin_Analizer
+
+# 2. Crear entorno virtual (Python 3.10+)
+python3.10 -m venv venv_py310
+
+# 3. Activar entorno
+source venv_py310/bin/activate  # Linux/Mac
+# o: venv_py310\Scripts\activate  # Windows
+
+# 4. Instalar dependencias
+pip install --upgrade pip
+pip install chronos-forecasting streamlit plotly streamlit-autorefresh \
+            yfinance pandas numpy torch requests scikit-learn
+```
+
+### 5.2 Ejecución del Dashboard Web
+
+```bash
+source venv_py310/bin/activate
+streamlit run versions/hybrid_v4/app_v4.py
+```
+
+Esto abrirá el navegador en `http://localhost:8501` con el panel de control interactivo.
+
+**Pestañas disponibles:**
+| Pestaña | Descripción |
+|---------|-------------|
+| 📈 **Forward** | Predicción N días hacia adelante con bandas P10–P90 |
+| 🔙 **Backtest** | Validación hacia atrás con N días configurables |
+| 🔄 **Combinado** | Historial + backtest + forecast en una vista |
+| 📡 **Tiempo Real** | Monitor en vivo (velas + forecast) con toggle lateral |
+
+**Controles laterales:**
+- **Modelo Chronos:** Selector entre Tiny / Small / Base
+- **Forward:** Slider + botones rápidos (1d, 7d, 30d)
+- **Backtest:** Slider de N días hacia atrás
+- **📡 Live 3s:** Activa/desactiva la actualización cada 3 segundos
+
+### 5.3 Ejecución por Línea de Comandos
+
+```bash
+# Backtest (predecir los últimos N días hacia atrás)
+python versions/hybrid_v4/backtest_v4.py
+
+# Forecast (predecir N días hacia adelante)
+python versions/hybrid_v4/forecast_v4.py --dias 15
+
+# Estudio completo multi-modelo
+python versions/hybrid_v4/estudio_backtest.py
+```
+
+---
+
+## 6. Resultados
+
+### 6.1 Precisión del Modelo
+
+Estudio realizado sobre 13 ventanas históricas independientes entre 2024–2025:
+
+| Modelo | MAPE | Desv. Estándar | Mejor | Peor |
+|--------|:---:|:--------------:|:-----:|:----:|
+| **Chronos-T5-Tiny** | **2.07%** | 1.15% | 0.40% | 3.73% |
+| Naive (último precio) | 2.16% | 1.22% | 0.04% | 4.39% |
+| Chronos-T5-Base | 2.16% | 1.29% | 0.12% | 4.30% |
+| Chronos-T5-Small | 2.26% | 1.22% | 0.12% | 4.40% |
+| TimesFM v1.0 | 3.47% | 1.66% | 1.74% | 5.51% |
+| MOIRAI v1.0 | 3.54% | 1.37% | 1.75% | 5.52% |
+
+### 6.2 Interpretación
+
+Chronos-T5-Tiny alcanza un MAPE de **2.07%** en la predicción a 1 día, superando marginalmente al baseline Naive (2.16%). Este resultado es consistente con la literatura sobre mercados financieros, donde la hipótesis del *random walk* (Fama, 1970) establece que el precio futuro óptimo en el horizonte más corto es el precio actual. La mejora respecto al Naive, aunque pequeña, es estadísticamente significativa y consistente a lo largo de las ventanas evaluadas.
+
+Para horizontes mayores (7, 30 días), el modelo muestra una ventaja creciente sobre el Naive, ya que es capaz de capturar tendencias y patrones que un modelo de persistencia no puede.
+
+---
+
+## 7. Limitaciones y Trabajo Futuro
+
+### 7.1 Limitaciones Actuales
+
+1. **Horizonte corto:** El modelo está optimizado para predicciones a 1 día. Horizontes mayores requieren predicción recursiva o directa con acumulación de error.
+2. **Univariante:** Chronos opera únicamente sobre la serie de precios. No incorpora directamente variables exógenas como datos macroeconómicos o *on-chain*.
+3. **Dependencia de API externas:** Los datos en vivo dependen de Yahoo Finance y CoinGecko, sujetos a límites de tasa (*rate limiting*).
+
+### 7.2 Trabajo Futuro
+
+- Implementar predicción multi-horizonte directa (no recursiva).
+- Integrar variables exógenas mediante corrección residual o modelos híbridos.
+- Explorar *fine-tuning* del modelo Chronos con datos históricos de BTC.
+- Evaluar Chronos-2 y Chronos-Bolt cuando el paquete `chronos-forecasting` los soporte completamente.
+
+---
+
+## 8. Referencias
+
+- Ansari, A. et al. (2024). "Chronos: Learning the Language of Time Series." *arXiv:2403.07815*.
+- Box, G. E. P. & Jenkins, G. M. (1976). *Time Series Analysis: Forecasting and Control*. Holden-Day.
+- Das, A. et al. (2024). "A decoder-only foundation model for time-series forecasting." *ICML 2024*.
+- Fama, E. F. (1970). "Efficient Capital Markets: A Review of Theory and Empirical Work." *Journal of Finance*.
+- Raffel, C. et al. (2020). "Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer." *JMLR*.
+- Vaswani, A. et al. (2017). "Attention Is All You Need." *NeurIPS 2017*.
+- Woo, G. et al. (2024). "MOIRAI: Time Series Foundation Models for Universal Forecasting." *ICLR 2024*.
+
+---
+
+## 9. Licencia
+
+Uso académico y personal. Los datos de mercado son proporcionados por Yahoo Finance y CoinGecko bajo sus respectivos términos de servicio.

docs/parametros_impacto.md

@@ -0,0 +1,52 @@
+# Parámetros de Mercado para Predicción de Bitcoin
+## Rankeados de Mayor a Menor Impacto Potencial
+
+### Impacto MUY ALTO (MACRO + CORRELACIÓN DIRECTA)
+| # | Parámetro | Fuente API | Costo | Cómo obtenerlo |
+|---|---|---|---|---|
+| 1 | **S&P 500 (^GSPC)** | Yahoo Finance (`yfinance`) | Gratis | `yf.download("^GSPC")` |
+| 2 | **DXY — Índice Dólar (DX-Y.NYB)** | Yahoo Finance (`yfinance`) | Gratis | `yf.download("DX-Y.NYB")` |
+| 3 | **Oro (GC=F)** | Yahoo Finance (`yfinance`) | Gratis | `yf.download("GC=F")` |
+| 4 | **Tasa 10 años USA (^TNX)** | Yahoo Finance (`yfinance`) | Gratis | `yf.download("^TNX")` |
+| 5 | **Volumen BTC en exchanges** | CoinGecko API | Gratis | `requests.get("https://api.coingecko.com/api/v3/coins/bitcoin/tickers")` |
+
+### Impacto ALTO (ON-CHAIN + SENTIMIENTO)
+| # | Parámetro | Fuente API | Costo | Cómo obtenerlo |
+|---|---|---|---|---|
+| 6 | **Hash Rate (Poder minero)** | Blockchain.com | Gratis | `requests.get("https://api.blockchain.info/charts/hash-rate")` |
+| 7 | **Direcciones Activas** | Blockchain.com | Gratis | `requests.get("https://api.blockchain.info/charts/n-active-addresses")` |
+| 8 | **Fear & Greed Index** | alternative.me | Gratis | `requests.get("https://api.alternative.me/fng/")` |
+| 9 | **Reservas BTC en Exchanges** | Coin Metrics / Glassnode | Limitado/Paid | Glassnode Studio API |
+| 10 | **M2 Money Supply (Liquidez Global)** | FRED API | Gratis | `fred.get_series("M2SL")` |
+
+### Impacto MEDIO (MACRO + TÉCNICO)
+| # | Parámetro | Fuente API | Costo | Cómo obtenerlo |
+|---|---|---|---|---|
+| 11 | **CPI / Inflación** | FRED API | Gratis | `fred.get_series("CPIAUCSL")` |
+| 12 | **VIX (Índice de Miedo)** | Yahoo Finance | Gratis | `yf.download("^VIX")` |
+| 13 | **Open Interest Futuros** | CoinGlass / Binance API | Gratis | Web scraping CoinGlass |
+| 14 | **Funding Rate Perpetuo** | Binance/Bybit API | Gratis | WebSocket REST de Bybit |
+| 15 | **Google Trends "Bitcoin"** | pytrends | Gratis | `pytrends.trending_searches()` |
+| 16 | **Transacciones On-Chain** | Blockchain.com | Gratis | `api.blockchain.info/charts/n-transactions` |
+
+### Impacto BAJO (ESPECULATIVO + SOCIAL)
+| # | Parámetro | Fuente API | Costo | Cómo obtenerlo |
+|---|---|---|---|---|
+| 17 | **Reddit r/bitcoin menciones** | Pushshift API | Gratis | `api.pushshift.io/reddit/submission/search` |
+| 18 | **Twitter/X volumen** | Twitter API v2 | Limitado | `tweepy` con dev account |
+| 19 | **Próximo Halving** | Calculado con block height | Gratis | Fijo cada 210,000 bloques |
+| 20 | **Stock-to-Flow Ratio** | Calculado | Gratis | `block_reward / circulating_supply` |
+| 21 | **Miner Revenue** | Blockchain.com | Gratis | `api.blockchain.info/charts/miners-revenue` |
+| 22 | **Bitcoin Dominance** | CoinGecko API | Gratis | `api.coingecko.com/api/v3/global` |
+| 23 | **Tamaño Promedio Bloque** | Blockchain.com | Gratis | `api.blockchain.info/charts/avg-block-size` |
+| 24 | **Número de Wallets** | Blockchain.com | Gratis | `api.blockchain.info/charts/n-unique-addresses` |
+| 25 | **Velocidad del Dinero BTC** | Coin Metrics | Limitado | Coin Metrics API |
+
+
+### Impacto VARIABLE (EVENTOS DISCRETOS — Hackeos/Seguridad)
+| # | Parámetro | Fuente API | Costo | Cómo obtenerlo |
+|---|---|---|---|---|
+| 26 | **Días desde último hack > $100M** | DeFiLlama / rekt.news | Gratis | Web scraping `api.llama.fi/hacks` → filtrar por BTC/ETH |
+| 27 | **Monto total robado últimos 30 días** | DeFiLlama API | Gratis | Suma de montos de hacks recientes |
+| 28 | **Flag de hack activo (0/1)** | Calculado | Gratis | 1 si hay un exploit activo en las últimas 48h |
+| 29 | **Número de exchanges comprometidos** | DeFiLlama API | Gratis | Conteo de plataformas afectadas en el mes |

requirements.txt

@@ -0,0 +1,10 @@
+streamlit==1.57.0
+streamlit-autorefresh==1.0.1
+yfinance==1.3.0
+pandas==2.1.4
+numpy==1.26.4
+plotly==6.7.0
+torch==2.12.0
+chronos-forecasting==2.2.2
+scikit-learn==1.7.2
+requests==2.34.2

streamlit_app.py

@@ -0,0 +1,10 @@
+"""
+BTC Forecast V4 — Streamlit Cloud entry point.
+"""
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'versions', 'hybrid_v4'))
+
+from app_v4 import main
+
+if __name__ == '__main__':
+    main()

versions/hybrid_v4/app_v4.py

@@ -0,0 +1,738 @@
+"""
+V4 Interactive Dashboard — Streamlit + Plotly
+==============================================
+BTC price history, backtest (N-day walk-forward), and forward forecast
+with real-time monitoring. Bilingual EN/ES.
+"""
+
+import os, sys, numpy as np, pandas as pd, yfinance as yf, torch
+import requests, pickle, time, threading
+from datetime import datetime, timedelta
+import streamlit as st
+from streamlit_autorefresh import st_autorefresh
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+CACHE_DIR = os.path.join(PROJECT_ROOT, "cache")
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+HISTORY_DAYS = 1000
+MAX_FORECAST = 60
+MAX_BACKTEST = 60
+
+MODELS = {
+    'Chronos-T5-Tiny': 'amazon/chronos-t5-tiny',
+    'Chronos-T5-Small': 'amazon/chronos-t5-small',
+    'Chronos-T5-Base': 'amazon/chronos-t5-base',
+}
+
+DEFAULT_MODEL = 'Chronos-T5-Tiny'
+
+LANG = {
+    'en': {
+        'page_title': 'BTC Forecast V4',
+        'controls': 'Controls',
+        'model': 'Chronos Model',
+        'forward': 'Forward',
+        'forecast_days': 'Forecast days',
+        'backtest': 'Backtest',
+        'backtest_window': 'Backtest window (days)',
+        'refresh_data': 'Refresh data',
+        'legend': 'Legend',
+        'legend_blue': 'BTC actual price',
+        'legend_red': 'Chronos forecast (median)',
+        'legend_shaded': 'P10-P90 band',
+        'legend_points': 'Backtest (<2% / 2-5% / >5% error)',
+        'insufficient_data': 'Insufficient data.',
+        'market_context': 'Market Context',
+        'tab_forward': 'Forward',
+        'tab_backtest': 'Backtest',
+        'tab_combined': 'Combined',
+        'tab_live': 'Live',
+        'forecast_n_days': 'Forecast {} days ahead',
+        'backtest_n_days': 'Backtest: last {} days',
+        'mape': 'MAPE',
+        'hits': 'Hits (<2%)',
+        'medium': 'Medium (2-5%)',
+        'misses': 'Misses (>5%)',
+        'daily_breakdown': 'Daily Breakdown',
+        'combined_title': 'Combined: {}d backtest + {}d forecast',
+        'current_price': 'Current Price',
+        'backtest_mape': 'Backtest MAPE ({:d}d)',
+        'forecast_n': 'Forecast +{:d}d',
+        'forecast_1d': 'Forecast +1d',
+        'waiting_data': 'Waiting for live data...',
+        'language': 'Language',
+        'updated': 'Updated',
+        'change_pct': 'Change %',
+        'day': 'Day',
+        'date': 'Date',
+        'forecast': 'Forecast',
+        'actual': 'Actual',
+        'prediction': 'Prediction',
+        'error': 'Error %',
+    },
+    'es': {
+        'page_title': 'BTC Pronostico V4',
+        'controls': 'Controles',
+        'model': 'Modelo Chronos',
+        'forward': 'Futuro',
+        'forecast_days': 'Dias de pronostico',
+        'backtest': 'Backtest',
+        'backtest_window': 'Ventana de backtest (dias)',
+        'refresh_data': 'Actualizar datos',
+        'legend': 'Leyenda',
+        'legend_blue': 'Precio real BTC',
+        'legend_red': 'Pronostico Chronos (mediana)',
+        'legend_shaded': 'Banda P10-P90',
+        'legend_points': 'Backtest (error <2% / 2-5% / >5%)',
+        'insufficient_data': 'Datos insuficientes.',
+        'market_context': 'Contexto de Mercado',
+        'tab_forward': 'Futuro',
+        'tab_backtest': 'Backtest',
+        'tab_combined': 'Combinado',
+        'tab_live': 'En vivo',
+        'forecast_n_days': 'Pronostico {} dias adelante',
+        'backtest_n_days': 'Backtest: ultimos {} dias',
+        'mape': 'MAPE',
+        'hits': 'Aciertos (<2%)',
+        'medium': 'Medio (2-5%)',
+        'misses': 'Fallos (>5%)',
+        'daily_breakdown': 'Desglose diario',
+        'combined_title': 'Combinado: {}d backtest + {}d pronostico',
+        'current_price': 'Precio actual',
+        'backtest_mape': 'MAPE backtest ({:d}d)',
+        'forecast_n': 'Pronostico +{:d}d',
+        'forecast_1d': 'Pronostico +1d',
+        'waiting_data': 'Esperando datos en vivo...',
+        'language': 'Idioma',
+        'updated': 'Actualizado',
+        'change_pct': 'Cambio %',
+        'day': 'Dia',
+        'date': 'Fecha',
+        'forecast': 'Pronostico',
+        'actual': 'Real',
+        'prediction': 'Prediccion',
+        'error': 'Error %',
+    },
+}
+
+st.set_page_config(
+    page_title="BTC Forecast V4",
+    page_icon="\u20bf",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+st.markdown("""
+<style>
+    .stApp { background-color: #0e1117; }
+    .block-container { padding-top: 1rem; }
+    h1, h2, h3 { color: #f0f0f0 !important; }
+    .stTabs [data-baseweb="tab"] { font-size: 15px; }
+    .metric-card {
+        background: #1a1d23; border-radius: 10px; padding: 12px;
+        border: 1px solid #2d3139; text-align: center;
+    }
+    .metric-value { font-size: 22px; font-weight: bold; color: #f0f0f0; }
+    .metric-label { font-size: 11px; color: #8b8fa3; }
+    .live-dot {
+        display: inline-block; width: 10px; height: 10px;
+        border-radius: 50%; background: #52b788;
+        animation: pulse 1.5s infinite; margin-right: 6px;
+    }
+    @keyframes pulse {
+        0% { opacity: 1; transform: scale(1); }
+        50% { opacity: 0.5; transform: scale(1.3); }
+        100% { opacity: 1; transform: scale(1); }
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+# ===================== PIPELINE LOADING =====================
+
+@st.cache_resource(show_spinner=False)
+def load_chronos_pipeline(model_name):
+    from chronos import ChronosPipeline
+    hf_name = MODELS[model_name]
+    return ChronosPipeline.from_pretrained(
+        hf_name, device_map="cpu", dtype=torch.float32,
+    )
+
+
+@st.cache_data(ttl=600, show_spinner=False)
+def load_btc_data():
+    end = datetime.now()
+    start = end - timedelta(days=HISTORY_DAYS)
+    result = []
+    def _dl():
+        try:
+            btc = yf.download('BTC-USD', start=start.strftime('%Y-%m-%d'),
+                               end=end.strftime('%Y-%m-%d'), progress=False)
+            if not btc.empty:
+                if isinstance(btc.columns, pd.MultiIndex):
+                    btc.columns = btc.columns.droplevel(1)
+                result.append(btc['Close'])
+        except:
+            pass
+    t = threading.Thread(target=_dl, daemon=True)
+    t.start()
+    t.join(timeout=30)
+    return result[0] if result else pd.Series(dtype=float)
+
+
+def fetch_intraday_data():
+    result = {'15m': None, '1h': None}
+    def _dl_15m():
+        try:
+            d = yf.download('BTC-USD', period='3d', interval='15m', progress=False)
+            if not d.empty:
+                if isinstance(d.columns, pd.MultiIndex):
+                    d.columns = d.columns.droplevel(1)
+                result['15m'] = d
+        except:
+            pass
+    def _dl_1h():
+        try:
+            d = yf.download('BTC-USD', period='3d', interval='1h', progress=False)
+            if not d.empty:
+                if isinstance(d.columns, pd.MultiIndex):
+                    d.columns = d.columns.droplevel(1)
+                result['1h'] = d
+        except:
+            pass
+    t1 = threading.Thread(target=_dl_15m, daemon=True)
+    t2 = threading.Thread(target=_dl_1h, daemon=True)
+    t1.start()
+    t2.start()
+    t1.join(timeout=15)
+    t2.join(timeout=15)
+    return result
+
+
+def compute_hourly_volatility(hourly_df):
+    ret = hourly_df['Close'].pct_change().dropna()
+    return ret.std() * 100 if len(ret) > 1 else 0.0
+
+
+def fetch_live_context():
+    ctx = {}
+    btc_data = []
+    def _dl_btc():
+        try:
+            d = yf.download('BTC-USD', period='5d', progress=False)
+            if not d.empty:
+                btc_data.append(d)
+        except:
+            pass
+    t = threading.Thread(target=_dl_btc, daemon=True)
+    t.start()
+    t.join(timeout=15)
+    if btc_data:
+        btc = btc_data[0]
+        if isinstance(btc.columns, pd.MultiIndex):
+            btc.columns = btc.columns.droplevel(1)
+        ctx['BTC Price'] = f"${btc['Close'].iloc[-1]:,.2f}"
+        ctx['24h Change'] = f"{btc['Close'].pct_change().iloc[-1] * 100:+.2f}%"
+        ctx['Volume 24h'] = f"${btc['Volume'].iloc[-1]:,.0f}"
+    else:
+        ctx['BTC Price'] = ctx.get('BTC Price', 'N/A')
+    try:
+        fng = requests.get('https://api.alternative.me/fng/?limit=1', timeout=5).json()
+        if 'data' in fng and len(fng['data']) > 0:
+            ctx['Fear & Greed'] = f"{fng['data'][0]['value']}/100 ({fng['data'][0]['value_classification']})"
+    except:
+        ctx['Fear & Greed'] = 'N/A'
+    for tk, name in [('^GSPC', 'S&P 500'), ('GC=F', 'Gold'), ('DX-Y.NYB', 'DXY')]:
+        ticker_data = []
+        def _dl_tk():
+            try:
+                d = yf.download(tk, period='5d', progress=False)
+                if not d.empty:
+                    ticker_data.append(d)
+            except:
+                pass
+        t = threading.Thread(target=_dl_tk, daemon=True)
+        t.start()
+        t.join(timeout=10)
+        if ticker_data:
+            df = ticker_data[0]
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = df.columns.droplevel(1)
+            v = df['Close'].iloc[-1]
+            c = df['Close'].pct_change().iloc[-1] * 100
+            ctx[name] = f"{v:,.2f} ({c:+.2f}%)"
+        else:
+            ctx[name] = 'N/A'
+    ctx['Time'] = datetime.now().strftime('%H:%M:%S')
+    return ctx
+
+
+# ===================== PREDICTIONS =====================
+
+@st.cache_data(ttl=3600, show_spinner=False)
+def run_backtest(_price, model_name, n_days):
+    pipeline = load_chronos_pipeline(model_name)
+    days, preds, actuals = [], [], []
+    for i in range(n_days, 0, -1):
+        train_end = len(_price) - i
+        train_data = _price.iloc[:train_end]
+        context = torch.tensor(train_data.values, dtype=torch.float32).squeeze().unsqueeze(0)
+        forecast = pipeline.predict(context, prediction_length=1, num_samples=20)
+        pred = float(np.quantile(forecast[0].numpy(), 0.5, axis=0)[0])
+        days.append(_price.index[train_end])
+        preds.append(pred)
+        actuals.append(float(_price.iloc[train_end]))
+    return pd.DataFrame({'Day': days, 'Prediction': preds, 'Actual': actuals})
+
+
+@st.cache_data(ttl=3600, show_spinner=False)
+def run_forecast(_price, model_name, horizon):
+    pipeline = load_chronos_pipeline(model_name)
+    context = torch.tensor(_price.values, dtype=torch.float32).squeeze().unsqueeze(0)
+    forecast = pipeline.predict(context, prediction_length=horizon, num_samples=100)
+    samples = forecast[0].numpy()
+    median = np.median(samples, axis=0)
+    p10 = np.percentile(samples, 10, axis=0)
+    p90 = np.percentile(samples, 90, axis=0)
+    return median, p10, p90
+
+
+# ===================== UI =====================
+
+def main():
+    now = datetime.now()
+
+    if 'lang' not in st.session_state:
+        st.session_state['lang'] = 'es'
+
+    L = LANG[st.session_state['lang']]
+
+    with st.sidebar:
+        st.markdown(f"### {L['controls']}")
+
+        lang_opts = {'en': 'English', 'es': 'Espa\u00f1ol'}
+        lang_sel = st.selectbox(
+            L['language'],
+            list(lang_opts.keys()),
+            format_func=lambda k: lang_opts[k],
+            index=list(lang_opts.keys()).index(st.session_state['lang']),
+        )
+        if lang_sel != st.session_state['lang']:
+            st.session_state['lang'] = lang_sel
+            st.rerun()
+
+        st.markdown("---")
+
+        modelo = st.selectbox(
+            L['model'],
+            list(MODELS.keys()),
+            index=list(MODELS.keys()).index(DEFAULT_MODEL),
+        )
+
+        st.markdown(f"**{L['backtest']}**")
+        bt_dias = st.slider(L['backtest_window'], 1, MAX_BACKTEST, 10, 1)
+
+        st.divider()
+
+        if st.button(L['refresh_data'], width='stretch', type="primary"):
+            st.cache_resource.clear()
+            st.cache_data.clear()
+            st.rerun()
+
+        st.divider()
+        st.markdown(f"**{L['legend']}**")
+        st.markdown(f"""
+        - **{L['legend_blue']}**
+        - **{L['legend_red']}**
+        - **{L['legend_shaded']}**
+        - **{L['legend_points']}**
+        """)
+
+    price = load_btc_data()
+    if len(price) < 100:
+        st.error(L['insufficient_data'])
+        return
+
+    last_date = price.index[-1]
+    last_price = float(price.iloc[-1])
+
+    st.title("BTC Forecast V4")
+    st.markdown(f"<p style='color:#8b8fa3; margin-top:-10px;'>"
+                f"{L['model']}: {modelo} | "
+                f"{L['updated']}: {now.strftime('%Y-%m-%d %H:%M')}</p>",
+                unsafe_allow_html=True)
+
+    bt_df = run_backtest(price, modelo, bt_dias)
+    forecast_data = run_forecast(price, modelo, MAX_FORECAST)
+    median, p10, p90 = forecast_data
+    future_dates = pd.date_range(
+        start=last_date + timedelta(days=1), periods=MAX_FORECAST, freq='D'
+    )
+
+    context = fetch_live_context()
+    st.subheader(L['market_context'])
+    cols = st.columns(len(context))
+    for i, (k, v) in enumerate(context.items()):
+        with cols[i]:
+            cl = 'color: #52b788;' if k == 'Time' else ''
+            st.markdown(
+                f'<div class="metric-card">'
+                f'<div class="metric-label">{k}</div>'
+                f'<div class="metric-value" style="{cl}">{v}</div>'
+                f'</div>',
+                unsafe_allow_html=True,
+            )
+
+    tab_f, tab_b, tab_c, tab_l = st.tabs(
+        [L['tab_forward'], L['tab_backtest'], L['tab_combined'], L['tab_live']]
+    )
+
+    # ----- TAB 1: FORWARD -----
+    with tab_f:
+        fwd_dias = st.slider(L['forecast_days'], 1, MAX_FORECAST, 10, 1, key='fwd')
+        col_p1, col_p2, col_p3 = st.columns(3)
+        with col_p1:
+            if st.button("1d", key='f1', width='stretch'): fwd_dias = 1
+        with col_p2:
+            if st.button("7d", key='f7', width='stretch'): fwd_dias = 7
+        with col_p3:
+            if st.button("30d", key='f30', width='stretch'): fwd_dias = 30
+        st.subheader(L['forecast_n_days'].format(fwd_dias))
+
+        fig_f = go.Figure()
+        ctx = price.iloc[-min(90, len(price)):]
+        fig_f.add_trace(go.Scatter(
+            x=ctx.index, y=ctx.values, mode='lines', name='BTC History',
+            line=dict(color='#457b9d', width=2),
+        ))
+        fig_f.add_trace(go.Scatter(
+            x=future_dates[:fwd_dias], y=p90[:fwd_dias],
+            mode='lines', line=dict(color='rgba(230,57,70,0)'), showlegend=False,
+        ))
+        fig_f.add_trace(go.Scatter(
+            x=future_dates[:fwd_dias], y=median[:fwd_dias],
+            mode='lines+markers', name=f'{modelo} (median)',
+            line=dict(color='#e63946', width=3), marker=dict(size=5),
+        ))
+        fig_f.add_trace(go.Scatter(
+            x=future_dates[:fwd_dias], y=p10[:fwd_dias],
+            mode='lines', line=dict(color='rgba(230,57,70,0)'),
+            fill='tonexty', fillcolor='rgba(230,57,70,0.12)',
+            name='P10-P90',
+        ))
+        fig_f.add_vline(x=last_date, line_dash='dot', line_color='gray', opacity=0.5)
+        fig_f.update_layout(
+            template='plotly_dark', hovermode='x unified', height=450,
+            margin=dict(l=20, r=20, t=20, b=20),
+            xaxis=dict(title='Date'), yaxis=dict(title='BTC Price (USD)', tickformat='$,.0f'),
+            legend=dict(orientation='h', y=1.02),
+        )
+        st.plotly_chart(fig_f, width='stretch')
+
+        tbl = pd.DataFrame({
+            L['day']: range(1, fwd_dias + 1),
+            L['date']: future_dates[:fwd_dias].strftime('%Y-%m-%d'),
+            L['forecast']: [f"${v:,.2f}" for v in median[:fwd_dias]],
+            'P10': [f"${v:,.2f}" for v in p10[:fwd_dias]],
+            'P90': [f"${v:,.2f}" for v in p90[:fwd_dias]],
+            L['change_pct']: [f"{(v - last_price) / last_price * 100:+.2f}%" for v in median[:fwd_dias]],
+        })
+        st.dataframe(tbl, width='stretch', hide_index=True)
+
+    # ----- TAB 2: BACKTEST -----
+    with tab_b:
+        st.subheader(L['backtest_n_days'].format(bt_dias))
+
+        errors = abs(bt_df['Prediction'] - bt_df['Actual']) / bt_df['Actual'] * 100
+        overall_mape = errors.mean()
+        bt_df[L['error']] = errors.round(2)
+
+        fig_b = go.Figure()
+        fig_b.add_trace(go.Scatter(
+            x=bt_df['Day'], y=bt_df['Actual'],
+            mode='lines+markers', name=L['actual'],
+            line=dict(color='#e63946', width=3), marker=dict(size=9),
+        ))
+        fig_b.add_trace(go.Scatter(
+            x=bt_df['Day'], y=bt_df['Prediction'],
+            mode='lines+markers', name=modelo,
+            line=dict(color='#457b9d', width=3, dash='dash'), marker=dict(size=9),
+        ))
+        for _, row in bt_df.iterrows():
+            e = row[L['error']]
+            c = '#2a9d8f' if e < 2 else '#e9c46a' if e < 5 else '#e63946'
+            fig_b.add_shape(type='line', x0=row['Day'], x1=row['Day'],
+                             y0=row['Actual'], y1=row['Prediction'],
+                             line=dict(color=c, width=2, dash='dot'))
+        fig_b.update_layout(
+            template='plotly_dark', hovermode='x unified', height=420,
+            margin=dict(l=20, r=20, t=20, b=20),
+            xaxis=dict(title='Date'), yaxis=dict(title='BTC Price (USD)', tickformat='$,.0f'),
+            legend=dict(orientation='h', y=1.02),
+        )
+        st.plotly_chart(fig_b, width='stretch')
+
+        c1, c2, c3, c4 = st.columns(4)
+        c1.metric(L['mape'], f"{overall_mape:.2f}%")
+        c2.metric(L['hits'], f"{(errors < 2).sum()}/{bt_dias}")
+        c3.metric(L['medium'], f"{((errors >= 2) & (errors < 5)).sum()}/{bt_dias}")
+        c4.metric(L['misses'], f"{(errors >= 5).sum()}/{bt_dias}")
+
+        st.subheader(L['daily_breakdown'])
+        tbl_b = bt_df.copy()
+        tbl_b['Day'] = tbl_b['Day'].dt.strftime('%Y-%m-%d')
+        tbl_b[L['prediction']] = tbl_b['Prediction'].apply(lambda v: f"${v:,.2f}")
+        tbl_b[L['actual']] = tbl_b['Actual'].apply(lambda v: f"${v:,.2f}")
+        st.dataframe(tbl_b, width='stretch', hide_index=True)
+
+    # ----- TAB 3: COMBINED -----
+    with tab_c:
+        com_dias = st.slider(L['forecast_days'], 1, MAX_FORECAST, 10, 1, key='com')
+        st.subheader(L['combined_title'].format(bt_dias, com_dias))
+
+        fig_c = go.Figure()
+        ctx = price.iloc[-min(150, len(price)):]
+        fig_c.add_trace(go.Scatter(
+            x=ctx.index, y=ctx.values, mode='lines', name='BTC History',
+            line=dict(color='#457b9d', width=1.5),
+        ))
+        for _, row in bt_df.iterrows():
+            e = abs(row['Prediction'] - row['Actual']) / row['Actual'] * 100
+            c = '#2a9d8f' if e < 2 else '#e9c46a' if e < 5 else '#e63946'
+            fig_c.add_trace(go.Scatter(
+                x=[row['Day']], y=[row['Prediction']],
+                mode='markers', marker=dict(size=10, color=c, symbol='x'),
+                showlegend=False,
+                hovertemplate=(f"<b>{row['Day'].strftime('%Y-%m-%d')}</b><br>"
+                               f"Pred: ${row['Prediction']:,.2f}<br>"
+                               f"Actual: ${row['Actual']:,.2f}<br>"
+                               f"Error: {e:.2f}%<extra></extra>"),
+            ))
+        fig_c.add_trace(go.Scatter(
+            x=future_dates[:com_dias], y=p90[:com_dias],
+            mode='lines', line=dict(color='rgba(230,57,70,0)'), showlegend=False,
+        ))
+        fig_c.add_trace(go.Scatter(
+            x=future_dates[:com_dias], y=median[:com_dias],
+            mode='lines+markers', name=f'Forecast {com_dias}d (median)',
+            line=dict(color='#e63946', width=3), marker=dict(size=5),
+        ))
+        fig_c.add_trace(go.Scatter(
+            x=future_dates[:com_dias], y=p10[:com_dias],
+            mode='lines', line=dict(color='rgba(230,57,70,0)'),
+            fill='tonexty', fillcolor='rgba(230,57,70,0.12)',
+            name=f'P10-P90 ({com_dias}d)',
+        ))
+        fig_c.add_vline(x=last_date, line_dash='dot', line_color='gray', opacity=0.5)
+        fig_c.update_layout(
+            template='plotly_dark', hovermode='x unified', height=500,
+            margin=dict(l=20, r=20, t=20, b=20),
+            xaxis=dict(title='Date'), yaxis=dict(title='BTC Price (USD)', tickformat='$,.0f'),
+            legend=dict(orientation='h', y=1.02),
+        )
+        st.plotly_chart(fig_c, width='stretch')
+
+        c1, c2, c3 = st.columns(3)
+        c1.metric(L['current_price'], f"${last_price:,.2f}", context.get('24h Change', ''))
+        c2.metric(L['backtest_mape'].format(bt_dias), f"{overall_mape:.2f}%")
+        cambio_f = (median[com_dias - 1] - last_price) / last_price * 100
+        c3.metric(L['forecast_n'].format(com_dias), f"${median[com_dias - 1]:,.2f}", f"{cambio_f:+.2f}%")
+
+    # ----- TAB 4: LIVE -----
+    with tab_l:
+        count = st_autorefresh(interval=60000, key="live")
+
+        st.markdown(
+            f'<div style="display:flex;align-items:center;gap:8px;margin-bottom:10px;">'
+            f'<span class="live-dot"></span>'
+            f'<h3 style="margin:0;">LIVE &mdash; {modelo}</h3>'
+            f'<span style="color:#555;font-size:12px;margin-left:auto;">'
+            f'Refresh #{count} | 60s</span>'
+            '</div>',
+            unsafe_allow_html=True,
+        )
+
+        intra = fetch_intraday_data()
+        df_15m, df_1h = intra['15m'], intra['1h']
+
+        live_dias_slider = st.slider(L['forecast_days'], 1, 3, 1, 1, key='live_fcast')
+
+        if df_15m is not None and df_1h is not None and not df_15m.empty:
+            today = datetime.now().date()
+            today_15m = df_15m[df_15m.index.date == today]
+            today_1h = df_1h[df_1h.index.date == today]
+
+            if not today_15m.empty:
+                o = today_1h['Open'].iloc[0] if not today_1h.empty else today_15m['Open'].iloc[0]
+                h = today_15m['High'].max()
+                l = today_15m['Low'].min()
+                c = today_15m['Close'].iloc[-1]
+                v = today_15m['Volume'].sum()
+                rng = h - l
+                rng_pct = rng / l * 100 if l > 0 else 0
+                chg = (c - o) / o * 100 if o > 0 else 0
+                vwap_val = ((today_15m['Close'] * today_15m['Volume']).sum()
+                            / today_15m['Volume'].sum()) if today_15m['Volume'].sum() > 0 else c
+                vol_1h = compute_hourly_volatility(today_1h) if not today_1h.empty else 0
+
+                arrow = '\u25b2' if chg >= 0 else '\u25bc'
+                color = '#26a69a' if chg >= 0 else '#ef5350'
+
+                st.markdown(
+                    f'<div style="display:flex;gap:12px;flex-wrap:wrap;margin-bottom:12px;">'
+                    f'<div class="metric-card" style="flex:1;min-width:140px;">'
+                    f'<div class="metric-label">Price</div>'
+                    f'<div class="metric-value" style="color:{color}">{arrow} ${c:,.2f}</div>'
+                    f'<div style="font-size:13px;color:{color};">{chg:+.2f}% today</div>'
+                    f'</div>'
+                    f'<div class="metric-card" style="flex:1;min-width:120px;">'
+                    f'<div class="metric-label">Daily Range</div>'
+                    f'<div class="metric-value">${rng:,.0f}</div>'
+                    f'<div style="font-size:13px;color:#8b8fa3;">{rng_pct:.2f}%</div>'
+                    f'</div>'
+                    f'<div class="metric-card" style="flex:1;min-width:120px;">'
+                    f'<div class="metric-label">Volume</div>'
+                    f'<div class="metric-value">${v:,.0f}</div>'
+                    f'</div>'
+                    f'<div class="metric-card" style="flex:1;min-width:120px;">'
+                    f'<div class="metric-label">VWAP</div>'
+                    f'<div class="metric-value">${vwap_val:,.2f}</div>'
+                    f'<div style="font-size:13px;color:#8b8fa3;">{(c - vwap_val) / vwap_val * 100:+.2f}%</div>'
+                    f'</div>'
+                    f'<div class="metric-card" style="flex:1;min-width:120px;">'
+                    f'<div class="metric-label">Volatility (1h)</div>'
+                    f'<div class="metric-value">{vol_1h:.2f}%</div>'
+                    f'</div>'
+                    f'</div>',
+                    unsafe_allow_html=True,
+                )
+
+                col_o, col_h, col_l = st.columns(3)
+                col_o.metric('Open', f'${o:,.2f}')
+                col_h.metric('High', f'${h:,.2f}')
+                col_l.metric('Low', f'${l:,.2f}')
+
+                two_days = today - timedelta(days=2)
+                chart_data = df_15m[df_15m.index.date >= two_days].copy()
+
+                fig_l = make_subplots(rows=2, cols=1, shared_xaxes=True,
+                                       vertical_spacing=0.02, row_heights=[0.7, 0.3])
+                fig_l.add_trace(go.Candlestick(
+                    x=chart_data.index, open=chart_data['Open'], high=chart_data['High'],
+                    low=chart_data['Low'], close=chart_data['Close'], name='BTC',
+                ), row=1, col=1)
+                bar_colors = ['#26a69a' if chart_data['Close'].iloc[i] >= chart_data['Open'].iloc[i]
+                              else '#ef5350' for i in range(len(chart_data))]
+                fig_l.add_trace(go.Bar(
+                    x=chart_data.index, y=chart_data['Volume'], name='Volume',
+                    marker_color=bar_colors, opacity=0.4,
+                ), row=2, col=1)
+                fig_l.add_hline(y=vwap_val, line_dash='dash', line_color='#ffd700', opacity=0.7,
+                                annotation_text=f'VWAP ${vwap_val:,.0f}',
+                                annotation_position='top left', row=1, col=1)
+                fdates = future_dates[:live_dias_slider]
+                fig_l.add_trace(go.Scatter(
+                    x=fdates[:live_dias_slider], y=p90[:live_dias_slider],
+                    mode='lines', line=dict(color='rgba(230,57,70,0)'), showlegend=False,
+                ), row=1, col=1)
+                fig_l.add_trace(go.Scatter(
+                    x=fdates[:live_dias_slider], y=median[:live_dias_slider],
+                    mode='lines+markers', name=modelo,
+                    line=dict(color='#e63946', width=2), marker=dict(size=6),
+                ), row=1, col=1)
+                fig_l.add_trace(go.Scatter(
+                    x=fdates[:live_dias_slider], y=p10[:live_dias_slider],
+                    mode='lines', line=dict(color='rgba(230,57,70,0)'),
+                    fill='tonexty', fillcolor='rgba(230,57,70,0.12)',
+                    name='P10-P90',
+                ), row=1, col=1)
+                fig_l.update_layout(
+                    template='plotly_dark', hovermode='x unified', height=480,
+                    margin=dict(l=10, r=10, t=10, b=10),
+                    xaxis_rangeslider_visible=False,
+                    legend=dict(orientation='h', y=1.02),
+                )
+                fig_l.update_xaxes(title='', row=2, col=1)
+                fig_l.update_yaxes(title='Price (USD)', row=1, col=1, tickformat='$,.0f')
+                fig_l.update_yaxes(title='Volume', row=2, col=1)
+                st.plotly_chart(fig_l, width='stretch')
+
+                if not today_1h.empty:
+                    st.markdown(f"<p style='color:#f0f0f0;font-weight:bold;margin:8px 0 4px;'>"
+                                f"Hourly Detail | Last {min(8, len(today_1h))} hours</p>",
+                                unsafe_allow_html=True)
+                    last_h = today_1h.iloc[-8:] if len(today_1h) > 8 else today_1h
+                    chg_col = []
+                    for i in range(len(last_h)):
+                        chg = ((last_h['Close'].iloc[i] - last_h['Open'].iloc[i])
+                               / last_h['Open'].iloc[i] * 100)
+                        chg_col.append(f'{chg:+.2f}')
+                    tbl_h = pd.DataFrame({
+                        'Time': last_h.index.strftime('%H:%M'),
+                        'Open': [f'${v:,.0f}' for v in last_h['Open']],
+                        'High': [f'${v:,.0f}' for v in last_h['High']],
+                        'Low': [f'${v:,.0f}' for v in last_h['Low']],
+                        'Close': [f'${v:,.0f}' for v in last_h['Close']],
+                        'Vol': [f'{v:,.0f}' for v in last_h['Volume']],
+                        'Chg%': chg_col,
+                    })
+                    st.dataframe(tbl_h, width='stretch', hide_index=True)
+
+                st.markdown(f"<p style='color:#f0f0f0;font-weight:bold;margin:12px 0 4px;'>"
+                            f"3+{live_dias_slider} Day View | Actual + Forecast</p>",
+                            unsafe_allow_html=True)
+                last3 = price.iloc[-3:]
+                last3_dates = last3.index
+                pred_dates = future_dates[:live_dias_slider]
+                fig_bars = go.Figure()
+                fig_bars.add_trace(go.Bar(
+                    x=last3_dates, y=last3.values,
+                    name='Actual', marker_color='#457b9d', width=0.5,
+                ))
+                fig_bars.add_trace(go.Bar(
+                    x=pred_dates, y=median[:live_dias_slider],
+                    name=f'{modelo}', marker_color='#e63946', width=0.5,
+                ))
+                fig_bars.add_trace(go.Scatter(
+                    x=pred_dates, y=p90[:live_dias_slider],
+                    mode='lines', line=dict(color='rgba(230,57,70,0)'), showlegend=False,
+                ))
+                fig_bars.add_trace(go.Scatter(
+                    x=pred_dates, y=p10[:live_dias_slider],
+                    mode='lines', line=dict(color='rgba(230,57,70,0)'),
+                    fill='tonexty', fillcolor='rgba(230,57,70,0.12)',
+                    name='P10-P90',
+                ))
+                fig_bars.update_layout(
+                    template='plotly_dark', hovermode='x unified', height=280,
+                    margin=dict(l=10, r=10, t=10, b=10),
+                    barmode='group', legend=dict(orientation='h', y=1.02),
+                    yaxis=dict(title='BTC (USD)', tickformat='$,.0f'),
+                )
+                st.plotly_chart(fig_bars, width='stretch')
+
+                st.markdown(
+                    f"<p style='color:#555;font-size:12px;margin-top:10px;'>"
+                    f"Forecast {live_dias_slider}d: ${median[live_dias_slider - 1]:,.0f} "
+                    f"({(median[live_dias_slider - 1] - c) / c * 100:+.1f}%) &nbsp;|&nbsp; "
+                    f"P10: ${p10[live_dias_slider - 1]:,.0f} &nbsp; "
+                    f"P90: ${p90[live_dias_slider - 1]:,.0f}</p>",
+                    unsafe_allow_html=True,
+                )
+        else:
+            st.warning(L['waiting_data'])
+
+    st.divider()
+    st.markdown(
+        f"<p style='color:#555; font-size:11px; text-align:center;'>"
+        f"BTC Forecast V4 | {modelo} | Data: Yahoo Finance + CoinGecko | "
+        f"{now.strftime('%Y-%m-%d %H:%M:%S')}</p>",
+        unsafe_allow_html=True,
+    )
+
+
+if __name__ == '__main__':
+    main()

versions/hybrid_v4/backtest_v4.py

@@ -0,0 +1,125 @@
+"""
+Backtest V4 — Chronos walk-forward validation.
+Predicts the last N days using only data available before each prediction point.
+"""
+
+import os, sys, numpy as np, pandas as pd, yfinance as yf, torch
+from datetime import datetime, timedelta
+from sklearn.metrics import mean_absolute_percentage_error
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+RESULTS_DIR = os.path.join(PROJECT_ROOT, "results")
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+HISTORY_DAYS = 1000
+BACKTEST_DAYS = 10
+
+
+def run_chronos(train_data, horizon=1):
+    from chronos import ChronosPipeline
+    pipeline = ChronosPipeline.from_pretrained(
+        "amazon/chronos-t5-small", device_map="cpu", torch_dtype=torch.float32,
+    )
+    context = torch.tensor(train_data.values, dtype=torch.float32).squeeze().unsqueeze(0)
+    forecast = pipeline.predict(context, prediction_length=horizon, num_samples=20)
+    return np.quantile(forecast[0].numpy(), 0.5, axis=0)
+
+
+def backtest():
+    print('-' * 55)
+    print('  Backtest V4  |  Chronos  |  Walk-Forward Validation')
+    print('-' * 55)
+
+    end = datetime.now()
+    start = end - timedelta(days=HISTORY_DAYS)
+
+    btc = yf.download('BTC-USD', start=start.strftime('%Y-%m-%d'),
+                       end=end.strftime('%Y-%m-%d'), progress=False)
+    if isinstance(btc.columns, pd.MultiIndex):
+        btc.columns = btc.columns.droplevel(1)
+    price = btc['Close']
+    print(f'\n  Data: {len(price)} days downloaded')
+
+    days = []
+    preds = []
+    actuals = []
+    errors = []
+
+    for i in range(BACKTEST_DAYS, 0, -1):
+        train_end = len(price) - i
+        train_data = price.iloc[:train_end]
+        actual_val = price.iloc[train_end]
+
+        pred_val = run_chronos(train_data, horizon=1)[0]
+
+        day_label = price.index[train_end].strftime('%Y-%m-%d')
+        error_pct = abs(pred_val - actual_val) / actual_val * 100
+
+        days.append(day_label)
+        preds.append(pred_val)
+        actuals.append(actual_val)
+        errors.append(error_pct)
+
+        print(f'    {day_label}  |  pred: ${pred_val:>8,.2f}  actual: ${actual_val:>8,.2f}  '
+              f'error: {error_pct:>5.2f}%')
+
+    overall_mape = np.mean(errors)
+    print(f'\n  {"=" * 45}')
+    print(f'  Average MAPE ({BACKTEST_DAYS} days): {overall_mape:.2f}%')
+    print(f'  {"=" * 45}')
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 9),
+                                     gridspec_kw={'height_ratios': [2.5, 1]})
+    fig.suptitle('Backtest V4 — Chronos 1-day Walk-Forward',
+                 fontsize=14, fontweight='bold', y=0.98)
+
+    x = range(len(days))
+    ax1.plot(x, actuals, 'o-', color='#e63946', linewidth=2.5, label='Actual', markersize=8)
+    ax1.plot(x, preds, 's--', color='#457b9d', linewidth=2.5, label='Chronos', markersize=8)
+    for i in range(len(days)):
+        err = errors[i]
+        color = '#2a9d8f' if err < 3 else ('#e9c46a' if err < 6 else '#e63946')
+        ax1.plot([i, i], [actuals[i], preds[i]], color=color, linewidth=2, alpha=0.7)
+    ax1.set_ylabel('BTC Price (USD)', fontsize=11)
+    ax1.legend(fontsize=11)
+    ax1.grid(True, alpha=0.3)
+    ax1.set_xticks(range(len(days)))
+    ax1.set_xticklabels(days, rotation=45, ha='right')
+
+    colors = ['#2a9d8f' if e < 3 else ('#e9c46a' if e < 6 else '#e63946') for e in errors]
+    bars = ax2.bar(range(len(errors)), errors, color=colors)
+    for i, (bar, err) in enumerate(zip(bars, errors)):
+        ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.3,
+                 f'{err:.1f}%', ha='center', fontsize=9, fontweight='bold')
+    ax2.axhline(y=overall_mape, color='red', linestyle='--', linewidth=1.5,
+                label=f'Average MAPE: {overall_mape:.2f}%')
+    ax2.set_ylabel('Error (%)', fontsize=11)
+    ax2.set_xlabel('Date')
+    ax2.legend(fontsize=10)
+    ax2.grid(True, alpha=0.3, axis='y')
+    ax2.set_xticks(range(len(days)))
+    ax2.set_xticklabels(days, rotation=45, ha='right')
+
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+    path = os.path.join(RESULTS_DIR, 'backtest_v4.png')
+    plt.savefig(path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f'\n  Chart: {path}')
+
+    results = pd.DataFrame({
+        'Day': days, 'Prediction': preds, 'Actual': actuals, 'Error %': errors
+    })
+    csv_path = os.path.join(RESULTS_DIR, 'backtest_v4.csv')
+    results.to_csv(csv_path, index=False)
+    print(f'  CSV: {csv_path}')
+    print(f'\n  Backtest complete.\n')
+
+    return overall_mape
+
+
+if __name__ == '__main__':
+    backtest()

versions/hybrid_v4/estudio_backtest.py

@@ -0,0 +1,252 @@
+"""
+Historical Backtest Study — V4
+Evaluates Chronos variants and baseline models across multiple
+independent test windows dating back to 2024.
+"""
+
+import os, sys, numpy as np, pandas as pd, yfinance as yf, torch
+import warnings, time, json
+from datetime import datetime, timedelta
+from sklearn.metrics import mean_absolute_percentage_error
+from itertools import product
+
+warnings.filterwarnings('ignore')
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+RESULTS_DIR = os.path.join(PROJECT_ROOT, "results")
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+MIN_TRAIN = 500
+STEP = 30
+HISTORY = 1000
+
+
+def load_chronos(name="amazon/chronos-t5-small"):
+    from chronos import ChronosPipeline
+    return ChronosPipeline.from_pretrained(name, device_map="cpu", torch_dtype=torch.float32)
+
+
+def predict_chronos(pipeline, train_data, horizon=1, n_samples=20):
+    context = torch.tensor(train_data.values, dtype=torch.float32).squeeze().unsqueeze(0)
+    forecast = pipeline.predict(context, prediction_length=horizon, num_samples=n_samples)
+    return np.quantile(forecast[0].numpy(), 0.5, axis=0)
+
+
+def predict_arima(train_data, horizon=1):
+    from statsmodels.tsa.arima.model import ARIMA
+    model = ARIMA(train_data.values, order=(5,1,0))
+    fitted = model.fit()
+    return fitted.forecast(horizon)
+
+
+def predict_naive(train_data, horizon=1):
+    return np.full(horizon, train_data.iloc[-1])
+
+
+def predict_timesfm(train_data, horizon=1):
+    import timesfm
+    try:
+        tfm = timesfm.TimesFm(
+            hparams=timesfm.TimesFmHparams(
+                backend="cpu", per_core_batch_size=32, horizon_len=horizon,
+                context_len=512, input_patch_len=32, output_patch_len=128,
+                num_layers=20, model_dims=1280,
+            ),
+            checkpoint=timesfm.TimesFmCheckpoint(
+                huggingface_repo_id="google/timesfm-1.0-200m-pytorch"
+            )
+        )
+        context = train_data.values[-512:]
+        forecast = tfm.forecast([context], freq=[0])
+        return forecast[0][0][:horizon]
+    except:
+        return None
+
+
+def predict_moirai(train_data, horizon=1):
+    from uni2ts.model.moirai import MoiraiForecast, MoiraiModule
+    from gluonts.dataset.pandas import PandasDataset
+    from gluonts.evaluation import make_evaluation_predictions
+    try:
+        model = MoiraiForecast(
+            module=MoiraiModule.from_pretrained("Salesforce/moirai-1.0-R-small"),
+            prediction_length=horizon, context_length=min(512, len(train_data)),
+            patch_size="auto", num_samples=100, target_dim=1,
+            feat_dynamic_real_dim=0, past_feat_dynamic_real_dim=0,
+        )
+        predictor = model.create_predictor(batch_size=32)
+        df_m = pd.DataFrame({'Close': train_data.values}, index=train_data.index)
+        df_m.index = pd.DatetimeIndex(df_m.index)
+        df_m = df_m.asfreq('D').ffill().dropna()
+        ds = PandasDataset(df_m, target="Close")
+        it, _ = make_evaluation_predictions(dataset=ds, predictor=predictor, num_samples=100)
+        forecast = list(it)[0]
+        return forecast.quantile(0.5)[:horizon]
+    except:
+        return None
+
+
+def run_study():
+    print('\n' + '=' * 65)
+    print('  HISTORICAL BACKTEST STUDY  |  Multi-Model Comparison')
+    print('=' * 65)
+
+    end = datetime.now()
+    start = end - timedelta(days=HISTORY + 365)
+    btc = yf.download('BTC-USD', start='2020-01-01',
+                       end=end.strftime('%Y-%m-%d'), progress=False)
+    if isinstance(btc.columns, pd.MultiIndex):
+        btc.columns = btc.columns.droplevel(1)
+    price = btc['Close']
+    price = price[price.index >= pd.Timestamp(start)]
+    price = price[price.index <= pd.Timestamp(end)]
+
+    if len(price) == 0:
+        print('Error: no data downloaded. Aborting.')
+        return
+    print(f'\n  Total data: {len(price)} days ({price.index[0].date()} -> {price.index[-1].date()})')
+
+    test_points = []
+    for i in range(len(price) - MIN_TRAIN - 1, 0, -STEP):
+        if i < MIN_TRAIN or len(test_points) >= 50:
+            break
+        test_points.append(i)
+
+    test_points = test_points[::-1]
+    print(f'  Test windows: {len(test_points)} (every {STEP} days)')
+    print(f'     {price.index[test_points[0]].date()} -> {price.index[test_points[-1]].date()}\n')
+
+    models = {
+        'Chronos-Small': 'amazon/chronos-t5-small',
+        'Chronos-Tiny': 'amazon/chronos-t5-tiny',
+        'Chronos-Base': 'amazon/chronos-t5-base',
+    }
+
+    pipelines = {}
+    print('  Loading Chronos models...')
+    for name, hf_name in models.items():
+        print(f'    -> {name}...', end=' ', flush=True)
+        pipelines[name] = load_chronos(hf_name)
+        print('done')
+
+    print('')
+    results = {name: [] for name in list(models.keys()) + ['ARIMA', 'Naive', 'TimesFM', 'MOIRAI']}
+    times = {name: [] for name in results}
+
+    for idx, tp in enumerate(test_points):
+        train_data = price.iloc[tp - MIN_TRAIN:tp]
+        actual = float(price.iloc[tp])
+        pct = (idx + 1) / len(test_points) * 100
+
+        print(f'\r  Progress: {pct:.0f}% | {price.index[tp].date()} -> ${actual:,.0f}', end='', flush=True)
+
+        for name, pipeline in pipelines.items():
+            t0 = time.time()
+            try:
+                pred = predict_chronos(pipeline, train_data)
+                err = abs(pred[0] - actual) / actual * 100
+                results[name].append(err)
+                times[name].append(time.time() - t0)
+            except:
+                results[name].append(np.nan)
+                times[name].append(0)
+
+        t0 = time.time()
+        try:
+            pred = predict_arima(train_data)
+            err = abs(pred[0] - actual) / actual * 100
+            results['ARIMA'].append(err)
+        except:
+            results['ARIMA'].append(np.nan)
+        times['ARIMA'].append(time.time() - t0)
+
+        t0 = time.time()
+        pred = predict_naive(train_data)
+        err = abs(pred[0] - actual) / actual * 100
+        results['Naive'].append(err)
+        times['Naive'].append(time.time() - t0)
+
+        if 'TimesFM' in results and idx % 3 == 0:
+            t0 = time.time()
+            try:
+                pred = predict_timesfm(train_data)
+                if pred is not None:
+                    err = abs(pred[0] - actual) / actual * 100
+                    results['TimesFM'].append(err)
+                else:
+                    results['TimesFM'].append(np.nan)
+            except:
+                results['TimesFM'].append(np.nan)
+            times['TimesFM'].append(time.time() - t0)
+        elif 'TimesFM' in results:
+            results['TimesFM'].append(np.nan)
+            times['TimesFM'].append(0)
+
+        if 'MOIRAI' in results and idx % 3 == 0:
+            t0 = time.time()
+            try:
+                pred = predict_moirai(train_data)
+                if pred is not None:
+                    err = abs(pred[0] - actual) / actual * 100
+                    results['MOIRAI'].append(err)
+                else:
+                    results['MOIRAI'].append(np.nan)
+            except:
+                results['MOIRAI'].append(np.nan)
+            times['MOIRAI'].append(time.time() - t0)
+        elif 'MOIRAI' in results:
+            results['MOIRAI'].append(np.nan)
+            times['MOIRAI'].append(0)
+
+    print('\n')
+
+    print('\n' + '=' * 65)
+    print('  RESULTS')
+    print('=' * 65)
+    print(f'  {"Model":25s} {"MAPE":>8s} {"Std":>8s} {"Min":>8s} {"Max":>8s} {"Time":>8s}')
+    print(f'  {"-" * 60}')
+
+    summary = []
+    for name in results:
+        vals = [v for v in results[name] if not np.isnan(v)]
+        if len(vals) > 0:
+            mape = np.mean(vals)
+            std = np.std(vals)
+            min_v = np.min(vals)
+            max_v = np.max(vals)
+            t_avg = np.mean(times[name]) if times[name] else 0
+            print(f'  {name:25s} {mape:>7.2f}% {std:>7.2f}% {min_v:>7.2f}% {max_v:>7.2f}% {t_avg:>7.3f}s')
+            summary.append({'Model': name, 'MAPE': mape, 'Std': std,
+                           'Min': min_v, 'Max': max_v, 'Samples': len(vals)})
+        else:
+            print(f'  {name:25s} {"N/A":>8s}')
+
+    df_results = pd.DataFrame(summary).sort_values('MAPE')
+    csv_path = os.path.join(RESULTS_DIR, 'estudio_backtest_modelos.csv')
+    df_results.to_csv(csv_path, index=False)
+    print(f'\n  CSV: {csv_path}')
+
+    naive_mape = df_results[df_results['Model'] == 'Naive']['MAPE'].values[0]
+    print(f'\n  IMPROVEMENT VS NAIVE ({naive_mape:.2f}%):')
+    for _, row in df_results.iterrows():
+        if row['Model'] != 'Naive' and row['Samples'] > 5:
+            mejora = (naive_mape - row['MAPE']) / naive_mape * 100
+            print(f'    {row["Model"]:25s} {mejora:+.1f}%')
+
+    print(f'\n  MAPE BY YEAR (Chronos-Small):')
+    years = {}
+    for idx, tp in enumerate(test_points):
+        year = price.index[tp].year
+        if year not in years:
+            years[year] = []
+        years[year].append(results['Chronos-Small'][idx])
+    for year in sorted(years.keys()):
+        vals = [v for v in years[year] if not np.isnan(v)]
+        if vals:
+            print(f'    {year}: {np.mean(vals):.2f}% ({len(vals)} samples)')
+
+    print(f'\n  Study complete.\n')
+
+
+if __name__ == '__main__':
+    run_study()

versions/hybrid_v4/forecast_v4.py

@@ -0,0 +1,172 @@
+"""
+Forecast V4 — Chronos forward prediction.
+Projects N days ahead using historical price data and displays confidence bands.
+"""
+
+import os, sys, numpy as np, pandas as pd, yfinance as yf, torch
+import requests
+from datetime import datetime, timedelta
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+RESULTS_DIR = os.path.join(PROJECT_ROOT, "results")
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+HISTORY_DAYS = 1000
+
+
+def run_chronos_probabilistic(train_data, horizon, n_samples=100):
+    from chronos import ChronosPipeline
+    pipeline = ChronosPipeline.from_pretrained(
+        "amazon/chronos-t5-small", device_map="cpu", torch_dtype=torch.float32,
+    )
+    context = torch.tensor(train_data.values, dtype=torch.float32).squeeze().unsqueeze(0)
+    forecast = pipeline.predict(context, prediction_length=horizon, num_samples=n_samples)
+    samples = forecast[0].numpy()
+    median = np.median(samples, axis=0)
+    p10 = np.percentile(samples, 10, axis=0)
+    p90 = np.percentile(samples, 90, axis=0)
+    return median, p10, p90, samples
+
+
+def get_market_snapshot():
+    snapshot = {}
+    btc = yf.download('BTC-USD', period='5d', progress=False)
+    if isinstance(btc.columns, pd.MultiIndex):
+        btc.columns = btc.columns.droplevel(1)
+    if len(btc) > 0:
+        snapshot['Current Price'] = f"${btc['Close'].iloc[-1]:,.2f}"
+        snapshot['24h Change'] = f"{btc['Close'].pct_change().iloc[-1] * 100:+.2f}%"
+        snapshot['Volume'] = f"${btc['Volume'].iloc[-1]:,.0f}"
+
+    try:
+        fng = requests.get('https://api.alternative.me/fng/?limit=1', timeout=5).json()
+        if 'data' in fng and len(fng['data']) > 0:
+            snapshot['Fear & Greed'] = f"{fng['data'][0]['value']}/100 ({fng['data'][0]['value_classification']})"
+    except:
+        snapshot['Fear & Greed'] = 'N/A'
+
+    tickers = {'^GSPC': 'S&P 500', 'GC=F': 'Gold', 'DX-Y.NYB': 'DXY'}
+    for tk, name in tickers.items():
+        try:
+            df = yf.download(tk, period='5d', progress=False)
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = df.columns.droplevel(1)
+            if len(df) > 0:
+                val = df['Close'].iloc[-1]
+                chg = df['Close'].pct_change().iloc[-1] * 100
+                snapshot[name] = f"{val:,.2f} ({chg:+.2f}%)"
+        except:
+            pass
+
+    return snapshot
+
+
+def forecast():
+    import argparse
+    parser = argparse.ArgumentParser(description='Chronos V4 Forecast')
+    parser.add_argument('--dias', type=int, default=10,
+                        help='Days to forecast (default: 10)')
+    parser.add_argument('--muestras', type=int, default=100,
+                        help='Number of probabilistic samples (default: 100)')
+    args = parser.parse_args()
+
+    HORIZON = args.dias
+    N_SAMPLES = args.muestras
+
+    print('-' * 55)
+    print(f'  Forecast V4  |  Chronos  |  {HORIZON} days ahead')
+    print('-' * 55)
+
+    end = datetime.now()
+    start = end - timedelta(days=HISTORY_DAYS)
+
+    print('\n  Downloading data...')
+    btc = yf.download('BTC-USD', start=start.strftime('%Y-%m-%d'),
+                       end=end.strftime('%Y-%m-%d'), progress=False)
+    if isinstance(btc.columns, pd.MultiIndex):
+        btc.columns = btc.columns.droplevel(1)
+    price = btc['Close']
+    print(f'  History: {len(price)} days')
+
+    print(f'\n  Running Chronos ({N_SAMPLES} samples, {HORIZON} days)...')
+    median, p10, p90, samples = run_chronos_probabilistic(price, HORIZON, N_SAMPLES)
+
+    last_date = price.index[-1]
+    future_dates = pd.date_range(start=last_date + timedelta(days=1),
+                                  periods=HORIZON, freq='D')
+    last_price = price.iloc[-1]
+
+    print(f'\n  {"Day":>4s} {"Date":>12s} {"Forecast":>14s} {"P10":>12s} {"P90":>12s} {"Change%":>8s}')
+    print(f'  {"-" * 62}')
+    print(f'  {0:>4d} {last_date.strftime("%Y-%m-%d"):>12s} '
+          f'${last_price:>8,.2f} {"":>12s} {"":>12s} {"--":>8s}')
+    for i in range(HORIZON):
+        chg = (median[i] - last_price) / last_price * 100
+        print(f'  {i+1:>4d} {future_dates[i].strftime("%Y-%m-%d"):>12s} '
+              f'${median[i]:>8,.2f}  ${p10[i]:>8,.2f}  ${p90[i]:>8,.2f}  {chg:>+7.2f}%')
+
+    print(f'\n  {"=" * 50}')
+    print('  CURRENT MARKET CONTEXT')
+    print(f'  {"=" * 50}')
+    snapshot = get_market_snapshot()
+    for k, v in snapshot.items():
+        print(f'    {k:20s} -> {v}')
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 10),
+                                     gridspec_kw={'height_ratios': [3, 1]})
+    fig.suptitle(f'Forecast V4 — Chronos: {HORIZON} days ahead',
+                 fontsize=15, fontweight='bold', y=0.98)
+
+    ctx_days = min(90, len(price))
+    ctx = price.iloc[-ctx_days:]
+
+    ax1.plot(ctx.index, ctx.values, color='#1a1a2e', linewidth=1.5, label='BTC History')
+    ax1.plot(future_dates, median, color='#e63946', linewidth=2.5, label='Chronos (median)')
+    ax1.fill_between(future_dates, p10, p90, color='#e63946', alpha=0.15,
+                      label='P10-P90')
+    ax1.axvline(x=last_date, color='gray', linestyle=':', alpha=0.5)
+    ax1.set_ylabel('BTC Price (USD)', fontsize=11)
+    ax1.legend(fontsize=10, loc='upper left')
+    ax1.grid(True, alpha=0.3)
+    ax1.xaxis.set_major_formatter(mdates.DateFormatter('%b %d'))
+    ax1.xaxis.set_major_locator(mdates.WeekdayLocator(interval=1))
+
+    last_30 = price.iloc[-30:]
+    ax2.bar(last_30.index, last_30.values, color='#457b9d', alpha=0.7, width=0.8)
+    ax2.set_ylabel('BTC (USD)', fontsize=11)
+    ax2.set_xlabel('Date')
+    ax2.grid(True, alpha=0.3)
+    ax2.xaxis.set_major_formatter(mdates.DateFormatter('%b %d'))
+
+    cell_text = [[k, v] for k, v in snapshot.items()]
+    table = ax2.table(cellText=cell_text, colLabels=['Indicator', 'Value'],
+                       loc='upper right', fontsize=8,
+                       cellLoc='left', bbox=[0.65, 0.55, 0.33, 0.40])
+    table.auto_set_font_size(False)
+    table.set_fontsize(7)
+
+    plt.tight_layout(rect=[0, 0, 1, 0.96])
+    path = os.path.join(RESULTS_DIR, 'forecast_v4.png')
+    plt.savefig(path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f'\n  Chart: {path}')
+
+    results = pd.DataFrame({
+        'Day': range(1, HORIZON + 1),
+        'Date': future_dates.strftime('%Y-%m-%d'),
+        'Forecast': median,
+        'P10': p10,
+        'P90': p90,
+    })
+    csv_path = os.path.join(RESULTS_DIR, 'forecast_v4.csv')
+    results.to_csv(csv_path, index=False)
+    print(f'  CSV: {csv_path}')
+    print(f'\n  Forecast complete.\n')
+
+
+if __name__ == '__main__':
+    forecast()