Comprehensive comparison for AI technology in ML Framework applications

import lightgbm as lgb
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
import joblib
import logging
from typing import Tuple, Optional
import json

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

class ProductDemandPredictor:
    """Production-grade LightGBM model for predicting product demand."""
    
    def __init__(self, model_path: Optional[str] = None):
        self.model = None
        self.feature_names = None
        if model_path:
            self.load_model(model_path)
    
    def prepare_features(self, df: pd.DataFrame) -> pd.DataFrame:
        """Engineer features for demand prediction."""
        try:
            df = df.copy()
            df['day_of_week'] = pd.to_datetime(df['date']).dt.dayofweek
            df['month'] = pd.to_datetime(df['date']).dt.month
            df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
            df['price_discount_ratio'] = df['discount'] / (df['price'] + 1e-6)
            df['stock_price_ratio'] = df['stock_level'] / (df['price'] + 1e-6)
            return df
        except Exception as e:
            logger.error(f"Feature engineering failed: {str(e)}")
            raise
    
    def train(self, X: pd.DataFrame, y: pd.Series, validation_split: float = 0.2) -> dict:
        """Train LightGBM model with best practices."""
        try:
            X_train, X_val, y_train, y_val = train_test_split(
                X, y, test_size=validation_split, random_state=42
            )
            
            self.feature_names = X.columns.tolist()
            
            train_data = lgb.Dataset(X_train, label=y_train, feature_name=self.feature_names)
            val_data = lgb.Dataset(X_val, label=y_val, reference=train_data)
            
            params = {
                'objective': 'regression',
                'metric': 'rmse',
                'boosting_type': 'gbdt',
                'num_leaves': 31,
                'learning_rate': 0.05,
                'feature_fraction': 0.8,
                'bagging_fraction': 0.8,
                'bagging_freq': 5,
                'verbose': -1,
                'min_child_samples': 20,
                'reg_alpha': 0.1,
                'reg_lambda': 0.1
            }
            
            self.model = lgb.train(
                params,
                train_data,
                num_boost_round=1000,
                valid_sets=[train_data, val_data],
                valid_names=['train', 'valid'],
                callbacks=[lgb.early_stopping(stopping_rounds=50), lgb.log_evaluation(period=100)]
            )
            
            y_pred = self.model.predict(X_val, num_iteration=self.model.best_iteration)
            rmse = np.sqrt(mean_squared_error(y_val, y_pred))
            r2 = r2_score(y_val, y_pred)
            
            metrics = {'rmse': float(rmse), 'r2': float(r2), 'best_iteration': self.model.best_iteration}
            logger.info(f"Training completed. Metrics: {json.dumps(metrics)}")
            
            return metrics
            
        except Exception as e:
            logger.error(f"Training failed: {str(e)}")
            raise
    
    def predict(self, X: pd.DataFrame) -> np.ndarray:
        """Make predictions with error handling."""
        if self.model is None:
            raise ValueError("Model not trained or loaded")
        
        try:
            if not all(col in X.columns for col in self.feature_names):
                raise ValueError(f"Missing required features: {self.feature_names}")
            
            predictions = self.model.predict(X[self.feature_names], num_iteration=self.model.best_iteration)
            return np.maximum(predictions, 0)
            
        except Exception as e:
            logger.error(f"Prediction failed: {str(e)}")
            raise
    
    def save_model(self, path: str) -> None:
        """Save model and metadata."""
        if self.model is None:
            raise ValueError("No model to save")
        
        self.model.save_model(path)
        joblib.dump(self.feature_names, f"{path}.features")
        logger.info(f"Model saved to {path}")
    
    def load_model(self, path: str) -> None:
        """Load model and metadata."""
        try:
            self.model = lgb.Booster(model_file=path)
            self.feature_names = joblib.load(f"{path}.features")
            logger.info(f"Model loaded from {path}")
        except Exception as e:
            logger.error(f"Model loading failed: {str(e)}")
            raise

if __name__ == "__main__":
    np.random.seed(42)
    df = pd.DataFrame({
        'date': pd.date_range('2023-01-01', periods=1000),
        'price': np.random.uniform(10, 100, 1000),
        'discount': np.random.uniform(0, 20, 1000),
        'stock_level': np.random.randint(0, 500, 1000),
        'demand': np.random.randint(10, 200, 1000)
    })
    
    predictor = ProductDemandPredictor()
    df_features = predictor.prepare_features(df)
    X = df_features[['price', 'discount', 'stock_level', 'day_of_week', 'month', 'is_weekend', 'price_discount_ratio', 'stock_price_ratio']]
    y = df_features['demand']
    
    metrics = predictor.train(X, y)
    predictions = predictor.predict(X.head(10))
    logger.info(f"Sample predictions: {predictions[:5]}")
    
    predictor.save_model('demand_model.txt')