NumPy para Data Science: Análisis de Datos en la Práctica

¡Bienvenido al tutorial práctico de NumPy para Data Science! Aquí aprenderás a aplicar todas las técnicas de NumPy en escenarios reales de análisis de datos, desde la carga y limpieza de datos hasta la preparación para machine learning. Este tutorial te prepara para convertirte en un data scientist competente usando NumPy como herramienta fundamental.

Objetivo: Aprender a aplicar NumPy en flujos de trabajo reales de data science, incluyendo carga de datos, preprocesamiento, análisis exploratorio y preparación para machine learning.

Índice

• Carga y Exploración de Datos
• Limpieza y Preprocesamiento
• Análisis Exploratorio de Datos (EDA)
• Integración con Pandas
• Visualización Básica con Matplotlib
• Preparación de Datos para Machine Learning
• Análisis de Series Temporales
• Caso de Estudio - Análisis de Ventas
• Proyecto Práctico - Sistema de Recomendaciones
• Próximos Pasos
• Conclusión

Carga y Exploración de Datos

Aprende a cargar diferentes tipos de datos con NumPy:

import numpy as np

# Cargar datos desde archivo CSV
def cargar_datos_csv(ruta_archivo):
    """Carga datos desde un archivo CSV usando NumPy"""
    try:
        datos = np.loadtxt(ruta_archivo, delimiter=',', skiprows=1)
        print(f"Datos cargados exitosamente: {datos.shape}")
        return datos
    except Exception as e:
        print(f"Error al cargar datos: {e}")
        return None

# Crear datos de ejemplo para simular un dataset
def crear_dataset_ejemplo():
    """Crea un dataset simulado de ventas"""
    np.random.seed(42)

    # Generar datos
    n_registros = 1000

    # Fechas (días desde inicio)
    fechas = np.arange(n_registros)

    # Ventas (distribución normal con tendencia)
    tendencia = 0.1 * fechas
    ventas_base = np.random.normal(100, 20, n_registros)
    ventas = ventas_base + tendencia

    # Precios (distribución log-normal)
    precios = np.random.lognormal(3, 0.5, n_registros)

    # Categorías de productos (0-4)
    categorias = np.random.choice(5, n_registros)

    # Regiones (0-2)
    regiones = np.random.choice(3, n_registros)

    # Combinar en matriz
    dataset = np.column_stack([fechas, ventas, precios, categorias, regiones])

    return dataset

# Crear y explorar dataset
dataset = crear_dataset_ejemplo()
print("Dataset creado:")
print(f"Forma: {dataset.shape}")
print(f"Tipos de datos: {dataset.dtype}")
print("Primeras 5 filas:")
print(dataset[:5])

Exploración inicial de datos

def explorar_dataset(datos, nombres_columnas=None):
    """Realiza exploración inicial del dataset"""
    if nombres_columnas is None:
        nombres_columnas = [f'Col_{i}' for i in range(datos.shape[1])]

    print("=== EXPLORACIÓN INICIAL DEL DATASET ===")
    print(f"Dimensiones: {datos.shape[0]} filas x {datos.shape[1]} columnas")
    print(f"Tamaño en memoria: {datos.nbytes / 1024:.1f} KB")

    print("\nEstadísticas básicas por columna:")
    for i, nombre in enumerate(nombres_columnas):
        columna = datos[:, i]
        print(f"{nombre}:")
        print(f"  Media: {np.mean(columna):.2f}")
        print(f"  Desviación: {np.std(columna):.2f}")
        print(f"  Mín: {np.min(columna):.2f}")
        print(f"  Máx: {np.max(columna):.2f}")
        print(f"  Mediana: {np.median(columna):.2f}")
        print()

# Nombres descriptivos para las columnas
columnas = ['Dia', 'Ventas', 'Precio', 'Categoria', 'Region']
explorar_dataset(dataset, columnas)

Limpieza y Preprocesamiento

Técnicas para limpiar y preparar datos:

