Ciclo de vida de un proyecto de aprendizaje automático

Un proyecto de aprendizaje automático es como construir una casa: requiere un proceso completo que va desde el diseño hasta la construcción y la aceptación final. Cada etapa es crucial e indispensable.

Seis etapas principales del flujo de aprendizaje automático:

  1. Definición del problema: aclarar qué problema se va a resolver
  2. Recopilación de datos: obtener datos relevantes
  3. Preparación de datos: limpiar y preprocesar los datos
  4. Entrenamiento del modelo: elegir el algoritmo y entrenar el modelo
  5. Evaluación del modelo: evaluar el rendimiento del modelo
  6. Implementación del modelo: poner el modelo en producción


Etapa 1: Definición del problema

Definir el problema de negocio

La definición del problema es el punto de partida más importante de un proyecto de aprendizaje automático, igual que es necesario tener claro el destino antes de usar el GPS.

Preguntas clave

¿Qué problema queremos resolver?

  • Problema de clasificación: determinar si un correo electrónico es spam
  • Problema de regresión: predecir el precio de una vivienda
  • Problema de agrupamiento: segmentación de clientes
  • Detección de anomalías: detectar fraude con tarjetas de crédito

¿Por qué es importante este problema?

  • Valor para el negocio: mejorar la eficiencia, reducir costos, aumentar ingresos
  • Valor para el usuario: mejorar la experiencia, ofrecer servicios personalizados

¿Cuál es el criterio de éxito?

  • Métricas cuantitativas: alcanzar una precisión superior al 90%
  • Métricas de negocio: aumentar la tasa de conversión en un 20%

Ejemplo de definición del problema

Ejemplo

# Ejemplo de definición del problema: sistema de recomendación para comercio electrónico
class ProblemDefinition:
    def __init__(self):
        # Problema de negocio
        self.business_problem = "La tasa de conversión de compra de los usuarios es baja; es necesario mejorar la precisión de las recomendaciones"
       
        # Problema técnico
        self.technical_problem = "Predecir los productos que un usuario podría comprar basándose en su comportamiento"
       
        # Tipo de problema
        self.problem_type = "Sistema de recomendación (clasificación + ranking)"
       
        # Criterios de éxito
        self.success_criteria = {
            "Aumento de la tasa de clics": "15%",
            "Aumento de la tasa de conversión": "10%",
            "Precisión de las recomendaciones": "80%"
        }
       
        # Restricciones
        self.constraints = {
            "Tiempo de respuesta": "< 100ms",
            "Privacidad de los datos": "Cumplir con los requisitos del GDPR",
            "Recursos computacionales": "Configuración actual del servidor"
        }
   
    def define_features_and_labels(self):
        """Definir características y etiquetas"""
        features = {
            "Características del usuario": ["Edad", "Género", "Historial de compras", "Comportamiento de navegación"],
            "Características del producto": ["Categoría", "Precio", "Calificación", "Inventario"],
            "Características contextuales": ["Tiempo", "Dispositivo", "Ubicación geográfica"]
        }
       
        labels = {
            "Etiqueta principal": "Si hizo clic",
            "Etiqueta secundaria": "Si compró",
            "Etiqueta auxiliar": "Tiempo de permanencia"
        }
       
        return features, labels
   
    def print_definition(self):
        """Imprimir la definición del problema"""
        print("=" * 50)
        print("Definición del problema de aprendizaje automático")
        print("=" * 50)
        print(f"Problema de negocio: {self.business_problem}")
        print(f"Problema técnico: {self.technical_problem}")
        print(f"Tipo de problema: {self.problem_type}")
        print("\nCriterios de éxito:")
        for metric, target in self.success_criteria.items():
            print(f"  {metric}:{target}")
        print("\nRestricciones:")
        for constraint, limit in self.constraints.items():
            print(f"  {constraint}:{limit}")
       
        features, labels = self.define_features_and_labels()
        print("\nDefinición de características:")
        for category, items in features.items():
            print(f"  {category}:{', '.join(items)}")
        print("\nDefinición de etiquetas:")
        for label_type, label_name in labels.items():
            print(f"  {label_type}:{label_name}")

# Ejemplo de uso
problem = ProblemDefinition()
problem.print_definition()

Contenido de salida:

==================================================
机器学习问题定义
==================================================
业务问题:用户购买转化率低,需要提高推荐精准度
技术问题:基于用户行为预测用户可能购买的商品
问题类型:推荐系统(分类+排序)

