Kronos + Autoresearch

Modelo fundacional financiero autónomo — Fusión de Kronos (primera foundation model open-source para mercados financieros) con un bucle de investigación autónoma inspirado en karpathy/autoresearch.

Entrena durante la noche. Despertate con un modelo mejorado.

📖 Índice

Qué es esto
Características
Requisitos
Instalación rápida
Uso
Estructura del proyecto
Optimizaciones para RTX 3090
Personalización avanzada
Resultados esperados
FAQ
Créditos
Licencia

🤔 Qué es esto

Este proyecto combina dos mundos:

Kronos: El primer modelo fundacional open-source para velas financieras (K-lines), entrenado en datos de más de 45 exchanges globales. Originalmente creado por shiyu-coder/Kronos.
Autoresearch: Un pipeline autónomo que realiza experimentos, mide resultados y decide automáticamente si "avanza" o "descarta" cambios en la arquitectura/hiperparámetros. Inspirado en karpathy/autoresearch.

¿Qué podés hacer con esto?

✅ Entrenar un modelo financiero en tu GPU local
✅ Dejar corriendo el bucle de investigación autónoma durante la noche
✅ Despertarte con un modelo mejorado, checkpoints y un results.tsv con el historial de experimentos
✅ Experimentar con arquitecturas Transformer cuantizadas (BSQ)
✅ Fine-tunear con tus propios datos financieros

✨ Características

Modelo Kronos integrado: Tokenización BSQ (Binary Spherical Quantization), embeddings jerárquicos, attention con RoPE
Bucle de investigación autónoma: Mutación automática de hiperparámetros y arquitectura
Optimizado para GPUs intermedias: Configurado para RTX 3090 (24GB VRAM), escalable a otras GPUs
Mixed Precision (AMP): Entrenamiento más rápido y eficiente en memoria
Gradient Clipping: Estabilidad en el entrenamiento
Checkpoints automáticos: Guardado cada N steps
Métricas en tiempo real: Loss, LR, MFU, uso de VRAM
Datos sintéticos incluidos: No necesitás datos externos para empezar

📦 Requisitos

Hardware

Componente	Mínimo	Recomendado
GPU	GTX 1080 (8GB)	RTX 3090 (24GB)
VRAM	8 GB	24 GB
RAM	16 GB	32+ GB
Disco	30 GB libres	100 GB SSD

Software

Python 3.10+
CUDA 12.0+ (para GPU NVIDIA)
Ubuntu 20.04+ / WSL2 / macOS (CPU-only)

🚀 Instalación rápida

1. Clonar el repositorio

git clone https://github.com/tu-usuario/kronos-autoresearch.git
cd kronos-autoresearch

2. Crear entorno virtual

python3 -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

3. Instalar dependencias

Opción A: Con pip (recomendado)

pip install --upgrade pip
pip install -r requirements.txt

Opción B: Con uv (más rápido)

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

4. Verificar instalación

python -c "import torch; print(f'PyTorch: {torch.__version__}')"
python -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}')"

📖 Uso

Modo 1: Preparar datos (solo la primera vez)

./run.sh prep

Esto genera datos financieros sintéticos (OHLC + volumen) para testing. Los datos reales se pueden cargar después (ver Personalización).

Modo 2: Entrenamiento estándar

./run.sh train

Parámetros por defecto:

Batch size: 32 (ajustable según VRAM)
Secuencia: 256 pasos
Learning rate: 3e-4
Mixed precision: activado

Comando completo con personalización:

python train.py \
  --batch-size 64 \
  --seq-len 512 \
  --lr 3e-4 \
  --max-steps 100000 \
  --eval-interval 500 \
  --save-interval 1000 \
  --use-amp \
  --output-dir ./checkpoints

Modo 3: Investigación autónoma (overnight)

./run.sh research

Este modo:

Genera mutaciones aleatorias en hiperparámetros/arquitectura
Entrena durante un presupuesto de tiempo fijo (10 min por defecto)
Evalúa y guarda/descarta el experimento
Registra todo en results.tsv

Ejemplo con customización:

python run_research.py \
  --iterations 20 \
  --budget 600 \
  --keep-best

Modo 4: Smoke test (verificación rápida)

./run.sh test

Ejecuta 10 steps de entrenamiento con batch pequeño para verificar que todo funcione.

📁 Estructura del proyecto

kronos-autoresearch/
├── model/
│   ├── kronos_modules.py      # Componentes base (BSQ, Attention, Transformer)
│   └── kronos_research.py     # Modelo unificado + wrapper de experimentos
├── prepare.py                 # Preparación de datos (sintéticos o reales)
├── train.py                   # Training loop con AMP y checkpoints
├── run_research.py            # Bucle autónomo de experimentación
├── config.py                  # Hiperparámetros centralizados
├── run.sh                     # Launcher de un solo comando
├── requirements.txt           # Dependencias de Python
├── README.md                  # Este archivo
├── LICENSE                    # Licencia MIT
├── checkpoints/               # Checkpoints generados (git-ignored)
├── logs/                      # Logs de entrenamiento (git-ignored)
└── results.tsv                # Historial de experimentos (git-ignored)

⚙️ Optimizaciones para RTX 3090

El código incluye optimizaciones específicas para GPUs NVIDIA de gama media-alta:

1. Mixed Precision (AMP)

from torch.cuda.amp import autocast, GradScaler

# Automáticamente activado con --use-amp

Beneficio: Reduce VRAM ~50%, acelera 1.5-2x en GPUs Ampere.