def limpiar_datos(datos):
    """Limpia y preprocesa los datos"""
    datos_limpios = datos.copy()

    print("=== LIMPIEZA DE DATOS ===")

    # 1. Manejar valores faltantes (simular con NaN)
    # En un caso real, usarías: np.isnan(datos)
    print("Verificando valores faltantes...")
    valores_faltantes = np.sum(np.isnan(datos_limpios))
    print(f"Valores faltantes encontrados: {valores_faltantes}")

    # 2. Eliminar outliers usando IQR
    print("\nEliminando outliers...")
    for i in range(datos_limpios.shape[1]):
        columna = datos_limpios[:, i]
        Q1 = np.percentile(columna, 25)
        Q3 = np.percentile(columna, 75)
        IQR = Q3 - Q1

        limite_inferior = Q1 - 1.5 * IQR
        limite_superior = Q3 + 1.5 * IQR

        mascara_outliers = (columna < limite_inferior) | (columna > limite_superior)
        n_outliers = np.sum(mascara_outliers)
        print(f"Columna {i}: {n_outliers} outliers encontrados")

        # Reemplazar outliers con la mediana
        if n_outliers > 0:
            mediana = np.median(columna[~mascara_outliers])
            columna[mascara_outliers] = mediana

    # 3. Normalización de datos
    print("\nNormalizando datos...")
    for i in range(datos_limpios.shape[1]):
        columna = datos_limpios[:, i]
        media = np.mean(columna)
        desviacion = np.std(columna)

        if desviacion > 0:  # Evitar división por cero
            datos_limpios[:, i] = (columna - media) / desviacion

    print("Datos normalizados (media ≈ 0, desviación ≈ 1)")

    return datos_limpios

# Aplicar limpieza
dataset_limpio = limpiar_datos(dataset)
print("\nPrimeras filas después de limpieza:")
print(dataset_limpio[:5])

Transformaciones de datos

def transformar_datos(datos):
    """Aplica transformaciones avanzadas a los datos"""
    datos_transformados = datos.copy()

    print("=== TRANSFORMACIONES DE DATOS ===")

    # 1. Transformaciones logarítmicas para datos sesgados
    precios = datos_transformados[:, 2]  # Columna de precios
    if np.min(precios) > 0:  # Solo si no hay valores negativos
        precios_log = np.log(precios)
        print("Transformación logarítmica aplicada a precios")

    # 2. Codificación one-hot para variables categóricas
    categorias = datos_transformados[:, 3].astype(int)
    n_categorias = len(np.unique(categorias))

    # Crear matriz one-hot
    one_hot = np.zeros((len(categorias), n_categorias))
    one_hot[np.arange(len(categorias)), categorias] = 1

    print(f"One-hot encoding aplicado: {n_categorias} categorías")

    # 3. Creación de features derivadas
    ventas = datos_transformados[:, 1]
    precios_promedio = np.mean(precios)

    # Feature: ventas por encima del promedio
    ventas_alto = (ventas > np.mean(ventas)).astype(int)

    # Feature: precio relativo
    precio_relativo = precios / precios_promedio

    print("Features derivadas creadas:")
    print(f"  - Ventas alto: {np.sum(ventas_alto)} registros")
    print(".2f")

    # Combinar todas las transformaciones
    features_derivadas = np.column_stack([ventas_alto, precio_relativo])

    return datos_transformados, features_derivadas, one_hot

# Aplicar transformaciones
datos_transformados, features_derivadas, one_hot = transformar_datos(dataset_limpio)
print(f"\nDimensiones finales: {datos_transformados.shape}")
print(f"Features derivadas: {features_derivadas.shape}")
print(f"One-hot encoding: {one_hot.shape}")

Análisis Exploratorio de Datos (EDA)

Análisis profundo para entender los datos:

