from ultralytics import YOLO

# Cargar modelo pre-entrenado
model = YOLO('yolov8n.pt')  # nano (más rápido)
# model = YOLO('yolov8s.pt')  # small
# model = YOLO('yolov8m.pt')  # medium
# model = YOLO('yolov8l.pt')  # large
# model = YOLO('yolov8x.pt')  # xlarge (más preciso)

# Detectar objetos
results = model('image.jpg')

# Visualizar
results[0].show()

# Acceder a detecciones
for box in results[0].boxes:
    class_id = int(box.cls)
    confidence = float(box.conf)
    bbox = box.xyxy[0].tolist()  # [x1, y1, x2, y2]
    
    print(f"Detected: {model.names[class_id]} ({confidence:.2f})")
    print(f"BBox: {bbox}")

from ultralytics import YOLO
import cv2

model = YOLO('yolov8n.pt')

# 1. Imagen única
results = model('path/to/image.jpg')

# 2. Múltiples imágenes
results = model(['image1.jpg', 'image2.jpg'])

# 3. Video
results = model('video.mp4', stream=True)
for r in results:
    r.show()  # Mostrar frame por frame

# 4. Webcam en tiempo real
results = model(0, stream=True)  # 0 = default webcam
for r in results:
    frame = r.plot()  # Dibujar detecciones
    cv2.imshow('YOLO', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 5. YouTube stream
results = model('https://www.youtube.com/watch?v=dQw4w9WgXcQ')

results = model('image.jpg')
result = results[0]

# Bounding boxes
boxes = result.boxes.xyxy.cpu().numpy()  # [[x1, y1, x2, y2], ...]
confidences = result.boxes.conf.cpu().numpy()  # [0.95, 0.87, ...]
classes = result.boxes.cls.cpu().numpy()  # [0, 5, 2, ...]  (class IDs)

# Filtrar por confidence
high_conf = boxes[confidences > 0.7]

# Filtrar por clase (ej: solo personas = clase 0)
person_boxes = boxes[classes == 0]

# Guardar imagen con detecciones
annotated = result.plot()
cv2.imwrite('output.jpg', annotated)

# Guardar boxes como JSON
import json
detections = []
for box, conf, cls in zip(boxes, confidences, classes):
    detections.append({
        "class": model.names[int(cls)],
        "confidence": float(conf),
        "bbox": box.tolist()
    })
json.dump(detections, open('detections.json', 'w'))

from ultralytics import YOLO

# Cargar modelo pre-entrenado (transfer learning)
model = YOLO('yolov8n.pt')

# Entrenar
results = model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,  # GPU 0 (o 'cpu')
    workers=8,
    patience=20,  # Early stopping
    save=True,
    project='defect_detection',
    name='exp1'
)

# Resultados guardados en: defect_detection/exp1/
# - weights/best.pt
# - weights/last.pt
# - results.png (gráficas)
# - confusion_matrix.png

model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    
    # Learning rate
    lr0=0.01,        # Initial LR
    lrf=0.01,        # Final LR (lr0 * lrf)
    momentum=0.937,
    weight_decay=0.0005,
    
    # Augmentation
    hsv_h=0.015,     # Hue
    hsv_s=0.7,       # Saturation
    hsv_v=0.4,       # Value
    degrees=10.0,    # Rotation (±deg)
    translate=0.1,   # Translation (±%)
    scale=0.5,       # Scaling (±%)
    flipud=0.0,      # Vertical flip
    fliplr=0.5,      # Horizontal flip
    mosaic=1.0,      # Mosaic augmentation
    
    # Regularization
    dropout=0.0,
    label_smoothing=0.0,
    
    # Device
    device=0,        # GPU
    workers=8,
    cache=True       # Cache images in RAM
)

# Cargar best model
model = YOLO('defect_detection/exp1/weights/best.pt')

# Evaluar en validation set
metrics = model.val()

print(f"mAP@50: {metrics.box.map50:.3f}")
print(f"mAP@50-95: {metrics.box.map:.3f}")
print(f"Precision: {metrics.box.p}")
print(f"Recall: {metrics.box.r}")

# Test en imágenes específicas
results = model.predict('test_images/', save=True)

from albumentations import Compose, HorizontalFlip, RandomBrightnessContrast, CLAHE

augment = Compose([
    HorizontalFlip(p=0.5),
    RandomBrightnessContrast(p=0.2),
    CLAHE(p=0.3)
])

# Aplicar antes de training
augmented = augment(image=image, bboxes=bboxes, class_labels=labels)

models = [
    YOLO('yolov8n.pt'),
    YOLO('yolov8s.pt'),
    YOLO('yolov8m.pt')
]

# Combinar predicciones
all_boxes = []
all_scores = []
for model in models:
    results = model('image.jpg')
    all_boxes.extend(results[0].boxes.xyxy)
    all_scores.extend(results[0].boxes.conf)

# Non-Maximum Suppression (NMS) para eliminar duplicados
from torchvision.ops import nms
keep = nms(all_boxes, all_scores, iou_threshold=0.5)
final_boxes = all_boxes[keep]

# Predecir con múltiples augmentaciones y promediar
results = model('image.jpg', augment=True)
# Internamente hace: original + flipud + fliplr y promedia

from ultralytics import YOLO

model = YOLO('yolov8n.pt')

# Object tracking con ByteTrack
results = model.track(
    'video.mp4',
    stream=True,
    tracker='bytetrack.yaml'  # o 'botsort.yaml'
)

for r in results:
    for box in r.boxes:
        track_id = int(box.id)  # ID único del objeto
        print(f"Object {track_id} at {box.xyxy}")

model = YOLO('yolov8n.pt')

