AI Project Management and Deployment

import os
import json
import pickle
import logging
from datetime import datetime
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score
import mlflow
import mlflow.sklearn

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

class AIProjectPipeline:
    def __init__(self, project_name):
        self.project_name = project_name
        self.model = None
        self.model_version = None
        self.metrics = {}
        self.config = self.load_config()
        
        # Initialize MLflow
        mlflow.set_tracking_uri("sqlite:///mlflow.db")
        mlflow.set_experiment(project_name)
    
    def load_config(self):
        """Load project configuration"""
        config = {
            "data_path": "data/",
            "model_path": "models/",
            "test_size": 0.2,
            "random_state": 42,
            "model_params": {
                "n_estimators": 100,
                "max_depth": 10,
                "random_state": 42
            }
        }
        return config
    
    def create_directories(self):
        """Create necessary directories"""
        directories = [
            self.config["data_path"],
            self.config["model_path"],
            "logs/",
            "reports/",
            "tests/"
        ]
        
        for directory in directories:
            os.makedirs(directory, exist_ok=True)
            logger.info(f"Created directory: {directory}")
    
    def generate_sample_data(self):
        """Generate sample data for demonstration"""
        np.random.seed(self.config["random_state"])
        n_samples = 1000
        
        # Generate features
        data = {
            'feature1': np.random.normal(0, 1, n_samples),
            'feature2': np.random.normal(0, 1, n_samples),
            'feature3': np.random.normal(0, 1, n_samples),
            'feature4': np.random.choice([0, 1], n_samples),
            'feature5': np.random.uniform(0, 1, n_samples)
        }
        
        # Create target with some relationship to features
        target = (
            (data['feature1'] > 0.5).astype(int) +
            (data['feature2'] < -0.5).astype(int) +
            data['feature4'] +
            (data['feature5'] > 0.7).astype(int)
        )
        target = (target > 2).astype(int)  # Binary classification
        
        df = pd.DataFrame(data)
        df['target'] = target
        
        # Save data
        data_file = os.path.join(self.config["data_path"], "sample_data.csv")
        df.to_csv(data_file, index=False)
        logger.info(f"Generated sample data: {data_file}")
        
        return df
    
    def load_data(self):
        """Load and prepare data"""
        data_file = os.path.join(self.config["data_path"], "sample_data.csv")
        
        if not os.path.exists(data_file):
            logger.info("Sample data not found, generating new data...")
            return self.generate_sample_data()
        
        df = pd.read_csv(data_file)
        logger.info(f"Loaded data: {df.shape}")
        return df
    
    def preprocess_data(self, df):
        """Preprocess data for training"""
        # Handle missing values
        df = df.dropna()
        
        # Split features and target
        X = df.drop('target', axis=1)
        y = df['target']
        
        # Split data
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, 
            test_size=self.config["test_size"],
            random_state=self.config["random_state"],
            stratify=y
        )
        
        logger.info(f"Training set: {X_train.shape}")
        logger.info(f"Testing set: {X_test.shape}")
        
        return X_train, X_test, y_train, y_test
    
    def train_model(self, X_train, y_train):
        """Train the model with MLflow tracking"""
        with mlflow.start_run():
            # Log parameters
            mlflow.log_params(self.config["model_params"])
            
            # Train model
            self.model = RandomForestClassifier(**self.config["model_params"])
            self.model.fit(X_train, y_train)
            
            # Log model
            mlflow.sklearn.log_model(self.model, "model")
            
            # Get run info
            run = mlflow.active_run()
            self.model_version = run.info.run_id
            
            logger.info(f"Model trained and logged with run ID: {self.model_version}")
    
    def evaluate_model(self, X_test, y_test):
        """Evaluate model performance"""
        if self.model is None:
            raise ValueError("Model not trained yet")
        
        # Make predictions
        y_pred = self.model.predict(X_test)
        y_pred_proba = self.model.predict_proba(X_test)[:, 1]
        
        # Calculate metrics
        self.metrics = {
            'accuracy': accuracy_score(y_test, y_pred),
            'precision': classification_report(y_test, y_pred, output_dict=True)['weighted avg']['precision'],
            'recall': classification_report(y_test, y_pred, output_dict=True)['weighted avg']['recall'],
            'f1_score': classification_report(y_test, y_pred, output_dict=True)['weighted avg']['f1-score']
        }
        
        # Log metrics to MLflow
        with mlflow.start_run(run_id=self.model_version):
            for metric_name, metric_value in self.metrics.items():
                mlflow.log_metric(metric_name, metric_value)
        
        # Print results
        logger.info("Model Evaluation Results:")
        for metric_name, metric_value in self.metrics.items():
            logger.info(f"{metric_name}: {metric_value:.4f}")
        
        return self.metrics
    
    def save_model(self):
        """Save model locally"""
        if self.model is None:
            raise ValueError("Model not trained yet")
        
        model_file = os.path.join(self.config["model_path"], f"model_v{self.model_version}.pkl")
        
        with open(model_file, 'wb') as f:
            pickle.dump(self.model, f)
        
        logger.info(f"Model saved: {model_file}")
        
        # Save model metadata
        metadata = {
            'model_version': self.model_version,
            'training_date': datetime.now().isoformat(),
            'metrics': self.metrics,
            'config': self.config
        }
        
        metadata_file = os.path.join(self.config["model_path"], f"metadata_v{self.model_version}.json")
        with open(metadata_file, 'w') as f:
            json.dump(metadata, f, indent=2)
        
        logger.info(f"Metadata saved: {metadata_file}")
    
    def generate_report(self):
        """Generate project report"""
        report = f"""
AI Project Report: {self.project_name}
Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

Model Information:
- Version: {self.model_version}
- Type: Random Forest Classifier
- Parameters: {self.config['model_params']}

Performance Metrics:
- Accuracy: {self.metrics.get('accuracy', 'N/A'):.4f}
- Precision: {self.metrics.get('precision', 'N/A'):.4f}
- Recall: {self.metrics.get('recall', 'N/A'):.4f}
- F1-Score: {self.metrics.get('f1_score', 'N/A'):.4f}

Configuration:
- Test size: {self.config['test_size']}
- Random state: {self.config['random_state']}
        """
        
        report_file = os.path.join("reports", f"report_v{self.model_version}.txt")
        with open(report_file, 'w') as f:
            f.write(report)
        
        logger.info(f"Report generated: {report_file}")
        return report
    
    def run_pipeline(self):
        """Run complete AI project pipeline"""
        logger.info(f"Starting AI project pipeline: {self.project_name}")
        
        try:
            # Create directories
            self.create_directories()
            
            # Load and preprocess data
            df = self.load_data()
            X_train, X_test, y_train, y_test = self.preprocess_data(df)
            
            # Train model
            self.train_model(X_train, y_train)
            
            # Evaluate model
            self.evaluate_model(X_test, y_test)
            
            # Save model
            self.save_model()
            
            # Generate report
            report = self.generate_report()
            
            logger.info("Pipeline completed successfully!")
            return True
            
        except Exception as e:
            logger.error(f"Pipeline failed: {str(e)}")
            return False

# Run the pipeline
if __name__ == "__main__":
    pipeline = AIProjectPipeline("Sample_AI_Project")
    success = pipeline.run_pipeline()
    
    if success:
        print("\nAI Project Pipeline completed successfully!")
        print("\nNext steps:")
        print("1. Review the generated report")
        print("2. Test the model with new data")
        print("3. Deploy the model to production")
        print("4. Set up monitoring and alerting")
        print("5. Plan model retraining schedule")
    else:
        print("\nPipeline failed. Check logs for details.")

# MLOps best practices
print("\nMLOps Best Practices:")
print("1. Version Control: Track code, data, and model versions")
print("2. Automated Testing: Test models before deployment")
print("3. Continuous Integration: Automate model training and testing")
print("4. Model Monitoring: Track model performance in production")
print("5. A/B Testing: Compare model versions systematically")
print("6. Rollback Strategy: Plan for model failures")
print("7. Documentation: Maintain clear project documentation")