Comprehensive comparison for AI technology in applications

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
import pandas as pd
import numpy as np
from typing import Dict, Any
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class CustomerChurnPredictor:
    def __init__(self, experiment_name: str = "customer_churn_prediction"):
        self.experiment_name = experiment_name
        mlflow.set_experiment(experiment_name)
        
    def train_and_log_model(self, data: pd.DataFrame, 
                           hyperparameters: Dict[str, Any]) -> str:
        try:
            with mlflow.start_run(run_name="churn_rf_model") as run:
                mlflow.set_tag("model_type", "RandomForest")
                mlflow.set_tag("use_case", "customer_churn")
                
                X = data.drop(['customer_id', 'churned'], axis=1)
                y = data['churned']
                
                X_train, X_test, y_train, y_test = train_test_split(
                    X, y, test_size=0.2, random_state=42, stratify=y
                )
                
                mlflow.log_param("train_samples", len(X_train))
                mlflow.log_param("test_samples", len(X_test))
                mlflow.log_param("n_estimators", hyperparameters.get('n_estimators', 100))
                mlflow.log_param("max_depth", hyperparameters.get('max_depth', 10))
                mlflow.log_param("min_samples_split", hyperparameters.get('min_samples_split', 2))
                
                model = RandomForestClassifier(
                    n_estimators=hyperparameters.get('n_estimators', 100),
                    max_depth=hyperparameters.get('max_depth', 10),
                    min_samples_split=hyperparameters.get('min_samples_split', 2),
                    random_state=42,
                    n_jobs=-1
                )
                
                logger.info("Training model...")
                model.fit(X_train, y_train)
                
                y_pred = model.predict(X_test)
                
                accuracy = accuracy_score(y_test, y_pred)
                precision = precision_score(y_test, y_pred, zero_division=0)
                recall = recall_score(y_test, y_pred, zero_division=0)
                f1 = f1_score(y_test, y_pred, zero_division=0)
                
                mlflow.log_metric("accuracy", accuracy)
                mlflow.log_metric("precision", precision)
                mlflow.log_metric("recall", recall)
                mlflow.log_metric("f1_score", f1)
                
                feature_importance = pd.DataFrame({
                    'feature': X.columns,
                    'importance': model.feature_importances_
                }).sort_values('importance', ascending=False)
                
                feature_importance.to_csv('feature_importance.csv', index=False)
                mlflow.log_artifact('feature_importance.csv')
                
                mlflow.sklearn.log_model(
                    model, 
                    "model",
                    registered_model_name="churn_predictor",
                    input_example=X_train.head(1)
                )
                
                logger.info(f"Model logged successfully. Run ID: {run.info.run_id}")
                return run.info.run_id
                
        except Exception as e:
            logger.error(f"Error during model training: {str(e)}")
            raise

if __name__ == "__main__":
    np.random.seed(42)
    sample_data = pd.DataFrame({
        'customer_id': range(1000),
        'tenure_months': np.random.randint(1, 72, 1000),
        'monthly_charges': np.random.uniform(20, 120, 1000),
        'total_charges': np.random.uniform(100, 8000, 1000),
        'contract_type': np.random.choice([0, 1, 2], 1000),
        'churned': np.random.choice([0, 1], 1000, p=[0.7, 0.3])
    })
    
    predictor = CustomerChurnPredictor()
    hyperparams = {'n_estimators': 150, 'max_depth': 15, 'min_samples_split': 5}
    run_id = predictor.train_and_log_model(sample_data, hyperparams)
    print(f"Training complete. MLflow Run ID: {run_id}")