# ONNX (universal)
model.export(format='onnx')

# TensorRT (NVIDIA GPUs - 3× más rápido)
model.export(format='engine', device=0)

# CoreML (iOS/macOS)
model.export(format='coreml')

# TFLite (Android/Edge devices)
model.export(format='tflite')

# OpenVINO (Intel CPUs)
model.export(format='openvino')

# Modelo exportado: yolov8n.engine
model = YOLO('yolov8n.engine')

# Inference 3× más rápido (1.5ms → 0.5ms)
results = model('image.jpg')

# Procesar múltiples imágenes a la vez
images = [f'image{i}.jpg' for i in range(100)]
results = model(images, batch=32)  # 32 imágenes por batch

model = YOLO('yolov8n.pt')
model.to('cuda')
model.half()  # FP32 → FP16 (2× más rápido, misma precisión)

results = model('image.jpg')

# Dataset: 5000 imágenes de trabajadores
# Classes: helmet, no_helmet, person

model = YOLO('yolov8s.pt')
model.train(
    data='helmet_dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16
)

# Deployment: Raspberry Pi 4 + webcam
# FPS: 8-10 con yolov8n.pt
# Alerta si detect 'no_helmet'

# Dataset: 10k imágenes de piezas manufacturadas
# Classes: scratch, dent, crack, ok

# Training
model = YOLO('yolov8m.pt')
model.train(data='defects.yaml', epochs=150)

# Accuracy: 96.3% mAP@50
# Deployment: Conveyor belt @ 30 FPS
# ROI: 85% reduction in manual inspection

# Detect vehicles, count traffic, detect violations
model = YOLO('yolov8l.pt')

# Classes: car, truck, bus, motorcycle, bicycle, person
results = model.track('traffic_cam.mp4', tracker='bytetrack.yaml')

# Count vehicles crossing line
line_y = 500
vehicle_count = 0

for r in results:
    for box in r.boxes:
        y_center = (box.xyxy[0][1] + box.xyxy[0][3]) / 2
        if y_center > line_y:
            vehicle_count += 1

# Síntomas: train loss baja, val loss alta
# Soluciones:

# 1. Más data augmentation
model.train(
    data='dataset.yaml',
    mosaic=1.0,
    degrees=15,
    scale=0.7,
    mixup=0.1
)

# 2. Early stopping
model.train(patience=30)

# 3. Regularization
model.train(dropout=0.2, label_smoothing=0.1)

# Dataset: 90% OK, 5% defect_A, 5% defect_B

# Solución: Class weights en loss function
# (YOLOv8 hace esto automáticamente con class frequencies)

# O balancear dataset manualmente
from imblearn.over_sampling import RandomOverSampler

# Aumentar muestras de clases minoritarias

# Objetos < 32×32 píxeles difíciles de detectar

# Soluciones:

# 1. Aumentar resolución
model.train(imgsz=1280)  # Default: 640

# 2. Tile-based inference
# Dividir imagen grande en tiles, detectar en cada tile

# 3. Usar YOLOv8-P6 (diseñado para objetos pequeños)
model = YOLO('yolov8n-p6.pt')

# notebook_final_v3_REAL_ultima_version.ipynb

# ❌ Problemas:
# - Datos sin versionar (¿qué data entrenó este modelo?)
# - Experimentos perdidos (¿qué hiperparams funcionaron?)
# - Código no reproducible (funciona en mi máquina™)
# - Deploy manual (copiar .pkl a servidor)
# - Sin monitoring (modelo degrada silently)

# src/train.py
import yaml
import joblib
from sklearn.ensemble import RandomForestClassifier

# Leer params
with open("params.yaml") as f:
    params = yaml.safe_load(f)

# Entrenar
model = RandomForestClassifier(
    n_estimators=params["train"]["n_estimators"],
    max_depth=params["train"]["max_depth"]
)
model.fit(X_train, y_train)

# Guardar
joblib.dump(model, "models/model.pkl")

# Guardar métricas
metrics = {"accuracy": 0.92, "f1": 0.89}
with open("metrics.json", "w") as f:
    json.dump(metrics, f)

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score

# Configurar tracking server
mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("credit-card-fraud")

# Entrenar con tracking
with mlflow.start_run(run_name="rf_baseline"):
    
    # Log params
    params = {
        "n_estimators": 100,
        "max_depth": 10,
        "min_samples_split": 5
    }
    mlflow.log_params(params)
    
    # Entrenar modelo
    model = RandomForestClassifier(**params)
    model.fit(X_train, y_train)
    
    # Evaluar
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    f1 = f1_score(y_test, y_pred)
    
    # Log metrics
    mlflow.log_metrics({
        "accuracy": accuracy,
        "f1_score": f1,
        "precision": precision_score(y_test, y_pred)
    })
    
    # Log artifacts
    fig = plot_confusion_matrix(y_test, y_pred)
    mlflow.log_figure(fig, "confusion_matrix.png")
    
    # Log model
    mlflow.sklearn.log_model(
        model,
        "model",
        registered_model_name="FraudDetector"
    )
    
    # Log dataset info
    mlflow.log_param("train_size", len(X_train))
    mlflow.log_param("test_size", len(X_test))

from mlflow.tracking import MlflowClient

client = MlflowClient()

# Registrar modelo
result = mlflow.register_model(
    "runs:/abc123/model",
    "FraudDetector"
)

# Promover a staging
client.transition_model_version_stage(
    name="FraudDetector",
    version=3,
    stage="Staging"
)

# Después de validar, promover a production
client.transition_model_version_stage(
    name="FraudDetector",
    version=3,
    stage="Production"
)

