Comprehensive comparison for AI technology in applications

import boto3
import sagemaker
from sagemaker.sklearn.estimator import SKLearn
from sagemaker.sklearn.model import SKLearnModel
from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer
from sagemaker.deserializers import JSONDeserializer
import json
import time

class FraudDetectionPipeline:
    """
    Production-ready fraud detection pipeline using SageMaker.
    Trains a model, deploys it, and provides prediction capabilities.
    """
    
    def __init__(self, role_arn, bucket_name, region='us-east-1'):
        self.role = role_arn
        self.bucket = bucket_name
        self.region = region
        self.session = sagemaker.Session()
        self.endpoint_name = None
        
    def train_model(self, training_data_s3_path, instance_type='ml.m5.xlarge'):
        """
        Train fraud detection model using scikit-learn on SageMaker.
        """
        try:
            estimator = SKLearn(
                entry_point='train.py',
                role=self.role,
                instance_type=instance_type,
                instance_count=1,
                framework_version='1.0-1',
                py_version='py3',
                hyperparameters={
                    'n_estimators': 100,
                    'max_depth': 10,
                    'random_state': 42
                },
                sagemaker_session=self.session,
                tags=[{'Key': 'Project', 'Value': 'FraudDetection'}]
            )
            
            estimator.fit({'train': training_data_s3_path}, wait=True)
            print(f"Model training completed: {estimator.model_data}")
            return estimator
            
        except Exception as e:
            print(f"Training failed: {str(e)}")
            raise
    
    def deploy_model(self, estimator, instance_type='ml.t2.medium'):
        """
        Deploy trained model to a SageMaker endpoint with error handling.
        """
        try:
            self.endpoint_name = f"fraud-detection-{int(time.time())}"
            
            predictor = estimator.deploy(
                initial_instance_count=1,
                instance_type=instance_type,
                endpoint_name=self.endpoint_name,
                serializer=CSVSerializer(),
                deserializer=JSONDeserializer(),
                wait=True
            )
            
            print(f"Model deployed to endpoint: {self.endpoint_name}")
            return predictor
            
        except Exception as e:
            print(f"Deployment failed: {str(e)}")
            self._cleanup_failed_endpoint()
            raise
    
    def predict(self, transaction_data):
        """
        Make fraud prediction with validation and error handling.
        """
        if not self.endpoint_name:
            raise ValueError("No endpoint available. Deploy model first.")
        
        try:
            runtime = boto3.client('sagemaker-runtime', region_name=self.region)
            
            response = runtime.invoke_endpoint(
                EndpointName=self.endpoint_name,
                ContentType='text/csv',
                Body=transaction_data
            )
            
            result = json.loads(response['Body'].read().decode())
            return {
                'is_fraud': result['prediction'],
                'confidence': result['probability'],
                'endpoint': self.endpoint_name
            }
            
        except Exception as e:
            print(f"Prediction failed: {str(e)}")
            return {'error': str(e), 'is_fraud': None}
    
    def _cleanup_failed_endpoint(self):
        """Clean up resources if deployment fails."""
        if self.endpoint_name:
            try:
                sm_client = boto3.client('sagemaker', region_name=self.region)
                sm_client.delete_endpoint(EndpointName=self.endpoint_name)
            except:
                pass
    
    def delete_endpoint(self):
        """Delete endpoint to stop incurring costs."""
        if self.endpoint_name:
            sm_client = boto3.client('sagemaker', region_name=self.region)
            sm_client.delete_endpoint(EndpointName=self.endpoint_name)
            print(f"Endpoint {self.endpoint_name} deleted successfully")