def analisis_exploratorio(datos, columnas):
    """Realiza análisis exploratorio completo"""
    print("=== ANÁLISIS EXPLORATORIO DE DATOS ===")

    # 1. Matriz de correlación
    print("\nMatriz de correlación:")
    correlacion = np.corrcoef(datos.T)
    for i, col_i in enumerate(columnas):
        for j, col_j in enumerate(columnas):
            if i <= j:  # Solo triangular superior
                corr = correlacion[i, j]
                intensidad = "Fuerte" if abs(corr) > 0.7 else "Moderada" if abs(corr) > 0.3 else "Débil"
                print(".3f")

    # 2. Análisis por grupos
    print("\n=== ANÁLISIS POR CATEGORÍAS ===")
    categorias = datos[:, 3].astype(int)  # Columna de categorías

    for cat in np.unique(categorias):
        mascara_cat = categorias == cat
        datos_cat = datos[mascara_cat]

        print(f"\nCategoría {cat}:")
        print(f"  Registros: {len(datos_cat)}")
        print(".2f")
        print(".2f")
        print(".2f")

    # 3. Análisis de distribución
    print("\n=== ANÁLISIS DE DISTRIBUCIÓN ===")
    for i, col in enumerate(columnas):
        columna = datos[:, i]

        # Asimetría y curtosis
        skewness = np.mean(((columna - np.mean(columna)) / np.std(columna))**3)
        kurtosis = np.mean(((columna - np.mean(columna)) / np.std(columna))**4) - 3

        print(f"{col}:")
        print(".4f")
        print(".4f")

        # Clasificación de distribución
        if abs(skewness) < 0.5 and abs(kurtosis) < 0.5:
            distribucion = "Aproximadamente normal"
        elif skewness > 1:
            distribucion = "Sesgada a la derecha"
        elif skewness < -1:
            distribucion = "Sesgada a la izquierda"
        else:
            distribucion = "Distribución irregular"

        print(f"  Clasificación: {distribucion}")

# Ejecutar análisis exploratorio
analisis_exploratorio(dataset_limpio, columnas)

Integración con Pandas

Trabajar eficientemente con Pandas usando NumPy:

import pandas as pd

def numpy_a_pandas(datos_numpy, columnas):
    """Convierte array de NumPy a DataFrame de Pandas"""
    df = pd.DataFrame(datos_numpy, columns=columnas)
    return df

def pandas_a_numpy(df):
    """Convierte DataFrame de Pandas a array de NumPy"""
    return df.values

# Convertir dataset a Pandas para análisis avanzado
df_ventas = numpy_a_pandas(dataset_limpio, columnas)
print("DataFrame creado:")
print(df_ventas.head())
print(f"\nTipo: {type(df_ventas)}")
print(f"Forma: {df_ventas.shape}")

# Operaciones conjuntas NumPy-Pandas
print("\n=== OPERACIONES CONJUNTAS ===")

# Usar NumPy para cálculos vectorizados en Pandas
ventas_array = df_ventas['Ventas'].values  # Extraer como NumPy array
precios_array = df_ventas['Precio'].values

# Cálculos con NumPy
ingresos = ventas_array * precios_array
margen_ganancia = np.where(ventas_array > np.mean(ventas_array), 0.15, 0.10)

# Agregar resultados al DataFrame
df_ventas['Ingresos'] = ingresos
df_ventas['Margen_Ganancia'] = margen_ganancia
df_ventas['Ganancia'] = ingresos * margen_ganancia

print("Nuevas columnas agregadas:")
print(df_ventas[['Ventas', 'Precio', 'Ingresos', 'Ganancia']].head())

# Estadísticas agrupadas usando NumPy
print("\nEstadísticas por categoría (usando NumPy):")
categorias_unicas = np.unique(df_ventas['Categoria'].values)

for cat in categorias_unicas:
    mascara = df_ventas['Categoria'].values == cat
    ingresos_cat = df_ventas['Ingresos'].values[mascara]

    print(f"Categoría {cat}:")
    print(".2f")
    print(".2f")

Visualización Básica con Matplotlib

Crear visualizaciones usando NumPy y Matplotlib:

import matplotlib.pyplot as plt

