Fundamentos de IA, Machine Learning y Produccion

# En entrevista, demuestra que entiendes la jerarquia con EJEMPLOS concretos.
#
# IA:           Cualquier sistema inteligente.
#               - Ej: un termostato con reglas if-else (clasico "symbolic AI")
#
# ML:           Sistemas que aprenden de datos.
#               - Ej: un modelo de prediccion de churn
#
# DL:           Redes neuronales profundas (> 5 capas tipicamente).
#               - Ej: una CNN que clasifica imagenes de radiografias
#
# Generativa:   Crea contenido nuevo.
#               - Ej: Stable Diffusion genera imagenes a partir de texto
#
# LLM:          Modelo de lenguaje grande.
#               - Ej: GPT-4, Claude 3, Gemini, LLaMA 3

import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin

class InteractionFeatures(BaseEstimator, TransformerMixin):
    """Crea features de interaccion entre columnas. Encaja en un Pipeline."""

    def __init__(self, interaction_cols=None):
        self.interaction_cols = interaction_cols

    def fit(self, X, y=None):
        return self  # no aprende nada

    def transform(self, X):
        X = pd.DataFrame(X, columns=self.interaction_cols) if isinstance(X, np.ndarray) else X.copy()
        cols = self.interaction_cols or X.columns.tolist()
        for i, c1 in enumerate(cols):
            for c2 in cols[i+1:]:
                X[f'{c1}_x_{c2}'] = X[c1] * X[c2]
        return X

class LogTransformer(BaseEstimator, TransformerMixin):
    """Aplica np.log1p a columnas especificas."""

    def __init__(self, cols=None):
        self.cols = cols

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        X = X.copy()
        for c in self.cols:
            X[c] = np.log1p(X[c])
        return X

# Uso en un Pipeline:
# from sklearn.pipeline import Pipeline
# pipe = Pipeline([
#     ('log',     LogTransformer(cols=['tarifa', 'precio'])),
#     ('scaler',  StandardScaler()),
#     ('inter',   InteractionFeatures(interaction_cols=['edad', 'ingreso'])),
#     ('model',   RandomForestClassifier())
# ])

# pip install optuna
import optuna
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

data = load_breast_cancer()
X, y = data.data, data.target

def objetivo(trial):
    """Funcion que Optuna minimiza (o maximiza con direction='maximize')."""
    params = {
        'n_estimators':      trial.suggest_int('n_estimators', 50, 500),
        'max_depth':         trial.suggest_int('max_depth', 3, 20),
        'min_samples_leaf':  trial.suggest_int('min_samples_leaf', 1, 50),
        'max_features':      trial.suggest_categorical('max_features', ['sqrt', 'log2', None]),
    }
    pipe = Pipeline([
        ('scaler', StandardScaler()),
        ('model', RandomForestClassifier(**params, random_state=42, n_jobs=-1))
    ])
    cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
    return cross_val_score(pipe, X, y, cv=cv, scoring='roc_auc', n_jobs=-1).mean()

# Crear estudio con early stopping
study = optuna.create_study(
    direction='maximize',
    pruner=optuna.pruners.MedianPruner()  # corta trials que van mal
)
study.optimize(
    objetivo,
    n_trials=50,           # maximo de trials
    timeout=300,           # o 5 minutos, lo que llegue primero
    show_progress_bar=False
)

print(f"Mejor AUC: {study.best_value:.4f}")
print(f"Mejores hiperparametros: {study.best_params}")
print(f"Trials completados: {len(study.trials)}")

import os
import random
import numpy as np
import torch  # si usas deep learning
import tensorflow as tf  # si usas TF

# 1) PYTHONHASHSEED (importante para dicts, sets)
os.environ['PYTHONHASHSEED'] = '42'

# 2) Python random
random.seed(42)

# 3) NumPy
np.random.seed(42)

# 4) PyTorch
torch.manual_seed(42)
torch.cuda.manual_seed_all(42)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

# 5) TensorFlow
tf.random.set_seed(42)

# 6) En sklearn: random_state=42 en TODOS los modelos y splits

# 7) requirements.txt
# numpy==1.24.3
# pandas==2.0.1
# scikit-learn==1.3.0
# matplotlib==3.7.1
# seaborn==0.12.2

# 8) Antes de entregar: Kernel → Restart & Run All
# Si falla, tienes un bug de orden de ejecucion.

# pip install fastapi uvicorn
# main.py
from fastapi import FastAPI
from pydantic import BaseModel, Field
import joblib
import numpy as np

app = FastAPI(title="DSBook Churn API", version="1.0.0")
model_data = joblib.load('churn_pipeline.joblib')
pipeline = model_data['pipeline']
metadata = model_data.get('metadata', {})

class Cliente(BaseModel):
    """Schema de entrada: valida automaticamente con Pydantic."""
    tenure:           int   = Field(..., ge=0, le=100, description="Meses como cliente")
    monthly_charges:  float = Field(..., ge=0)
    total_charges:    float = Field(..., ge=0)
    contract:         str   = Field(..., pattern="^(Mes a mes|1 anio|2 anios)$")
    internet:         str   = Field(..., pattern="^(Fibra|DSL|No)$")
    tech_support:     str   = Field(None, pattern="^(Si|No)$")

class Prediccion(BaseModel):
    probabilidad_churn: float
    prediccion:         str
    modelo:             str
    umbral:             float = 0.5

@app.get("/")
def root():
    return {
        "modelo":   metadata.get('modelo', 'desconocido'),
        "version":  app.version,
        "auc_test": metadata.get('auc_test'),
    }

@app.post("/predecir", response_model=Prediccion)
def predecir(cliente: Cliente):
    X = np.array([[
        cliente.tenure, cliente.monthly_charges, cliente.total_charges,
        cliente.contract, cliente.internet, cliente.tech_support
    ]], dtype=object)
    prueba = pipeline.predict_proba(X)[0, 1]
    return Prediccion(
        probabilidad_churn=float(prueba),
        prediccion="churn" if prueba >= 0.5 else "activo",
        modelo=metadata.get('modelo', 'churn_v1'),
    )

# Correr: uvicorn main:app --reload
# Documentacion automatica: http://localhost:8000/docs