# Cargar modelo de producción
model_uri = "models:/FraudDetector/Production"
model = mlflow.sklearn.load_model(model_uri)

# tests/test_model.py
import pytest
import joblib
import pandas as pd
from src.train import preprocess, train_model

def test_preprocess():
    """Test data preprocessing"""
    df = pd.DataFrame({
        'amount': [100, 200, 50],
        'time': [0, 100, 200],
        'class': [0, 1, 0]
    })
    X, y = preprocess(df)
    assert X.shape[0] == 3
    assert len(y) == 3
    assert not X.isnull().any().any()

def test_model_predictions():
    """Test model makes valid predictions"""
    model = joblib.load("models/model.pkl")
    X_test = pd.read_csv("data/test.csv")
    
    predictions = model.predict(X_test)
    
    # Verificar output shape
    assert len(predictions) == len(X_test)
    
    # Verificar valores válidos (0 o 1)
    assert all(p in [0, 1] for p in predictions)
    
    # Verificar performance mínima
    accuracy = accuracy_score(y_test, predictions)
    assert accuracy >= 0.85, f"Accuracy {accuracy} below threshold"

def test_model_latency():
    """Test inference speed"""
    model = joblib.load("models/model.pkl")
    X_sample = X_test.iloc[:100]
    
    import time
    start = time.time()
    model.predict(X_sample)
    latency = (time.time() - start) / 100
    
    assert latency < 0.01, f"Latency {latency}s exceeds 10ms"

@pytest.mark.parametrize("input_data,expected", [
    ({"amount": 100, "time": 0}, 0),
    ({"amount": 10000, "time": 50}, 1),
])
def test_edge_cases(input_data, expected):
    """Test edge cases"""
    model = joblib.load("models/model.pkl")
    X = pd.DataFrame([input_data])
    pred = model.predict(X)[0]
    assert pred == expected

# src/api.py - FastAPI serving
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import mlflow.sklearn

app = FastAPI(title="Fraud Detection API")

# Cargar modelo al startup
@app.on_event("startup")
def load_model():
    global model
    # Opción 1: Desde archivo
    model = joblib.load("models/model.pkl")
    
    # Opción 2: Desde MLflow
    # model = mlflow.sklearn.load_model("models:/FraudDetector/Production")

class Transaction(BaseModel):
    amount: float
    time: int
    v1: float
    v2: float
    # ... más features

@app.post("/predict")
def predict(transaction: Transaction):
    """Predict fraud probability"""
    features = [[
        transaction.amount,
        transaction.time,
        transaction.v1,
        transaction.v2
    ]]
    
    prediction = model.predict(features)[0]
    probability = model.predict_proba(features)[0][1]
    
    return {
        "is_fraud": bool(prediction),
        "fraud_probability": float(probability)
    }

@app.get("/health")
def health():
    return {"status": "healthy", "model_loaded": model is not None}

from evidently import ColumnMapping
from evidently.report import Report
from evidently.metrics import DataDriftTable, DatasetDriftMetric

def detect_drift(reference_data, current_data):
    """Detectar drift en features"""
    
    report = Report(metrics=[
        DataDriftTable(),
        DatasetDriftMetric()
    ])
    
    report.run(
        reference_data=reference_data,
        current_data=current_data
    )
    
    drift_report = report.as_dict()
    
    if drift_report['metrics'][1]['result']['dataset_drift']:
        print("⚠️ Data drift detectado!")
        drifted_features = [
            col for col, metrics in drift_report['metrics'][0]['result']['drift_by_columns'].items()
            if metrics['drift_detected']
        ]
        print(f"Features con drift: {drifted_features}")
        
        # Trigger retraining
        trigger_retraining_pipeline()
    
    return drift_report

from prometheus_client import Counter, Histogram, Gauge
import time

# Métricas Prometheus
prediction_counter = Counter('predictions_total', 'Total predictions made')
prediction_latency = Histogram('prediction_latency_seconds', 'Prediction latency')
fraud_rate = Gauge('fraud_rate', 'Current fraud detection rate')

@app.post("/predict")
def predict(transaction: Transaction):
    # Medir latency
    start_time = time.time()
    
    # Hacer predicción
    prediction = model.predict([transaction.dict().values()])[0]
    
    # Actualizar métricas
    prediction_counter.inc()
    prediction_latency.observe(time.time() - start_time)
    
    if prediction == 1:
        fraud_rate.inc()
    
    return {"is_fraud": bool(prediction)}

import logging
import json
from datetime import datetime

class JSONFormatter(logging.Formatter):
    def format(self, record):
        log_data = {
            "timestamp": datetime.utcnow().isoformat(),
            "level": record.levelname,
            "message": record.getMessage(),
            "module": record.module,
            "function": record.funcName
        }
        return json.dumps(log_data)

logger = logging.getLogger(__name__)
handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())
logger.addHandler(handler)

@app.post("/predict")
def predict(transaction: Transaction):
    logger.info("Prediction request", extra={
        "transaction_id": transaction.id,
        "amount": transaction.amount
    })
    
    prediction = model.predict(...)
    
    logger.info("Prediction made", extra={
        "transaction_id": transaction.id,
        "prediction": prediction,
        "latency_ms": latency
    })
    
    return {"prediction": prediction}

from feast import FeatureStore, Entity, FeatureView, Field
from feast.types import Int64, Float32
from datetime import timedelta

# Definir entity
user = Entity(
    name="user",
    join_keys=["user_id"]
)

# Definir feature view
user_features = FeatureView(
    name="user_transaction_features",
    entities=[user],
    ttl=timedelta(days=1),
    schema=[
        Field(name="avg_transaction_amount", dtype=Float32),
        Field(name="transaction_count_7d", dtype=Int64),
        Field(name="max_transaction_amount", dtype=Float32)
    ],
    source=BigQuerySource(
        table="project.dataset.user_features"
    )
)

