MLZC25-04. Python para Machine Learning: Más que un Lenguaje de Programación

# Python - Claro como el agua
if edad >= 18 and tiene_licencia:
    puede_conducir = True
    print("¡Puedes manejar!")

// Java - Más verboso
if (edad >= 18 && tieneLicencia) {
    puedeConducir = true;
    System.out.println("¡Puedes manejar!");
}

# En 5 líneas puedes hacer análisis complejos
import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression

df = pd.read_csv('datos.csv')
modelo = LinearRegression().fit(df[['edad']], df['salario'])

# 1. Cargar datos
df = pd.read_csv('datos.csv')

# 2. Explorar (interactivo)
df.head()
df.info()
df.describe()

# 3. Visualizar (rápido)
df['edad'].hist()

# 4. Modelar (simple)
from sklearn.linear_model import LinearRegression
modelo = LinearRegression()
modelo.fit(df[['edad']], df['salario'])

# 5. Evaluar (directo)
from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_test, predicciones)

import numpy as np

# Arrays que son 100x más rápidos que listas de Python
datos = np.array([1, 2, 3, 4, 5])

# Operaciones vectorizadas (súper rápidas)
cuadrados = datos ** 2  # [1, 4, 9, 16, 25]
promedio = np.mean(datos)  # 3.0

# Álgebra lineal (fundamental para ML)
matriz = np.array([[1, 2], [3, 4]])
inversa = np.linalg.inv(matriz)

import pandas as pd

# Cargar datos como si fuera Excel
df = pd.read_csv('ventas.csv')

# Explorar como un detective
df.head()  # Primeras filas
df.info()  # Información del dataset
df.describe()  # Estadísticas descriptivas

# Filtrar y transformar fácilmente
ventas_alto = df[df['ventas'] > 1000]
df['ventas_mensuales'] = df['ventas'] / 12

# Agrupar y agregar
por_region = df.groupby('region')['ventas'].sum()

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Preparar datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Entrenar modelo (una línea)
modelo = LinearRegression().fit(X_train, y_train)

# Hacer predicciones (una línea)
predicciones = modelo.predict(X_test)

# Evaluar (una línea)
mse = mean_squared_error(y_test, predicciones)

import matplotlib.pyplot as plt

# Gráfico básico
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', label='Datos reales')
plt.plot(x, predicciones, 'r--', label='Predicciones')
plt.xlabel('Edad')
plt.ylabel('Salario')
plt.title('Predicción de Salario por Edad')
plt.legend()
plt.show()

import seaborn as sns

# Gráficos hermosos con poco código
sns.scatterplot(data=df, x='edad', y='salario', hue='genero')
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
sns.pairplot(df, hue='categoria')

def explorar_datos(archivo):
    """Patrón estándar para explorar cualquier dataset"""
    # Cargar
    df = pd.read_csv(archivo)

    # Información básica
    print(f"Forma: {df.shape}")
    print(f"Columnas: {df.columns.tolist()}")
    print(f"Tipos: {df.dtypes}")

    # Valores faltantes
    print(f"Valores faltantes:\n{df.isnull().sum()}")

    # Estadísticas
    print(f"Estadísticas:\n{df.describe()}")

    # Visualizaciones
    df.hist(figsize=(15, 10))
    plt.show()

    return df

def entrenar_modelo(X, y, tipo_modelo='regression'):
    """Patrón estándar para entrenar modelos"""
    # Dividir datos
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )

    # Elegir modelo
    if tipo_modelo == 'regression':
        modelo = LinearRegression()
    elif tipo_modelo == 'classification':
        modelo = LogisticRegression()

    # Entrenar
    modelo.fit(X_train, y_train)

    # Evaluar
    predicciones = modelo.predict(X_test)
    score = modelo.score(X_test, y_test)

    print(f"Score: {score:.3f}")
    return modelo, score

def validar_modelo(modelo, X, y, cv=5):
    """Validación cruzada estándar"""
    from sklearn.model_selection import cross_val_score

    scores = cross_val_score(modelo, X, y, cv=cv)

    print(f"Scores: {scores}")
    print(f"Promedio: {scores.mean():.3f} (+/- {scores.std() * 2:.3f})")

    return scores

# ❌ Malo
df1 = pd.read_csv('data.csv')
m1 = LinearRegression()
m1.fit(df1[['x']], df1['y'])

# ✅ Bueno
ventas_df = pd.read_csv('ventas_2023.csv')
modelo_salario = LinearRegression()
modelo_salario.fit(ventas_df[['experiencia']], ventas_df['salario'])

def preprocesar_datos(df, columnas_numericas):
    """
    Preprocesa datos para machine learning.

    Args:
        df (DataFrame): Dataset original
        columnas_numericas (list): Lista de columnas numéricas

    Returns:
        DataFrame: Dataset preprocesado
    """
    # Implementación aquí
    pass

def crear_grafico_correlacion(df, titulo="Correlación"):
    """Crea un heatmap de correlación"""
    plt.figure(figsize=(12, 8))
    sns.heatmap(df.corr(), annot=True, cmap='coolwarm', center=0)
    plt.title(titulo)
    plt.tight_layout()
    plt.show()

# ❌ Error
modelo.fit(X, y)  # X contiene NaN

# ✅ Solución
X_limpio = X.dropna()
y_limpio = y[X.index.isin(X_limpio.index)]
modelo.fit(X_limpio, y_limpio)

# ❌ Error
X = df['edad']  # 1D array
modelo.fit(X, y)

# ✅ Solución
X = df[['edad']]  # 2D array
modelo.fit(X, y)

# ❌ Error
df['nueva_columna']  # No existe

# ✅ Solución
if 'nueva_columna' in df.columns:
    print(df['nueva_columna'])
else:
    print("Columna no encontrada")

# ❌ Lento (loops de Python)
resultado = []
for i in range(len(datos)):
    resultado.append(datos[i] * 2)

# ✅ Rápido (NumPy vectorizado)
resultado = datos * 2  # 100x más rápido

# ❌ Desperdicio de memoria
df['categoria'] = df['categoria'].astype('object')

# ✅ Eficiente
df['categoria'] = df['categoria'].astype('category')