成功标准:
  点击率提升:15%
  转化率提升:10%
  推荐准确率:80%

约束条件:
  响应时间:< 100ms
  数据隐私:符合 GDPR 要求
  计算资源:现有服务器配置

特征定义:
  用户特征:年龄, 性别, 购买历史, 浏览行为
  商品特征:类别, 价格, 评分, 库存
  上下文特征:时间, 设备, 地理位置

标签定义:
  主要标签:是否点击
  次要标签:是否购买
  辅助标签:停留时间

Etapa 2: Recopilación de datos

Fuentes de datos

Los datos son el combustible del aprendizaje automático, sin los datos adecuados, incluso el mejor algoritmo no puede funcionar.

Fuentes de datos comunes

  1. Datos internos: datos comerciales de la empresa, datos de comportamiento del usuario
  2. Datos externos: conjuntos de datos públicos, servicios de datos de terceros
  3. Web scraping: datos de páginas web, datos de redes sociales
  4. Datos de sensores: dispositivos IoT, sistemas de monitoreo

Ejemplo de recopilación de datos

Ejemplo

# Ejemplo de recopilación de datos: simular múltiples fuentes de datos
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

class DataCollector:
    def __init__(self):
        self.collected_data = {}
   
    def collect_user_data(self, n_users=1000):
        """Recopilar datos de usuarios"""
        np.random.seed(42)
       
        user_data = {
            'user_id': range(1, n_users + 1),
            'age': np.random.randint(18, 65, n_users),
            'gender': np.random.choice(['Masculino', 'Femenino'], n_users),
            'city': np.random.choice(['Pekín', 'Shanghái', 'Cantón', 'Shenzhen'], n_users),
            'registration_date': [
                datetime.now() - timedelta(days=np.random.randint(1, 365))
                for _ in range(n_users)
            ]
        }
       
        self.collected_data['users'] = pd.DataFrame(user_data)
        print(f"Se recopilaron {len(user_data['user_id'])} registros de datos de usuario")
        return self.collected_data['users']
   
    def collect_behavior_data(self, n_behaviors=5000):
        """Recopilar datos de comportamiento del usuario"""
        np.random.seed(42)
       
        user_ids = np.random.choice(range(1, 1001), n_behaviors)
        product_ids = np.random.choice(range(1, 501), n_behaviors)
       
        behavior_data = {
            'behavior_id': range(1, n_behaviors + 1),
            'user_id': user_ids,
            'product_id': product_ids,
            'behavior_type': np.random.choice(
                ['Ver', 'Clic', 'Agregar al carrito', 'Comprar'], n_behaviors,
                p=[0.4, 0.3, 0.2, 0.1]
            ),
            'timestamp': [
                datetime.now() - timedelta(minutes=np.random.randint(1, 10080))
                for _ in range(n_behaviors)
            ],
            'duration': np.random.exponential(30, n_behaviors)  # Tiempo de permanencia (segundos)
        }
       
        self.collected_data['behaviors'] = pd.DataFrame(behavior_data)
        print(f"Se recopilaron {len(behavior_data['behavior_id'])} registros de datos de comportamiento")
        return self.collected_data['behaviors']
   
    def collect_product_data(self, n_products=500):
        """Recopilar datos de productos"""
        np.random.seed(42)
       
        categories = ['Electrónicos', 'Ropa', 'Alimentos', 'Hogar', 'Libros']
        product_data = {
            'product_id': range(1, n_products + 1),
            'category': np.random.choice(categories, n_products),
            'price': np.random.uniform(10, 1000, n_products),
            'rating': np.random.uniform(3.0, 5.0, n_products),
            'stock': np.random.randint(0, 1000, n_products)
        }
       
        self.collected_data['products'] = pd.DataFrame(product_data)
        print(f"Se recopilaron {len(product_data['product_id'])} registros de datos de productos")
        return self.collected_data['products']
   
    def get_data_summary(self):
        """Obtener el resumen de los datos"""
        print("\nResumen de la recopilación de datos:")
        for name, df in self.collected_data.items():
            print(f"\n{name} Conjunto de datos:")
            print(f" Forma: {df.shape}")
            print(f" Nombres de columnas: {list(df.columns)}")
            print(f" Valores faltantes: {df.isnull().sum().sum()}")
            print(f" Datos de ejemplo:")
            print(df.head(2))