# Usar en training
fs = FeatureStore(".")
features = fs.get_historical_features(
    entity_df=training_data,
    features=[
        "user_transaction_features:avg_transaction_amount",
        "user_transaction_features:transaction_count_7d"
    ]
).to_df()

# Usar en inference (online serving)
features = fs.get_online_features(
    features=[
        "user_transaction_features:avg_transaction_amount"
    ],
    entity_rows=[{"user_id": 12345}]
).to_dict()

# requirements.txt con versiones fijas
numpy==1.24.3
scikit-learn==1.3.0
pandas==2.0.3

# Seed para reproducibilidad
np.random.seed(42)
random.seed(42)

# Guardar environment info
import platform
info = {
    "python_version": platform.python_version(),
    "packages": {pkg.key: pkg.version for pkg in pkg_resources.working_set}
}
mlflow.log_dict(info, "environment.json")

import random

def get_model_version(user_id):
    """Route 10% traffic to new model"""
    if hash(user_id) % 100 < 10:
        return "v2-challenger"
    return "v1-champion"

@app.post("/predict")
def predict(transaction: Transaction):
    model_version = get_model_version(transaction.user_id)
    model = models[model_version]
    
    prediction = model.predict(...)
    
    # Log for analysis
    mlflow.log_metric(f"{model_version}_prediction", prediction)
    
    return {"prediction": prediction}

def saludo(nombre):
    """Función de ejemplo en Python"""
    print(f"¡Hola, {nombre}!")
    
saludo("Mundo")

# Full fine-tuning de LLaMA-7B
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")

# Problema:
# - 7B parámetros × 4 bytes = 28 GB solo del modelo
# - + Gradientes (28 GB) + Optimizer states (56 GB) = 112 GB VRAM total
# - Training time: ~40 horas en 8x A100
# - Costo: ~$500-1000

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset
import torch

# 1. Cargar modelo base
model_name = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_8bit=True,  # Cuantización para ahorrar memoria
    device_map="auto",
    torch_dtype=torch.float16
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 2. Configurar LoRA
lora_config = LoraConfig(
    r=16,                    # Rank (dimensión del low-rank)
    lora_alpha=32,           # Scaling factor (típ. 2×r)
    target_modules=[         # Qué layers modificar
        "q_proj",            # Query projection
        "k_proj",            # Key projection
        "v_proj",            # Value projection
        "o_proj"             # Output projection
    ],
    lora_dropout=0.05,       # Dropout para regularización
    bias="none",             # No entrenar bias
    task_type="CAUSAL_LM"    # Tipo de tarea
)

# 3. Preparar modelo para training
model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)

# Verificar parámetros entrenables
model.print_trainable_parameters()
# Output: trainable params: 8.4M || all params: 6.74B || trainable%: 0.124%

# 4. Cargar dataset
dataset = load_dataset("json", data_files="training_data.json")

def format_instruction(example):
    """Formato tipo Alpaca"""
    return f"""### Instruction:
{example['instruction']}

### Input:
{example['input']}

### Response:
{example['output']}"""

def tokenize_function(examples):
    texts = [format_instruction(ex) for ex in examples]
    return tokenizer(
        texts,
        truncation=True,
        max_length=2048,
        padding="max_length"
    )

tokenized_dataset = dataset.map(tokenize_function, batched=True)

# 5. Training arguments
training_args = TrainingArguments(
    output_dir="./lora_results",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_steps=100,
    evaluation_strategy="steps",
    eval_steps=100,
    warmup_steps=100,
    optim="adamw_torch"
)

# 6. Entrenar
from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"],
    eval_dataset=tokenized_dataset["validation"]
)

trainer.train()

# 7. Guardar adaptadores LoRA (solo 16-32 MB!)
model.save_pretrained("./lora_adapter")
tokenizer.save_pretrained("./lora_adapter")

from transformers import BitsAndBytesConfig

# Configurar cuantización 4-bit
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",           # Normal Float 4
    bnb_4bit_use_double_quant=True,      # Double quantization
    bnb_4bit_compute_dtype=torch.bfloat16
)

# Cargar modelo cuantizado
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=bnb_config,
    device_map="auto"
)

# Resultado:
# - LLaMA-7B en 4-bit: ~4.5 GB VRAM
# - + LoRA adapters: ~500 MB
# - Total: ~5 GB VRAM (puedes fine-tunear en una RTX 3090!)

# r = rank de las matrices low-rank
# Trade-off: performance vs memory

configs = {
    "tiny": LoraConfig(r=8),      # ~4M params, menos expresivo
    "small": LoraConfig(r=16),    # ~8M params, balance óptimo
    "medium": LoraConfig(r=32),   # ~16M params, más expresivo
    "large": LoraConfig(r=64)     # ~32M params, casi full fine-tuning
}

# Recomendación: empezar con r=16, subir si no converge

# Scaling factor: ΔW × (α/r)
# Controla la "fuerza" de los adapters

lora_config = LoraConfig(
    r=16,
    lora_alpha=32  # Típicamente α = 2×r (estándar)
)

# α < 2r: adapters más sutiles (menos overfitting)
# α = 2r: balance recomendado
# α > 2r: adapters más agresivos (útil para datasets pequeños)

# ¿Qué layers modificar con LoRA?

# Opción 1: Solo attention (más eficiente)
target_modules = ["q_proj", "v_proj"]

# Opción 2: Todas las proyecciones de attention (recomendado)
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]