def crear_visualizaciones(datos, columnas):
    """Crea visualizaciones básicas del dataset"""
    fig, axes = plt.subplots(2, 3, figsize=(15, 10))
    fig.suptitle('Análisis Visual del Dataset de Ventas', fontsize=16)

    # 1. Histograma de ventas
    axes[0, 0].hist(datos[:, 1], bins=30, alpha=0.7, color='blue')
    axes[0, 0].set_title('Distribución de Ventas')
    axes[0, 0].set_xlabel('Ventas')
    axes[0, 0].set_ylabel('Frecuencia')
    axes[0, 0].grid(True, alpha=0.3)

    # 2. Gráfico de dispersión: Precio vs Ventas
    axes[0, 1].scatter(datos[:, 2], datos[:, 1], alpha=0.6, c=datos[:, 3], cmap='viridis')
    axes[0, 1].set_title('Precio vs Ventas')
    axes[0, 1].set_xlabel('Precio')
    axes[0, 1].set_ylabel('Ventas')
    axes[0, 1].grid(True, alpha=0.3)

    # 3. Box plot por categoría
    categorias_unicas = np.unique(datos[:, 3])
    datos_por_cat = [datos[datos[:, 3] == cat, 1] for cat in categorias_unicas]
    axes[0, 2].boxplot(datos_por_cat, labels=[f'Cat {int(cat)}' for cat in categorias_unicas])
    axes[0, 2].set_title('Ventas por Categoría')
    axes[0, 2].set_ylabel('Ventas')
    axes[0, 2].grid(True, alpha=0.3)

    # 4. Serie temporal de ventas
    axes[1, 0].plot(datos[:, 0], datos[:, 1], 'b-', alpha=0.7)
    axes[1, 0].set_title('Tendencia de Ventas')
    axes[1, 0].set_xlabel('Día')
    axes[1, 0].set_ylabel('Ventas')
    axes[1, 0].grid(True, alpha=0.3)

    # 5. Matriz de correlación
    correlacion = np.corrcoef(datos.T)
    im = axes[1, 1].imshow(correlacion, cmap='coolwarm', vmin=-1, vmax=1)
    axes[1, 1].set_title('Matriz de Correlación')
    axes[1, 1].set_xticks(range(len(columnas)))
    axes[1, 1].set_yticks(range(len(columnas)))
    axes[1, 1].set_xticklabels(columnas, rotation=45)
    axes[1, 1].set_yticklabels(columnas)
    plt.colorbar(im, ax=axes[1, 1])

    # 6. Análisis de regiones
    regiones_unicas = np.unique(datos[:, 4])
    ventas_por_region = [np.mean(datos[datos[:, 4] == reg, 1]) for reg in regiones_unicas]
    axes[1, 2].bar([f'Región {int(reg)}' for reg in regiones_unicas], ventas_por_region,
                   color=['red', 'green', 'blue'], alpha=0.7)
    axes[1, 2].set_title('Ventas Promedio por Región')
    axes[1, 2].set_ylabel('Ventas Promedio')
    axes[1, 2].grid(True, alpha=0.3)

    plt.tight_layout()
    return fig

# Crear visualizaciones
try:
    fig = crear_visualizaciones(dataset_limpio, columnas)
    plt.savefig('analisis_ventas.png', dpi=300, bbox_inches='tight')
    print("Visualizaciones guardadas como 'analisis_ventas.png'")
    plt.show()
except ImportError:
    print("Matplotlib no está instalado. Instala con: pip install matplotlib")

Preparación de Datos para Machine Learning

Preparar datos para algoritmos de ML:

def preparar_datos_ml(datos, target_col=1):
    """Prepara datos para machine learning"""
    print("=== PREPARACIÓN DE DATOS PARA ML ===")

    # Separar features y target
    X = np.delete(datos, target_col, axis=1)  # Todas las columnas excepto target
    y = datos[:, target_col]  # Columna target

    print(f"Features (X): {X.shape}")
    print(f"Target (y): {y.shape}")

    # 1. División train/test
    n_total = len(X)
    n_train = int(0.8 * n_total)
    n_test = n_total - n_train

    # Mezclar índices
    indices = np.random.permutation(n_total)

    # Dividir
    train_indices = indices[:n_train]
    test_indices = indices[n_train:]

    X_train = X[train_indices]
    X_test = X[test_indices]
    y_train = y[train_indices]
    y_test = y[test_indices]

    print(f"Conjunto de entrenamiento: {X_train.shape[0]} muestras")
    print(f"Conjunto de prueba: {X_test.shape[0]} muestras")

    # 2. Normalización/Estandarización
    # Calcular estadísticas solo del conjunto de entrenamiento
    X_train_mean = np.mean(X_train, axis=0)
    X_train_std = np.std(X_train, axis=0)

    # Aplicar estandarización
    X_train_scaled = (X_train - X_train_mean) / X_train_std
    X_test_scaled = (X_test - X_train_mean) / X_train_std

    print("Datos estandarizados (media ≈ 0, std ≈ 1)")

    # 3. Crear features polinomiales (ejemplo simple)
    # Agregar términos cuadráticos para algunas features
    X_train_poly = np.column_stack([
        X_train_scaled,
        X_train_scaled[:, 0]**2,  # Cuadrado de primera feature
        X_train_scaled[:, 1]**2   # Cuadrado de segunda feature
    ])

    X_test_poly = np.column_stack([
        X_test_scaled,
        X_test_scaled[:, 0]**2,
        X_test_scaled[:, 1]**2
    ])

    print(f"Features polinomiales agregadas: {X_train_poly.shape[1]} features totales")

    return X_train_poly, X_test_poly, y_train, y_test