# Ejemplo de uso
collector = DataCollector()
collector.collect_user_data()
collector.collect_behavior_data()
collector.collect_product_data()
collector.get_data_summary()

Etapa 3: Preparación de datos

Importancia de la preparación de datos

La preparación de datos representa del 60 al 80% del tiempo en un proyecto de aprendizaje automático, es igual de importante que los preparativos antes de cocinar.

Principales tareas de la preparación de datos

  1. Limpieza de datos: manejar valores faltantes, valores atípicos y valores duplicados
  2. Ingeniería de características: crear nuevas características, seleccionar características importantes
  3. Transformación de datos: estandarización, normalización, codificación
  4. División de datos: conjunto de entrenamiento, conjunto de validación, conjunto de prueba

Ejemplo de preparación de datos

Ejemplo

# Ejemplo de preparación de datos
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.model_selection import train_test_split

class DataPreparer:
    def __init__(self, data):
        self.data = data.copy()
        self.processed_data = None
   
    def clean_data(self):
        """Limpieza de datos"""
        print("Comenzando la limpieza de datos...")
       
        # 1. Manejar valores faltantes
        print(f"Cantidad de valores faltantes antes del procesamiento: {self.data.isnull().sum().sum()}")
       
        # Las columnas numéricas se rellenan con la media
        numeric_columns = self.data.select_dtypes(include=[np.number]).columns
        for col in numeric_columns:
            if self.data[col].isnull().sum() > 0:
                self.data[col].fillna(self.data[col].mean(), inplace=True)
       
        # Las columnas categóricas se rellenan con la moda
        categorical_columns = self.data.select_dtypes(include=['object']).columns
        for col in categorical_columns:
            if self.data[col].isnull().sum() > 0:
                mode_val = self.data[col].mode()[0]
                self.data[col].fillna(mode_val, inplace=True)
       
        print(f"Cantidad de valores faltantes después del procesamiento: {self.data.isnull().sum().sum()}")
       
        # 2. Manejar valores duplicados
        duplicates_before = self.data.duplicated().sum()
        self.data.drop_duplicates(inplace=True)
        duplicates_after = self.data.duplicated().sum()
        print(f"Valores duplicados eliminados: {duplicates_before - duplicates_after}")
       
        # 3. Manejar valores atípicos (método simple: usar IQR)
        for col in numeric_columns:
            Q1 = self.data[col].quantile(0.25)
            Q3 = self.data[col].quantile(0.75)
            IQR = Q3 - Q1
            lower_bound = Q1 - 1.5 * IQR
            upper_bound = Q3 + 1.5 * IQR
           
            outliers = ((self.data[col] < lower_bound) |
                       (self.data[col] > upper_bound)).sum()
            if outliers > 0:
                # Reemplazar los valores atípicos con el valor límite
                self.data[col] = self.data[col].clip(lower_bound, upper_bound)
                print(f"Procesando {outliers} valores atípicos en la columna {col}")
       
        return self.data
   
    def feature_engineering(self):
        """Ingeniería de características"""
        print("\nComenzando la ingeniería de características...")
       
        # 1. Crear nuevas características (ejemplo)
        if 'price' in self.data.columns and 'rating' in self.data.columns:
            # Crear la característica de relación calidad-precio
            self.data['price_per_rating'] = self.data['price'] / self.data['rating']
            print("Crear nueva característica: price_per_rating")
       
        # 2. Selección de características (ejemplo simple: eliminar características de baja varianza)
        numeric_columns = self.data.select_dtypes(include=[np.number]).columns
        low_variance_features = []
       
        for col in numeric_columns:
            if self.data[col].var() < 0.01:  # Umbral de varianza
                low_variance_features.append(col)
       
        if low_variance_features:
            self.data.drop(columns=low_variance_features, inplace=True)
            print(f"Eliminar características de baja varianza: {low_variance_features}")
       
        return self.data
   
    def transform_data(self):
        """Transformación de datos"""
        print("\nComenzar transformación de datos...")
       
        # 1. Codificar variables categóricas
        categorical_columns = self.data.select_dtypes(include=['object']).columns
        label_encoders = {}
       
        for col in categorical_columns:
            le = LabelEncoder()
            self.data[col] = le.fit_transform(self.data[col])
            label_encoders[col] = le
            print(f"Codificar variables categóricas: {col}")
       
        # 2. Estandarizar variables numéricas
        numeric_columns = self.data.select_dtypes(include=[np.number]).columns
        scaler = StandardScaler()
       
        if len(numeric_columns) > 0:
            self.data[numeric_columns] = scaler.fit_transform(self.data[numeric_columns])
            print(f"Estandarizar variables numéricas: {list(numeric_columns)}")
       
        return self.data, label_encoders, scaler
   
    def split_data(self, target_column, test_size=0.2, val_size=0.2):
        """División de datos"""
        print(f"\nComenzar división de datos (proporción de prueba: {test_size}, proporción de validación: {val_size})...")
       
        X = self.data.drop(columns=[target_column])
        y = self.data[target_column]
       
        # Primero separar el conjunto de prueba
        X_temp, X_test, y_temp, y_test = train_test_split(
            X, y, test_size=test_size, random_state=42
        )
       
        # Luego separar el conjunto de validación de los datos restantes
        val_size_adjusted = val_size / (1 - test_size)
        X_train, X_val, y_train, y_val = train_test_split(
            X_temp, y_temp, test_size=val_size_adjusted, random_state=42
        )
       
        print(f"Tamaño del conjunto de entrenamiento: {X_train.shape)
        print(f"Tamaño del conjunto de validación: {X_val.shape)
        print(f"Tamaño del conjunto de prueba: {X_test.shape)
       
        return {
            'X_train': X_train, 'y_train': y_train,
            'X_val': X_val, 'y_val': y_val,
            'X_test': X_test, 'y_test': y_test
        }
   
    def prepare_pipeline(self, target_column):
        """Pipeline completo de preparación de datos"""
        print("=" * 50)
        print("Pipeline de preparación de datos")
        print("=" * 50)
       
        # 1. Limpieza de datos
        self.clean_data()
       
        # 2. Ingeniería de características
        self.feature_engineering()
       
        # 3. Transformación de datos
        processed_data, encoders, scaler = self.transform_data()
       
        # 4. División de datos
        splits = self.split_data(target_column)
       
        self.processed_data = processed_data
        return splits, encoders, scaler

# Crear datos de ejemplo y demostrar la preparación de datos
np.random.seed(42)
sample_data = pd.DataFrame({
    'age': np.random.randint(18, 65, 1000),
    'income': np.random.normal(50000, 15000, 1000),
    'gender': np.random.choice(['Hombre', 'Mujer'], 1000),
    'city': np.random.choice(['Beijing', 'Shanghái', 'Guangzhou'], 1000),
    'target': np.random.choice([0, 1], 1000)
})

# Agregar algunos valores faltantes y valores atípicos
sample_data.loc[np.random.choice(1000, 50), 'income'] = np.nan
sample_data.loc[np.random.choice(1000, 20), 'age'] = np.random.randint(100, 150)

preparer = DataPreparer(sample_data)
splits, encoders, scaler = preparer.prepare_pipeline('target')
hr>

Etapa 4: Entrenamiento del modelo

Estrategia de selección del modelo

Elegir el modelo adecuado es clave para el éxito, como elegir la herramienta adecuada para el trabajo.

Factores a considerar en la selección de modelos

  1. Tipo de problema: clasificación, regresión, agrupamiento, etc.
  2. Características de los datos: volumen de datos, número de características, tipo de datos
  3. Requisitos de rendimiento: exactitud, velocidad, interpretabilidad
  4. Restricciones de recursos: recursos computacionales, limitaciones de tiempo

Ejemplo de entrenamiento del modelo

Ejemplo

# Ejemplo de entrenamiento de modelos
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.svm import SVC, SVR
from sklearn.metrics import accuracy_score, mean_squared_error, classification_report

class ModelTrainer:
    def __init__(self):
        self.models = {}
        self.trained_models = {}
   
    def register_model(self, name, model, problem_type):
        """Registrar modelo"""
        self.models[name] = {
            'model': model,
            'problem_type': problem_type
        }
        print(f"Registrar modelo: {name} ({problem_type})")
   
    def train_single_model(self, name, X_train, y_train):
        """Entrenar modelo individual"""
        if name not in self.models:
            raise ValueError(f"El modelo {name} no está registrado")
       
        model_info = self.models[name]
        model = model_info['model']
       
        print(f"\nEntrenar modelo: {name}")
        model.fit(X_train, y_train)
       
        self.trained_models[name] = model
        print(f"Entrenamiento del modelo {name} completado")
       
        return model
   
    def train_all_models(self, X_train, y_train):
        """Entrenar todos los modelos registrados"""
        print("\nComenzar entrenamiento de todos los modelos...")
       
        for name in self.models.keys():
            try:
                self.train_single_model(name, X_train, y_train)
            except Exception as e:
                print(f"Error al entrenar el modelo {name}: {e}")
       
        return self.trained_models
   
    def evaluate_models(self, X_test, y_test):
        """Evaluar todos los modelos entrenados"""
        print("\nResultados de evaluación de modelos:")
        print("-" * 50)
       
        results = {}
       
        for name, model in self.trained_models.items():
            problem_type = self.models[name]['problem_type']
           
            # Predicción
            y_pred = model.predict(X_test)
           
            # Seleccionar métricas de evaluación según el tipo de problema
            if problem_type == 'classification':
                accuracy = accuracy_score(y_test, y_pred)
                results[name] = {'accuracy': accuracy}
                print(f"{name}: exactitud = {accuracy:.4f}")
               
                # Informe detallado
                print(classification_report(y_test, y_pred))
               
            elif problem_type == 'regression':
                mse = mean_squared_error(y_test, y_pred)
                rmse = np.sqrt(mse)
                results[name] = {'mse': mse, 'rmse': rmse}
                print(f"{name}: MSE = {mse:.4f}, RMSE = {rmse:.4f}")
           
            print("-" * 50)
       
        return results
   
    def get_best_model(self, results, metric='accuracy'):
        """Obtener el mejor modelo"""
        if not results:
            return None
       
        best_model_name = max(results.keys(), key=lambda x: results[x].get(metric, 0))
        best_score = results[best_model_name][metric]
       
        print(f"\nMejor modelo: {best_model_name} ({metric} = {best_score:.4f})")
       
        return best_model_name, self.trained_models[best_model_name]

# Ejemplo de uso
trainer = ModelTrainer()

# Registrar diferentes tipos de modelos
trainer.register_model('Regresión logística', LogisticRegression(random_state=42), 'classification')
trainer.register_model('Bosque aleatorio', RandomForestClassifier(n_estimators=100, random_state=42), 'classification')
trainer.register_model('Máquina de vectores de soporte', SVC(random_state=42), 'classification')

# Crear datos de entrenamiento
X_train = splits['X_train']
y_train = splits['y_train']
X_test = splits['X_test']
y_test = splits['y_test']

# Entrenar todos los modelos
trained_models = trainer.train_all_models(X_train, y_train)

# Evaluar modelos
results = trainer.evaluate_models(X_test, y_test)

# Obtener el mejor modelo
best_name, best_model = trainer.get_best_model(results)

Etapa 5: Evaluación del modelo

Selección de métricas de evaluación

Elegir las métricas de evaluación adecuadas es como elegir la regla adecuada, diferentes métricas son adecuadas para diferentes escenarios.

Métricas de evaluación comunes

Problemas de clasificación:

  • Exactitud (Accuracy): proporción de predicciones correctas
  • Precisión (Precision): proporción de muestras predichas como positivas que realmente son positivas
  • Recuperación (Recall): proporción de muestras realmente positivas que se predijeron correctamente como positivas
  • Puntuación F1: media armónica de precisión y recuperación

Problemas de regresión:

  • Error cuadrático medio (MSE): promedio de los cuadrados de las diferencias entre los valores predichos y los reales
  • Raíz del error cuadrático medio (RMSE): raíz cuadrada del MSE
  • Error absoluto medio (MAE): promedio de los valores absolutos de las diferencias entre los valores predichos y los reales
  • Puntuación R²: proporción de varianza explicada por el modelo

Ejemplo de evaluación del modelo

Ejemplo

# Ejemplo de evaluación de modelos
import matplotlib.pyplot as plt
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    confusion_matrix, roc_curve, auc
)

class ModelEvaluator:
    def __init__(self):
        self.evaluation_results = {}
   
    def evaluate_classification(self, y_true, y_pred, y_prob=None, model_name="Model"):
        """Evaluar modelo de clasificación"""
        results = {}
       
        # Métricas básicas
        results['accuracy'] = accuracy_score(y_true, y_pred)
        results['precision'] = precision_score(y_true, y_pred, average='weighted')
        results['recall'] = recall_score(y_true, y_pred, average='weighted')
        results['f1'] = f1_score(y_true, y_pred, average='weighted')
       
        print(f"\nResultados de evaluación de clasificación de {model_name}:")
        print(f"Exactitud: {results['accuracy']:.4f}")
        print(f"Precisión: {results['precision']:.4f}")
        print(f"Recuperación: {results['recall']:.4f}")
        print(f"Puntuación F1: {results['f1']:.4f}")
       
        # Matriz de confusión
        cm = confusion_matrix(y_true, y_pred)
        print(f"\nMatriz de confusión:")
        print(cm)
       
        # Curva ROC (si hay predicciones de probabilidad)
        if y_prob is not None and len(np.unique(y_true)) == 2:
            fpr, tpr, thresholds = roc_curve(y_true, y_prob[:, 1])
            roc_auc = auc(fpr, tpr)
            results['roc_auc'] = roc_auc
           
            # Dibujar la curva ROC
            plt.figure(figsize=(8, 6))
            plt.plot(fpr, tpr, color='darkorange', lw=2,
                    label=f'Curva ROC (AUC = {roc_auc:.2f})')
            plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
            plt.xlim([0.0, 1.0])
            plt.ylim([0.0, 1.05])
            plt.xlabel('Tasa de falsos positivos')
            plt.ylabel('Tasa de verdaderos positivos')
            plt.title(f'Curva ROC de {model_name}')
            plt.legend(loc="lower right")
            plt.grid(True)
            plt.show()
       
        self.evaluation_results[model_name] = results
        return results
   
    def evaluate_regression(self, y_true, y_pred, model_name="Model"):
        """Evaluar modelo de regresión"""
        results = {}
       
        # Métricas básicas
        mse = np.mean((y_true - y_pred) ** 2)
        rmse = np.sqrt(mse)
        mae = np.mean(np.abs(y_true - y_pred))
       
        # Puntuación R²
        ss_res = np.sum((y_true - y_pred) ** 2)
        ss_tot = np.sum((y_true - np.mean(y_true)) ** 2)
        r2 = 1 - (ss_res / ss_tot)
       
        results['mse'] = mse
        results['rmse'] = rmse
        results['mae'] = mae
        results['r2'] = r2
       
        print(f"\nResultados de evaluación de regresión de {model_name}:")
        print(f"Error cuadrático medio (MSE): {mse:.4f}")
        print(f"Raíz del error cuadrático medio (RMSE): {rmse:.4f}")
        print(f"Error absoluto medio (MAE): {mae:.4f}")
        print(f"Puntuación R²: {r2:.4f}")
       
        # Dibujar predicción vs. valor real
        plt.figure(figsize=(8, 6))
        plt.scatter(y_true, y_pred, alpha=0.6)
        plt.plot([y_true.min(), y_true.max()], [y_true.min(), y_true.max()],
                'r--', lw=2)
        plt.xlabel('Valor real')
        plt.ylabel('Valor predicho')
        plt.title(f'{model_name} predicción vs. valor real')
        plt.grid(True)
        plt.show()
       
        self.evaluation_results[model_name] = results
        return results
   
    def compare_models(self):
        """Comparar todos los modelos evaluados"""
        if not self.evaluation_results:
            print("No hay resultados de evaluación de modelos para comparar")
            return
       
        print("\nComparación de modelos:")
        print("-" * 50)
       
        # Crear tabla comparativa
        comparison_data = []
        for model_name, results in self.evaluation_results.items():
            row = [model_name]
            for metric, value in results.items():
                row.append(f"{value:.4f}")
            comparison_data.append(row)
       
        # Imprimir tabla
        headers = ["Nombre del modelo"] + list(self.evaluation_results.values())[0].keys()
        print("\t".join(headers))
        for row in comparison_data:
            print("\t".join(row))

# Ejemplo de uso
evaluator = ModelEvaluator()

# Evaluar modelo de clasificación
y_pred_class = best_model.predict(X_test)
y_prob_class = best_model.predict_proba(X_test)
evaluator.evaluate_classification(y_test, y_pred_class, y_prob_class, "Mejor modelo de clasificación")

# Comparar todos los modelos
evaluator.compare_models()

Etapa 6: Implementación del modelo

Estrategia de implementación

El despliegue de modelos es el proceso de poner un modelo en uso práctico, como llevar un producto desarrollado al mercado.

Formas de despliegue

  1. Predicción por lotes: procesar grandes volúmenes de datos periódicamente
  2. Predicción en tiempo real: servicio en línea, respuesta inmediata
  3. Despliegue integrado: integrar el modelo en sistemas existentes
  4. Despliegue en el borde: ejecutar el modelo en el dispositivo

Ejemplo de implementación del modelo

Ejemplo

# Ejemplo de despliegue de modelos
import pickle
import json
from datetime import datetime

class ModelDeployer:
    def __init__(self):
        self.deployed_models = {}
        self.deployment_logs = []
   
    def save_model(self, model, model_name, filepath=None):
        """Guardar modelo"""
        if filepath is None:
            filepath = f"{model_name}.pkl"
       
        with open(filepath, 'wb') as f:
            pickle.dump(model, f)
       
        print(f"El modelo {model_name} se ha guardado en {filepath}")
       
        # Registrar log de despliegue
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'action': 'save_model',
            'model_name': model_name,
            'filepath': filepath
        }
        self.deployment_logs.append(log_entry)
       
        return filepath
   
    def load_model(self, model_name, filepath):
        """Cargar modelo"""
        with open(filepath, 'rb') as f:
            model = pickle.load(f)
       
        self.deployed_models[model_name] = model
        print(f"El modelo {model_name} se ha cargado desde {filepath}")
       
        # Registrar log de despliegue
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'action': 'load_model',
            'model_name': model_name,
            'filepath': filepath
        }
        self.deployment_logs.append(log_entry)
       
        return model
   
    def create_prediction_service(self, model_name, encoders=None, scaler=None):
        """Crear servicio de predicción"""
        if model_name not in self.deployed_models:
            raise ValueError(f"El modelo {model_name} no está desplegado")
       
        model = self.deployed_models[model_name]
       
        def predict_service(input_data):
            """Función del servicio de predicción"""
            try:
                # Preprocesamiento de datos
                if encoders:
                    for col, encoder in encoders.items():
                        if col in input_data.columns:
                            input_data[col] = encoder.transform(input_data[col])
               
                if scaler:
                    numeric_cols = input_data.select_dtypes(include=['number']).columns
                    input_data[numeric_cols] = scaler.transform(input_data[numeric_cols])
               
                # Predicción
                prediction = model.predict(input_data)
               
                # Si es un modelo de clasificación, también devolver probabilidades
                if hasattr(model, 'predict_proba'):
                    probability = model.predict_proba(input_data)
                    return {
                        'prediction': prediction.tolist(),
                        'probability': probability.tolist(),
                        'status': 'success',
                        'timestamp': datetime.now().isoformat()
                    }
                else:
                    return {
                        'prediction': prediction.tolist(),
                        'status': 'success',
                        'timestamp': datetime.now().isoformat()
                    }
           
            except Exception as e:
                return {
                    'error': str(e),
                    'status': 'error',
                    'timestamp': datetime.now().isoformat()
                }
       
        # Registrar log de creación del servicio
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'action': 'create_service',
            'model_name': model_name
        }
        self.deployment_logs.append(log_entry)
       
        return predict_service
   
    def monitor_model(self, model_name, input_data, true_labels=None):
        """Monitorear el rendimiento del modelo"""
        if model_name not in self.deployed_models:
            raise ValueError(f"El modelo {model_name} no está desplegado")
       
        predict_service = self.create_prediction_service(model_name)
       
        # Obtener resultados de predicción
        result = predict_service(input_data)
       
        # Información de monitoreo
        monitoring_info = {
            'timestamp': datetime.now().isoformat(),
            'model_name': model_name,
            'input_shape': input_data.shape,
            'prediction_count': len(result.get('prediction', [])),
            'status': result.get('status', 'unknown')
        }
       
        # Si hay etiquetas reales, calcular métricas de rendimiento
        if true_labels is not None and 'prediction' in result:
            predictions = result['prediction']
            if len(predictions) == len(true_labels):
                accuracy = accuracy_score(true_labels, predictions)
                monitoring_info['accuracy'] = accuracy
       
        print("Información de monitoreo del modelo:")
        for key, value in monitoring_info.items():
            print(f"  {key}: {value}")
       
        return monitoring_info
   
    def get_deployment_logs(self):
        """Obtener logs de despliegue"""
        return self.deployment_logs