# Opción 3: Attention + FFN (máximo performance)
target_modules = [
    "q_proj", "k_proj", "v_proj", "o_proj",
    "gate_proj", "up_proj", "down_proj"
]

# Trade-off: más modules = mejor performance pero más VRAM

from peft import PeftModel

# 1. Cargar modelo base
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    load_in_8bit=True,
    device_map="auto"
)

# 2. Cargar adaptadores LoRA
model = PeftModel.from_pretrained(base_model, "./lora_adapter")

# 3. Generar texto
tokenizer = AutoTokenizer.from_pretrained("./lora_adapter")
inputs = tokenizer("### Instruction: Explica qué es LoRA\n\n### Response:", return_tensors="pt")
outputs = model.generate(**inputs, max_length=512)
print(tokenizer.decode(outputs[0]))

# 4. (Opcional) Merge adapters con modelo base para deployment
model = model.merge_and_unload()
model.save_pretrained("./merged_model")

from peft import PrefixTuningConfig

config = PrefixTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=20,  # Tokens "virtuales" prepended
    encoder_hidden_size=4096
)

# Entrena embeddings virtuales en lugar de pesos del modelo

from peft import PromptTuningConfig

config = PromptTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=8,
    prompt_tuning_init="TEXT",
    prompt_tuning_init_text="Classify if the sentiment is positive or negative:"
)

# Similar a prefix tuning pero más simple

from peft import AdaLoraConfig

config = AdaLoraConfig(
    r=8,
    target_r=4,  # Rank objetivo dinámico
    init_r=12,   # Rank inicial
    tinit=200,   # Steps para adaptar rank
    tfinal=1000
)

# Ajusta automáticamente el rank durante training

def prepare_instruction_dataset(examples):
    """
    Formato Alpaca para instruction following
    """
    formatted = []
    for ex in examples:
        text = f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
{ex['instruction']}

### Input:
{ex['input'] if 'input' in ex else ''}