# Preparar datos para ML
X_train, X_test, y_train, y_test = preparar_datos_ml(dataset_limpio)

print("
Datos preparados para ML:")
print(f"X_train: {X_train.shape}")
print(f"X_test: {X_test.shape}")
print(f"y_train: {y_train.shape}")
print(f"y_test: {y_test.shape}")

Análisis de Series Temporales

Análisis básico de series temporales con NumPy:

def analisis_series_temporales(datos, columna_tiempo=0, columna_valor=1):
    """Análisis básico de series temporales"""
    print("=== ANÁLISIS DE SERIES TEMPORALES ===")

    tiempo = datos[:, columna_tiempo]
    valores = datos[:, columna_valor]

    # 1. Tendencia
    from numpy.polynomial import Polynomial
    coeficientes = Polynomial.fit(tiempo, valores, deg=2)
    tendencia = coeficientes(tiempo)

    print("Análisis de tendencia:")
    print(".4f")
    print(".4f")

    # 2. Estacionalidad (usando promedio móvil)
    ventana = 30  # 30 días
    promedio_movil = np.convolve(valores, np.ones(ventana)/ventana, mode='valid')

    print("
Análisis de estacionalidad:")
    print(f"Ventana de promedio móvil: {ventana} períodos")
    print(".2f")
    print(".2f")

    # 3. Autocorrelación simple
    def autocorrelacion(x, lag):
        return np.corrcoef(x[:-lag], x[lag:])[0, 1]

    lags = range(1, 11)
    autocorr = [autocorrelacion(valores, lag) for lag in lags]

    print("
Autocorrelación (primeros 10 lags):")
    for lag, corr in zip(lags, autocorr):
        print(".4f")

    # 4. Descomposición simple
    residuales = valores - tendencia[:len(valores)]

    print("
Descomposición:")
    print(".2f")
    print(".2f")

    return tendencia, promedio_movil, autocorr

# Ejecutar análisis de series temporales
tendencia, promedio_movil, autocorr = analisis_series_temporales(dataset_limpio)

Caso de Estudio - Análisis de Ventas

Análisis completo de un escenario real:

def analisis_completo_ventas():
    """Análisis completo del dataset de ventas"""
    print("=== ANÁLISIS COMPLETO DE VENTAS ===\n")

    # 1. Cargar y preparar datos
    dataset = crear_dataset_ejemplo()
    columnas = ['Dia', 'Ventas', 'Precio', 'Categoria', 'Region']

    # 2. Limpieza de datos
    dataset_limpio = limpiar_datos(dataset)

    # 3. Análisis exploratorio
    explorar_dataset(dataset_limpio, columnas)

    # 4. Segmentación por categorías
    print("\n=== SEGMENTACIÓN POR CATEGORÍAS ===")
    categorias = dataset_limpio[:, 3].astype(int)

    for cat in np.unique(categorias):
        mascara = categorias == cat
        segmento = dataset_limpio[mascara]

        print(f"\nSegmento Categoría {cat}:")
        print(f"  Tamaño: {len(segmento)} registros ({len(segmento)/len(dataset_limpio)*100:.1f}%)")
        print(".2f")
        print(".2f")
        print(".2f")

    # 5. Análisis de correlaciones
    print("\n=== ANÁLISIS DE CORRELACIONES ===")
    correlaciones = np.corrcoef(dataset_limpio.T)

    for i in range(len(columnas)):
        for j in range(i+1, len(columnas)):
            corr = correlaciones[i, j]
            if abs(corr) > 0.3:
                intensidad = "fuerte" if abs(corr) > 0.7 else "moderada"
                direccion = "positiva" if corr > 0 else "negativa"
                print(".3f"

    # 6. Predicciones simples
    print("\n=== PREDICCIONES SIMPLES ===")

    # Regresión lineal simple usando NumPy
    X = dataset_limpio[:, 2].reshape(-1, 1)  # Precio
    y = dataset_limpio[:, 1]  # Ventas

    # Agregar intercepto
    X_b = np.column_stack([np.ones(len(X)), X])

    # Calcular coeficientes usando ecuaciones normales
    coeficientes = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y

    print("Regresión lineal: Ventas = {:.2f} + {:.2f} * Precio".format(
        coeficientes[0], coeficientes[1]))

    # Predicciones
    y_pred = X_b @ coeficientes
    mse = np.mean((y - y_pred)**2)
    r2 = 1 - (np.sum((y - y_pred)**2) / np.sum((y - np.mean(y))**2))

    print(".2f")
    print(".4f")

    return {
        'dataset': dataset_limpio,
        'coeficientes': coeficientes,
        'mse': mse,
        'r2': r2
    }

# Ejecutar análisis completo
resultados_analisis = analisis_completo_ventas()

Proyecto Práctico - Sistema de Recomendaciones

Construyamos un sistema de recomendaciones simple:

def sistema_recomendaciones():
    """Sistema de recomendaciones basado en similitud de usuarios"""
    print("=== SISTEMA DE RECOMENDACIONES ===\n")

    # Crear datos de ejemplo: usuarios x productos
    np.random.seed(42)
    n_usuarios = 100
    n_productos = 50

    # Matriz de calificaciones (usuarios x productos)
    # Usaremos distribución normal con algunos valores faltantes
    calificaciones = np.random.normal(3.5, 1.5, (n_usuarios, n_productos))
    calificaciones = np.clip(calificaciones, 1, 5)  # Limitar a rango 1-5

    # Simular valores faltantes (usuarios no han calificado todos los productos)
    mascara_faltantes = np.random.random((n_usuarios, n_productos)) < 0.7
    calificaciones[mascara_faltantes] = np.nan

    print(f"Matriz de calificaciones: {calificaciones.shape}")
    print(".1f"
    # 1. Calcular similitud entre usuarios usando correlación de Pearson
    def similitud_usuarios(matriz_calif):
        """Calcula similitud entre usuarios"""
        n_usuarios = matriz_calif.shape[0]
        similitudes = np.zeros((n_usuarios, n_usuarios))

        for i in range(n_usuarios):
            for j in range(n_usuarios):
                if i != j:
                    # Productos calificados por ambos usuarios
                    mascara_comun = ~(np.isnan(matriz_calif[i]) | np.isnan(matriz_calif[j]))

                    if np.sum(mascara_comun) > 5:  # Mínimo 5 calificaciones en común
                        calif_i = matriz_calif[i, mascara_comun]
                        calif_j = matriz_calif[j, mascara_comun]

                        # Correlación de Pearson
                        similitudes[i, j] = np.corrcoef(calif_i, calif_j)[0, 1]
                    else:
                        similitudes[i, j] = 0
                else:
                    similitudes[i, j] = 1  # Similitud perfecta consigo mismo

        return similitudes

    print("\nCalculando similitudes entre usuarios...")
    matriz_similitud = similitud_usuarios(calificaciones)

    # 2. Generar recomendaciones
    def recomendar_productos(usuario_id, matriz_calif, matriz_sim, top_n=5):
        """Genera recomendaciones para un usuario"""
        # Productos no calificados por el usuario
        productos_no_calif = np.isnan(matriz_calif[usuario_id])

        if not np.any(productos_no_calif):
            return []  # Usuario ha calificado todo

        recomendaciones = []

        for producto_id in np.where(productos_no_calif)[0]:
            # Calcular predicción ponderada
            pesos_similitud = matriz_sim[usuario_id]
            calif_vecinos = matriz_calif[:, producto_id]

            # Solo considerar usuarios similares (similitud > 0.3)
            mascara_vecinos = (~np.isnan(calif_vecinos)) & (pesos_similitud > 0.3)

            if np.sum(mascara_vecinos) > 0:
                pesos_filtrados = pesos_similitud[mascara_vecinos]
                calif_filtradas = calif_vecinos[mascara_vecinos]

                # Predicción ponderada
                prediccion = np.average(calif_filtradas, weights=pesos_filtrados)
                recomendaciones.append((producto_id, prediccion))

        # Ordenar por predicción descendente
        recomendaciones.sort(key=lambda x: x[1], reverse=True)
        return recomendaciones[:top_n]

    # 3. Evaluar el sistema
    def evaluar_sistema(matriz_calif, matriz_sim, n_evaluaciones=10):
        """Evalúa el sistema ocultando algunas calificaciones"""
        errores = []

        for _ in range(n_evaluaciones):
            # Seleccionar usuario y producto aleatorio con calificación
            mascara_calif = ~np.isnan(matriz_calif)
            indices_calif = np.where(mascara_calif)

            if len(indices_calif[0]) == 0:
                continue

            idx_aleatorio = np.random.randint(len(indices_calif[0]))
            usuario_id = indices_calif[0][idx_aleatorio]
            producto_id = indices_calif[1][idx_aleatorio]

            # Ocultar calificación real
            calif_real = matriz_calif[usuario_id, producto_id]
            matriz_calif[usuario_id, producto_id] = np.nan

            # Generar predicción
            recomendaciones = recomendar_productos(usuario_id, matriz_calif, matriz_sim, top_n=10)

            # Buscar predicción para el producto ocultado
            prediccion = None
            for prod_id, pred in recomendaciones:
                if prod_id == producto_id:
                    prediccion = pred
                    break

            # Restaurar calificación
            matriz_calif[usuario_id, producto_id] = calif_real

            if prediccion is not None:
                error = abs(calif_real - prediccion)
                errores.append(error)

        if errores:
            mae = np.mean(errores)
            rmse = np.sqrt(np.mean(np.array(errores)**2))
            print(".4f")
            print(".4f")
        else:
            print("No se pudieron generar evaluaciones")

    # Ejecutar sistema
    print("\nEvaluando sistema de recomendaciones...")
    evaluar_sistema(calificaciones.copy(), matriz_similitud)

    # Generar recomendaciones para usuario de ejemplo
    usuario_ejemplo = 0
    recomendaciones = recomendar_productos(usuario_ejemplo, calificaciones, matriz_similitud)

    print(f"\nRecomendaciones para Usuario {usuario_ejemplo}:")
    for producto_id, prediccion in recomendaciones:
        print(".2f")

    return calificaciones, matriz_similitud

# Ejecutar sistema de recomendaciones
calificaciones, similitudes = sistema_recomendaciones()

Próximos Pasos

¡Felicidades! Has completado el tutorial de NumPy para Data Science. Ahora puedes:

1. Machine Learning Avanzado: Aplicar NumPy en algoritmos de ML
2. Big Data: Procesar datasets masivos con NumPy
3. Deep Learning: Usar NumPy como base para TensorFlow/PyTorch
4. Especialización: Enfocarte en áreas específicas como NLP o Computer Vision

Tutoriales Recomendados

• Pandas Avanzado
• Scikit-learn con NumPy
• TensorFlow Fundamentals

Conclusión

Has aprendido a aplicar NumPy en escenarios reales de data science:

• Carga y limpieza de datos: Importar, limpiar y preprocesar datasets
• Análisis exploratorio: Entender la estructura y características de los datos
• Transformaciones: Normalizar, estandarizar y crear features derivadas
• Visualización: Crear gráficos informativos para comunicar insights
• Machine Learning: Preparar datos para algoritmos de ML
• Series temporales: Analizar tendencias y patrones temporales
• Sistemas de recomendación: Construir motores de recomendación

NumPy es la base de todo el ecosistema de data science en Python. Con estas habilidades, puedes abordar problemas complejos de análisis de datos con confianza y eficiencia.

¡Continúa practicando con datasets reales y aplicando estas técnicas en proyectos desafiantes!

¡Tu viaje en Data Science con NumPy continúa!

💡 Tip Importante

📝 Mejores Prácticas en Data Science con NumPy

• Siempre explora tus datos primero antes de aplicar transformaciones
• Documenta cada paso del preprocesamiento para reproducibilidad
• Valida tus resultados con métricas apropiadas
• Considera la escalabilidad desde el inicio de tus proyectos
• Combina NumPy con Pandas para análisis más expresivos
• Visualiza tus datos para comunicar insights efectivamente
• Evalúa el rendimiento de tus algoritmos regularmente

📚 Recursos Recomendados:

• Scikit-learn Documentation
• Pandas Documentation
• Matplotlib Gallery
• Kaggle Datasets

¡Los datos son tu lienzo, NumPy tu pincel. Crea algo extraordinario!