# Ejemplo de uso
deployer = ModelDeployer()

# Guardar el mejor modelo
model_path = deployer.save_model(best_model, "best_classification_model")

# Cargar modelo
deployer.load_model("best_classification_model", model_path)

# Crear servicio de predicción
prediction_service = deployer.create_prediction_service(
    "best_classification_model", encoders, scaler
)

# Usar el servicio de predicción
test_input = X_test.head(5)
prediction_result = prediction_service(test_input)
print("\nResultado de la predicción:")
print(json.dumps(prediction_result, indent=2, ensure_ascii=False))

# Monitorear el modelo
deployer.monitor_model("best_classification_model", test_input, y_test.head(5).values)

Ejemplo de flujo completo

Ejemplo

# Ejemplo completo de flujo de trabajo de aprendizaje automático
class MLProjectPipeline:
    def __init__(self):
        self.data_collector = DataCollector()
        self.data_preparer = None
        self.model_trainer = ModelTrainer()
        self.model_evaluator = ModelEvaluator()
        self.model_deployer = ModelDeployer()
   
    def run_complete_pipeline(self, target_column):
        """Ejecutar el pipeline completo de aprendizaje automático"""
        print("=" * 60)
        print("Flujo de trabajo completo del proyecto de aprendizaje automático")
        print("=" * 60)
       
        # 1. Recopilación de datos
        print("\nPaso 1: Recopilación de datos")
        print("-" * 30)
        user_data = self.data_collector.collect_user_data(1000)
        behavior_data = self.data_collector.collect_behavior_data(5000)
       
        # Combinar datos (ejemplo simplificado)
        merged_data = pd.merge(user_data, behavior_data, on='user_id', how='inner')
       
        # Crear la variable objetivo (ejemplo: si compró)
        merged_data['purchased'] = (merged_data['behavior_type'] == 'Compra').astype(int)
       
        # 2. Preparación de datos
        print("\nPaso 2: Preparación de datos")
        print("-" * 30)
       
        # Seleccionar columnas de características
        feature_columns = ['age', 'gender', 'city', 'duration']
        if all(col in merged_data.columns for col in feature_columns):
            data_for_ml = merged_data[feature_columns + ['purchased']].copy()
           
            # Manejar variables categóricas
            data_for_ml['gender'] = data_for_ml['gender'].map({'Masculino': 0, 'Femenino': 1})
            data_for_ml['city'] = data_for_ml['city'].map({'Pekín': 0, 'Shanghái': 1, 'Guangzhou': 2})
           
            # Preparación de datos
            self.data_preparer = DataPreparer(data_for_ml)
            splits, encoders, scaler = self.data_preparer.prepare_pipeline('purchased')
           
            # 3. Entrenamiento del modelo
            print("\nPaso 3: Entrenamiento del modelo")
            print("-" * 30)
           
            # Registrar el modelo
            self.model_trainer.register_model(
                'Regresión logística', LogisticRegression(random_state=42), 'classification'
            )
            self.model_trainer.register_model(
                'Bosque aleatorio', RandomForestClassifier(n_estimators=100, random_state=42), 'classification'
            )
           
            # Entrenar el modelo
            trained_models = self.model_trainer.train_all_models(
                splits['X_train'], splits['y_train']
            )
           
            # 4. Evaluación del modelo
            print("\nPaso 4: Evaluación del modelo")
            print("-" * 30)
           
            results = self.model_trainer.evaluate_models(
                splits['X_test'], splits['y_test']
            )
           
            best_name, best_model = self.model_trainer.get_best_model(results)
           
            # 5. Despliegue del modelo
            print("\nPaso 5: Despliegue del modelo")
            print("-" * 30)
           
            # Guardar el modelo
            model_path = self.model_deployer.save_model(best_model, "production_model")
           
            # Crear el servicio de predicción
            prediction_service = self.model_deployer.create_prediction_service(
                "production_model"
            )
           
            # Probar el servicio de predicción
            test_input = splits['X_test'].head(3)
            prediction_result = prediction_service(test_input)
           
            print("\nResultado de la prueba del servicio de predicción:")
            print(json.dumps(prediction_result, indent=2, ensure_ascii=False))
           
            print("\n" + "=" * 60)
            print("¡Flujo de trabajo del proyecto de aprendizaje automático completado!")
            print("=" * 60)
           
            return {
                'data': data_for_ml,
                'splits': splits,
                'best_model': best_model,
                'best_model_name': best_name,
                'evaluation_results': results,
                'prediction_service': prediction_service
            }
       
        else:
            print("Las columnas de datos están incompletas, no se puede continuar con el proceso")
            return None

# Ejecutar el flujo de trabajo completo
pipeline = MLProjectPipeline()
project_results = pipeline.run_complete_pipeline('purchased')
Otras extensiones