### Response:
{ex['output']}"""
        formatted.append(text)
    return formatted

# Ejemplo de dataset JSON
training_data = [
    {
        "instruction": "Explica qué es machine learning",
        "input": "",
        "output": "Machine learning es una rama de la IA que..."
    },
    {
        "instruction": "Traduce al español",
        "input": "Hello world",
        "output": "Hola mundo"
    }
]

from transformers import TrainerCallback
import wandb

class LoRAMetricsCallback(TrainerCallback):
    def on_log(self, args, state, control, logs=None, **kwargs):
        if logs:
            # Log a Weights & Biases
            wandb.log({
                "train_loss": logs.get("loss"),
                "learning_rate": logs.get("learning_rate"),
                "epoch": logs.get("epoch")
            })
            
            # Verificar overfitting
            if "eval_loss" in logs and "loss" in logs:
                gap = logs["loss"] - logs["eval_loss"]
                if gap > 0.5:
                    print("⚠️ Posible overfitting detectado")

# Agregar al trainer
training_args.callbacks = [LoRAMetricsCallback()]

# Full fine-tuning: 5e-6 típico
# LoRA: 10-100× más alto

learning_rates = {
    "conservative": 1e-4,  # Datasets grandes
    "standard": 2e-4,      # Recomendado
    "aggressive": 5e-4     # Datasets pequeños
}

# Effective batch size = per_device × accumulation × num_gpus

training_args = TrainingArguments(
    per_device_train_batch_size=2,  # Lo que cabe en VRAM
    gradient_accumulation_steps=8,   # Accumular gradientes
    # Effective batch size = 2 × 8 × 1 = 16
)

# Warmup evita inestabilidad inicial

training_args = TrainingArguments(
    warmup_steps=100,  # O warmup_ratio=0.1
    # LR gradualmente de 0 → max_lr en primeros 100 steps
)

# Fine-tune LLaMA-7B para responder preguntas médicas

# 1. Dataset
medical_data = load_dataset("medmcqa")

# 2. Configuración QLoRA
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    load_in_4bit=True,
    device_map="auto"
)

lora_config = LoraConfig(
    r=32,  # Rank más alto para dominio específico
    lora_alpha=64,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.1
)

# 3. Entrenar 3 epochs
trainer.train()

# Resultado:
# - Accuracy: 68% → 84% (+16%)
# - Training time: 4 horas en 1× RTX 4090
# - Costo: ~$5

# Ejemplo simple con scikit-learn
from sklearn.linear_model import LinearRegression
import numpy as np

# Datos de entrenamiento
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

# Crear y entrenar el modelo
model = LinearRegression()
model.fit(X, y)

# Hacer predicciones
prediction = model.predict([[6]])
print(f"Predicción: {prediction}")

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import DirectoryLoader

class RAGSystem:
    def __init__(self, docs_path, model_name="gpt-3.5-turbo"):
        self.embeddings = OpenAIEmbeddings()
        self.llm = OpenAI(model_name=model_name, temperature=0)
        self.vectorstore = None
        self.qa_chain = None
        
        # Cargar y procesar documentos
        self.load_documents(docs_path)
        
    def load_documents(self, docs_path):
        # 1. Cargar documentos
        loader = DirectoryLoader(docs_path, glob="**/*.txt")
        documents = loader.load()
        
        # 2. Split en chunks (chunking strategy)
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            length_function=len
        )
        chunks = text_splitter.split_documents(documents)
        
        # 3. Crear embeddings y almacenar en vector DB
        self.vectorstore = Chroma.from_documents(
            documents=chunks,
            embedding=self.embeddings,
            persist_directory="./chroma_db"
        )
        
        # 4. Crear cadena de Q&A
        self.qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            chain_type="stuff",
            retriever=self.vectorstore.as_retriever(
                search_kwargs={"k": 4}  # Top 4 documentos
            ),
            return_source_documents=True
        )
        
    def query(self, question):
        result = self.qa_chain({"query": question})
        return {
            "answer": result["result"],
            "sources": result["source_documents"]
        }

# Uso
rag = RAGSystem("./knowledge_base")
response = rag.query("¿Cómo funcionan los transformers?")
print(response["answer"])

from langchain.document_loaders import (
    TextLoader,
    PDFLoader,
    UnstructuredMarkdownLoader,
    CSVLoader
)

# Diferentes tipos de documentos
loaders = {
    "txt": TextLoader("docs/file.txt"),
    "pdf": PDFLoader("docs/file.pdf"),
    "md": UnstructuredMarkdownLoader("docs/file.md"),
    "csv": CSVLoader("data/file.csv")
}

# Cargar todos
documents = []
for loader in loaders.values():
    documents.extend(loader.load())

from langchain.text_splitter import (
    RecursiveCharacterTextSplitter,
    TokenTextSplitter,
    CharacterTextSplitter
)

# Estrategia 1: Por caracteres con overlap
char_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", " ", ""]
)

# Estrategia 2: Por tokens (mejor para LLMs)
token_splitter = TokenTextSplitter(
    chunk_size=256,
    chunk_overlap=50
)

# Estrategia 3: Semantic chunking (por significado)
from langchain.text_splitter import SemanticChunker

semantic_splitter = SemanticChunker(
    embeddings=OpenAIEmbeddings(),
    breakpoint_threshold_type="percentile"  # O "standard_deviation"
)

chunks = semantic_splitter.split_documents(documents)

from sentence_transformers import SentenceTransformer
import numpy as np

class EmbeddingModel:
    def __init__(self, model_name="all-MiniLM-L6-v2"):
        self.model = SentenceTransformer(model_name)
        
    def embed_documents(self, texts):
        """Convierte textos en vectores densos"""
        embeddings = self.model.encode(texts, convert_to_numpy=True)
        return embeddings
    
    def embed_query(self, query):
        """Embedding para la query"""
        return self.model.encode(query, convert_to_numpy=True)
    
    def cosine_similarity(self, vec1, vec2):
        """Similitud coseno entre vectores"""
        return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

# Ejemplo
embedder = EmbeddingModel()

# Embeddings de documentos
docs = ["Transformers usan self-attention", "BERT es un encoder"]
doc_embeddings = embedder.embed_documents(docs)

# Embedding de query
query = "¿Qué es self-attention?"
query_embedding = embedder.embed_query(query)

# Calcular similitud
similarities = [
    embedder.cosine_similarity(query_embedding, doc_emb)
    for doc_emb in doc_embeddings
]
print(similarities)  # [0.78, 0.42]

import chromadb
from chromadb.config import Settings

class VectorStore:
    def __init__(self, collection_name="knowledge_base"):
        self.client = chromadb.Client(Settings(
            chroma_db_impl="duckdb+parquet",
            persist_directory="./chroma_storage"
        ))
        self.collection = self.client.get_or_create_collection(
            name=collection_name,
            metadata={"hnsw:space": "cosine"}  # Métrica de distancia
        )
        
    def add_documents(self, texts, metadatas=None, ids=None):
        """Agregar documentos al vector store"""
        self.collection.add(
            documents=texts,
            metadatas=metadatas,
            ids=ids if ids else [f"doc_{i}" for i in range(len(texts))]
        )
        
    def search(self, query, k=5):
        """Búsqueda por similitud"""
        results = self.collection.query(
            query_texts=[query],
            n_results=k,
            include=["documents", "metadatas", "distances"]
        )
        return results
    
    def search_with_filter(self, query, filter_dict, k=5):
        """Búsqueda con filtros de metadata"""
        results = self.collection.query(
            query_texts=[query],
            n_results=k,
            where=filter_dict  # e.g., {"category": "deep-learning"}
        )
        return results

# Uso
vectorstore = VectorStore()
vectorstore.add_documents(
    texts=["Transformers revolucionaron NLP", "GPT-3 tiene 175B parámetros"],
    metadatas=[{"category": "nlp"}, {"category": "llm"}],
    ids=["doc1", "doc2"]
)

results = vectorstore.search("¿Qué es GPT-3?", k=2)
print(results)

# Búsqueda por similitud de embeddings
results = vectorstore.similarity_search(query, k=4)

from rank_bm25 import BM25Okapi

class BM25Retriever:
    def __init__(self, documents):
        self.documents = documents
        tokenized_docs = [doc.split() for doc in documents]
        self.bm25 = BM25Okapi(tokenized_docs)
        
    def retrieve(self, query, k=5):
        tokenized_query = query.split()
        scores = self.bm25.get_scores(tokenized_query)
        top_k_indices = np.argsort(scores)[::-1][:k]
        return [self.documents[i] for i in top_k_indices]

def hybrid_search(query, alpha=0.5):
    """
    Combina vector search y BM25
    alpha: peso de vector search (0-1)
    """
    # Dense retrieval
    dense_results = vectorstore.search(query, k=10)
    dense_scores = {doc.id: 1 - dist for doc, dist in dense_results}
    
    # Sparse retrieval (BM25)
    sparse_results = bm25_retriever.retrieve(query, k=10)
    sparse_scores = {doc.id: score for doc, score in sparse_results}
    
    # Combinar scores
    all_doc_ids = set(dense_scores.keys()) | set(sparse_scores.keys())
    hybrid_scores = {}
    
    for doc_id in all_doc_ids:
        dense_score = dense_scores.get(doc_id, 0)
        sparse_score = sparse_scores.get(doc_id, 0)
        hybrid_scores[doc_id] = alpha * dense_score + (1 - alpha) * sparse_score
    
    # Ordenar por score
    sorted_docs = sorted(hybrid_scores.items(), key=lambda x: x[1], reverse=True)
    return sorted_docs[:5]

from sentence_transformers import CrossEncoder

class Reranker:
    def __init__(self, model_name="cross-encoder/ms-marco-MiniLM-L-6-v2"):
        self.model = CrossEncoder(model_name)
        
    def rerank(self, query, documents, top_k=3):
        """
        Reranquear documentos usando un modelo de cross-encoder
        Más preciso que cosine similarity pero más lento
        """
        # Crear pares (query, doc)
        pairs = [[query, doc] for doc in documents]
        
        # Calcular scores de relevancia
        scores = self.model.predict(pairs)
        
        # Ordenar por score
        ranked_indices = np.argsort(scores)[::-1][:top_k]
        return [documents[i] for i in ranked_indices]

# Pipeline completo
def retrieve_and_rerank(query):
    # 1. Initial retrieval (k=20)
    candidates = vectorstore.search(query, k=20)
    
    # 2. Rerank top 20 → top 3
    reranker = Reranker()
    final_docs = reranker.rerank(query, candidates, top_k=3)
    
    return final_docs

def create_rag_prompt(query, context_docs):
    """
    Crear prompt optimizado para RAG
    """
    context = "\n\n".join([
        f"Documento {i+1}:\n{doc}"
        for i, doc in enumerate(context_docs)
    ])
    
    prompt = f"""Eres un asistente que responde preguntas basándote SOLO en el contexto proporcionado.