2. Segmentos expandibles de memoria

export PYTORCH_ALLOC_CONF="expandable_segments:True"

Beneficio: Evita OOM en entrenamientos largos.

3. TF32 para Ampere

torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True

Beneficio: Hasta 8x más rápido en RTX 3090.

4. Gradient Clipping

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=3.0)

Beneficio: Evita exploding gradients en transformers profundos.

5. Batch size dinámico

El script run.sh detecta automáticamente tu VRAM y ajusta:

if [ "GPU_MEM" -lt 10000 ]; then
    BATCH_SIZE=8
    SEQ_LEN=128
else
    BATCH_SIZE=64
    SEQ_LEN=512
fi

🛠️ Personalización avanzada

Usar datos financieros reales

Reemplazá generate_synthetic_financial_data() en prepare.py:

import pandas as pd

def load_real_financial_data(csv_path: str):
    """Cargar datos OHLCV desde CSV."""
    df = pd.read_csv(csv_path, parse_dates=True, index_col=0)
    
    # Seleccionar columnas
    cols = ["Open", "High", "Low", "Close", "Volume"]
    df = df[cols].fillna(method="ffill").fillna(method="bfill")
    
    # Normalizar
    mean = df.mean().values
    std = df.std().values + 1e-5
    df_normalized = (df - mean) / std
    
    return torch.tensor(df_normalized.values, dtype=torch.float32), mean, std

Luego en prepare_all():

financial_data, mean, std = load_real_financial_data("tu_archivo.csv")

Agregar nuevas mutaciones al research loop

Editá generate_random_hypothesis() en run_research.py:

def generate_random_hypothesis():
    mutation = random.choice([
        "lr_scale",
        "depth_change",
        "width_change",
        "my_custom_mutation",  # ← Nuevo
    ])
    
    if mutation == "my_custom_mutation":
        tweaks["n_heads"] = random.choice([8, 12, 16])
        desc = f"n_heads={tweaks['n_heads']}"
    
    return tweaks, desc

Cambiar arquitectura base

En config.py:

KRONOS_D_MODEL = 768       # De 512 a 768 (más capacidad)
KRONOS_N_LAYERS = 12       # De 8 a 12 (más profundidad)
KRONOS_N_HEADS = 12        # Ajustar proporcionalmente
S1_BITS = 10               # Más precisión en tokenización
S2_BITS = 10

📊 Resultados esperados

Métricas de entrenamiento

Configuración	VRAM	Tiempo/epoch	Loss inicial	Loss final (10k steps)
RTX 3090 (batch=64, seq=512)	16 GB	45s	2.5	0.95
RTX 3090 (batch=32, seq=256)	8 GB	25s	2.5	0.98
GTX 1080 (batch=8, seq=128)	6 GB	60s	2.6	1.05

Métricas de autoresearch

Experimento	val_bpb	memory_gb	status	descripción
exp_001	1.023456	18.5	keep	baseline
exp_002	0.998234	19.2	keep	LR x2
exp_003	1.045678	18.1	discard	n_layers=12
exp_004	0.000000	0.0	crash	OOM (batch=128)

Model FLOPS Utilization (MFU)

GPU	MFU (sin AMP)	MFU (con AMP)
RTX 3090	12-15%	18-25%
RTX 4090	15-18%	22-30%
A100	20-25%	28-35%

❓ FAQ

¿Puedo usar esto sin GPU?

Sí, pero el entrenamiento será muy lento. Usá --batch-size 4 --seq-len 64 para testing.

¿Necesito datos financieros reales?

No. El proyecto incluye generación de datos sintéticos. Pero para resultados útiles, usá datos reales.

¿Cuánto tarda en entrenar?

10k steps en RTX 3090: ~2-3 horas
100k steps en RTX 3090: ~20-30 horas
Research loop (20 iters): ~3-4 horas

¿Puedo usar esto para trading real?

⚠️ No. Este es un proyecto experimental. No lo uses para trading con dinero real sin validación exhaustiva.

¿Cómo guardo un checkpoint para usar después?

Automáticamente se guardan en ./checkpoints/. Para cargar:

checkpoint = torch.load("checkpoints/checkpoint_step_010000.pt")
model.load_state_dict(checkpoint["model"])

¿Funciona en macOS (M1/M2)?

Sí, pero sin GPU. El entrenamiento será lento. Usá --batch-size 4.

🙏 Créditos

Este proyecto combina y adapta código de:

Kronos: shiyu-coder/Kronos - Modelo fundacional financiero
Autoresearch: karpathy/autoresearch - Bucle de investigación autónoma
Binary Spherical Quantization: arxiv.org/abs/2406.07548

Agradecimientos especiales a:

Shiyu (Kronos original)
Andrej Karpathy (autoresearch)
La comunidad de Hugging Face

📄 Licencia

MIT License. Ver LICENSE para más detalles.

🤝 Contribuciones

Issues y PRs son bienvenidos. Este es un proyecto experimental y comunitario.

Formas de contribuir:

📬 Contacto

Issues: GitHub Issues
Discusión: GitHub Discussions

¿Te gustó este proyecto? ⭐ Dejá una estrella!

Hecho con ❤️ para la comunidad de ML financiero

Name		Name	Last commit message	Last commit date
model		model
README.md		README.md
config.py		config.py
prepare.py		prepare.py
requirements.txt		requirements.txt
run.sh		run.sh
run_research.py		run_research.py
train.py		train.py

Latest commit

History

Folders and files

Repository files navigation