CONTEXTO:
{context}

PREGUNTA: {query}

INSTRUCCIONES:
1. Responde SOLO usando información del contexto
2. Si la respuesta no está en el contexto, di "No tengo información suficiente"
3. Cita el número de documento que usaste
4. Sé conciso y preciso

RESPUESTA:"""
    
    return prompt

# Uso
query = "¿Cómo funciona self-attention?"
docs = retrieve_and_rerank(query)
prompt = create_rag_prompt(query, docs)
answer = llm.generate(prompt)

def transform_query(original_query):
    """
    Transforma query para mejorar retrieval
    """
    transformations = {
        "expansion": f"Genera 3 variaciones de esta pregunta: {original_query}",
        "decomposition": f"Descompón esta pregunta compleja en sub-preguntas: {original_query}",
        "abstraction": f"Reformula esta pregunta de manera más general: {original_query}"
    }
    
    # Usar LLM para transformar
    expanded_queries = llm.generate(transformations["expansion"])
    
    # Buscar con múltiples queries
    all_results = []
    for query in expanded_queries:
        results = vectorstore.search(query, k=3)
        all_results.extend(results)
    
    # Deduplicate y rankear
    unique_results = list(set(all_results))
    return unique_results

class ParentDocumentRetriever:
    """
    Guarda chunks pequeños para búsqueda, pero devuelve chunks padres más grandes
    """
    def __init__(self, parent_splitter, child_splitter):
        self.parent_chunks = {}
        self.child_to_parent = {}
        
    def index_documents(self, documents):
        # Split en chunks grandes (parents)
        parent_docs = self.parent_splitter.split_documents(documents)
        
        # Split cada parent en chunks pequeños (children)
        for parent_id, parent_doc in enumerate(parent_docs):
            self.parent_chunks[parent_id] = parent_doc
            
            child_docs = self.child_splitter.split_documents([parent_doc])
            for child_doc in child_docs:
                self.child_to_parent[child_doc.id] = parent_id
                vectorstore.add_documents([child_doc])
    
    def retrieve(self, query, k=3):
        # Buscar en child chunks
        child_results = vectorstore.search(query, k=k*2)
        
        # Devolver parent chunks únicos
        parent_ids = set([self.child_to_parent[child.id] for child in child_results])
        return [self.parent_chunks[pid] for pid in parent_ids][:k]

def self_rag(query, max_iterations=3):
    """
    RAG con auto-reflexión para mejorar respuestas
    """
    for i in range(max_iterations):
        # 1. Retrieve
        docs = vectorstore.search(query, k=3)
        
        # 2. Generate
        answer = generate_answer(query, docs)
        
        # 3. Critique (auto-evaluación)
        critique_prompt = f"""
        Query: {query}
        Answer: {answer}
        
        ¿Esta respuesta es completa y precisa? ¿Qué falta?
        Responde: [COMPLETA] o [INCOMPLETA: razón]
        """
        critique = llm.generate(critique_prompt)
        
        # 4. Si completa, terminar
        if "[COMPLETA]" in critique:
            return answer
        
        # 5. Si no, refinar query
        refine_prompt = f"Reformula esta query para obtener mejor información: {query}\nProblema: {critique}"
        query = llm.generate(refine_prompt)
    
    return answer

from ragas import evaluate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_relevancy,
    context_recall
)

# Crear dataset de evaluación
eval_dataset = {
    "question": ["¿Qué es RAG?", "¿Cómo funciona retrieval?"],
    "answer": [answer1, answer2],
    "contexts": [contexts1, contexts2],
    "ground_truth": [gt1, gt2]
}

# Evaluar
results = evaluate(
    dataset=eval_dataset,
    metrics=[
        faithfulness,        # ¿Respuesta fiel al contexto?
        answer_relevancy,    # ¿Respuesta relevante a la pregunta?
        context_relevancy,   # ¿Contexto relevante?
        context_recall       # ¿Recuperó todo el contexto necesario?
    ]
)

print(results)

import hashlib
import pickle

class EmbeddingCache:
    def __init__(self, cache_file="embeddings_cache.pkl"):
        self.cache_file = cache_file
        self.cache = self.load_cache()
        
    def load_cache(self):
        try:
            with open(self.cache_file, 'rb') as f:
                return pickle.load(f)
        except FileNotFoundError:
            return {}
    
    def save_cache(self):
        with open(self.cache_file, 'wb') as f:
            pickle.dump(self.cache, f)
    
    def get_embedding(self, text, embedder):
        # Hash del texto
        text_hash = hashlib.md5(text.encode()).hexdigest()
        
        if text_hash in self.cache:
            return self.cache[text_hash]
        
        # Calcular embedding
        embedding = embedder.embed_query(text)
        self.cache[text_hash] = embedding
        self.save_cache()
        
        return embedding

def smart_chunking(document, max_chunk_size=1000):
    """
    Chunking que respeta estructura del documento
    """
    # Detectar secciones
    sections = document.split("\n##")  # Headers de markdown
    
    chunks = []
    for section in sections:
        if len(section) <= max_chunk_size:
            chunks.append(section)
        else:
            # Split subsections
            subsections = section.split("\n###")
            for subsection in subsections:
                if len(subsection) <= max_chunk_size:
                    chunks.append(subsection)
                else:
                    # Split por párrafos
                    paragraphs = subsection.split("\n\n")
                    current_chunk = ""
                    for para in paragraphs:
                        if len(current_chunk) + len(para) <= max_chunk_size:
                            current_chunk += para + "\n\n"
                        else:
                            chunks.append(current_chunk)
                            current_chunk = para + "\n\n"
                    
                    if current_chunk:
                        chunks.append(current_chunk)
    
    return chunks

# Agregar metadata rica
vectorstore.add_documents(
    texts=chunks,
    metadatas=[{
        "source": "paper_transformer.pdf",
        "page": 3,
        "section": "Architecture",
        "date": "2017-06-12",
        "author": "Vaswani et al.",
        "topic": "deep-learning"
    } for chunk in chunks]
)

# Buscar con filtros
results = vectorstore.search(
    query="self-attention mechanism",
    filter={"topic": "deep-learning", "date": {"$gte": "2017-01-01"}},
    k=5
)

# Ejemplo simplificado de atención
import torch
import torch.nn as nn

class SelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(SelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads
        
        # Matrices de transformación
        self.values = nn.Linear(embed_size, embed_size)
        self.keys = nn.Linear(embed_size, embed_size)
        self.queries = nn.Linear(embed_size, embed_size)
        self.fc_out = nn.Linear(embed_size, embed_size)
    
    def forward(self, values, keys, query, mask):
        N = query.shape[0]
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]
        
        # Calcular atención
        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))
        
        attention = torch.softmax(energy / (self.embed_size ** (1/2)), dim=3)
        out = torch.einsum("nhql,nlhd->nqhd", [attention, values])
        
        return out

class Transformer(nn.Module):
    def __init__(self, d_model=512, nhead=8, num_layers=6):
        super().__init__()
        self.encoder = TransformerEncoder(num_layers)
        self.decoder = TransformerDecoder(num_layers)
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.positional_encoding = PositionalEncoding(d_model)
        
    def forward(self, src, tgt):
        # Embedding + Positional Encoding
        src = self.positional_encoding(self.embedding(src))
        tgt = self.positional_encoding(self.embedding(tgt))
        
        # Encoder -> Decoder
        memory = self.encoder(src)
        output = self.decoder(tgt, memory)
        return output

import torch
import torch.nn as nn
import math

class SelfAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        self.head_dim = d_model // num_heads
        
        # Linear projections
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
        
    def forward(self, x, mask=None):
        batch_size, seq_len, d_model = x.shape
        
        # Linear projections in batch from d_model => h x d_k
        Q = self.W_q(x).view(batch_size, seq_len, self.num_heads, self.head_dim)
        K = self.W_k(x).view(batch_size, seq_len, self.num_heads, self.head_dim)
        V = self.W_v(x).view(batch_size, seq_len, self.num_heads, self.head_dim)
        
        # Transpose for attention: (batch, num_heads, seq_len, head_dim)
        Q = Q.transpose(1, 2)
        K = K.transpose(1, 2)
        V = V.transpose(1, 2)
        
        # Scaled Dot-Product Attention
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.head_dim)
        
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        
        attention_weights = torch.softmax(scores, dim=-1)
        attention_output = torch.matmul(attention_weights, V)
        
        # Concatenate heads
        attention_output = attention_output.transpose(1, 2).contiguous()
        attention_output = attention_output.view(batch_size, seq_len, d_model)
        
        # Final linear projection
        output = self.W_o(attention_output)
        return output, attention_weights

# 8 heads con d_model=512 => cada head procesa 64 dimensiones
num_heads = 8
d_model = 512
head_dim = d_model // num_heads  # 64

# Ventajas:
# 1. Captura diferentes representaciones
# 2. Permite al modelo atender a diferentes posiciones simultáneamente
# 3. Aprende patrones complementarios

import numpy as np

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super().__init__()
        
        # Crear matriz de positional encodings
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        
        # Fórmula del paper original
        div_term = torch.exp(
            torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
        )
        
        pe[:, 0::2] = torch.sin(position * div_term)  # Posiciones pares
        pe[:, 1::2] = torch.cos(position * div_term)  # Posiciones impares
        
        pe = pe.unsqueeze(0)  # (1, max_len, d_model)
        self.register_buffer('pe', pe)
        
    def forward(self, x):
        # x shape: (batch_size, seq_len, d_model)
        x = x + self.pe[:, :x.size(1), :]
        return x