How to Deploy Your First AI Model Without Breaking the Budget? Cloud vs Edge vs Local Guide for SMEs

# Simple deployment example on AWS SageMaker
import boto3
import pickle
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
import joblib
import os

class SageMakerModel:
    """
    Class to deploy sklearn model on AWS SageMaker
    """
    
    def __init__(self, model_name="sme-model-v1"):
        self.model_name = model_name
        self.sagemaker_client = boto3.client('sagemaker')
        self.s3_client = boto3.client('s3')
        self.bucket = "my-company-ai-models"
        
    def train_example_model(self):
        """
        Trains a simple model for demonstration
        """
        # Generate example data
        X, y = make_classification(
            n_samples=1000, 
            n_features=20, 
            n_informative=10,
            n_redundant=10,
            random_state=42
        )
        
        # Train model
        self.model = RandomForestClassifier(
            n_estimators=100,
            random_state=42
        )
        self.model.fit(X, y)
        
        print(f"Model trained with accuracy: {self.model.score(X, y):.3f}")
        return self.model
    
    def prepare_for_deployment(self):
        """
        Prepares model for SageMaker deployment
        """
        # Create temporary directory
        os.makedirs("model", exist_ok=True)
        
        # Save model
        model_path = "model/model.pkl"
        joblib.dump(self.model, model_path)
        
        # Create inference script
        inference_script = '''
import joblib
import numpy as np
import json

def model_fn(model_dir):
    """Load the model"""
    model = joblib.load(f"{model_dir}/model.pkl")
    return model

def predict_fn(input_data, model):
    """Make predictions"""
    # Convert input to numpy array
    if isinstance(input_data, str):
        input_data = json.loads(input_data)
    
    input_array = np.array(input_data).reshape(1, -1)
    
    # Make prediction
    prediction = model.predict(input_array)
    probability = model.predict_proba(input_array)
    
    return {
        "prediction": int(prediction[0]),
        "probability": probability[0].tolist()
    }

def input_fn(request_body, request_content_type):
    """Process input"""
    if request_content_type == "application/json":
        input_data = json.loads(request_body)
        return input_data
    else:
        raise ValueError(f"Unsupported content type: {request_content_type}")

def output_fn(prediction, content_type):
    """Process output"""
    if content_type == "application/json":
        return json.dumps(prediction)
    else:
        raise ValueError(f"Unsupported content type: {content_type}")
'''
        
        # Save inference script
        with open("model/inference.py", "w") as f:
            f.write(inference_script)
        
        # Create requirements.txt
        requirements = '''
scikit-learn==1.3.0
joblib==1.3.2
numpy==1.24.3
'''
        with open("model/requirements.txt", "w") as f:
            f.write(requirements)
        
        print("Files prepared for deployment")
    
    def upload_to_s3(self):
        """
        Uploads packaged model to S3
        """
        import tarfile
        
        # Create tarball
        tar_path = f"{self.model_name}.tar.gz"
        with tarfile.open(tar_path, "w:gz") as tar:
            tar.add("model", arcname=".")
        
        # Upload to S3
        s3_key = f"models/{self.model_name}/{tar_path}"
        
        try:
            self.s3_client.upload_file(
                tar_path, 
                self.bucket, 
                s3_key
            )
            s3_uri = f"s3://{self.bucket}/{s3_key}"
            print(f"Model uploaded to: {s3_uri}")
            return s3_uri
        except Exception as e:
            print(f"Error uploading to S3: {e}")
            return None
    
    def create_endpoint(self, s3_model_uri):
        """
        Creates SageMaker endpoint
        """
        import time
        
        # Model configuration
        model_name = f"{self.model_name}-{int(time.time())}"
        
        # Create model in SageMaker
        try:
            self.sagemaker_client.create_model(
                ModelName=model_name,
                PrimaryContainer={
                    'Image': '246618743249.dkr.ecr.us-west-2.amazonaws.com/sagemaker-scikit-learn:1.0-1-cpu-py3',
                    'ModelDataUrl': s3_model_uri,
                    'Environment': {
                        'SAGEMAKER_PROGRAM': 'inference.py',
                        'SAGEMAKER_SUBMIT_DIRECTORY': '/opt/ml/code'
                    }
                },
                ExecutionRoleArn='arn:aws:iam::ACCOUNT:role/SageMakerExecutionRole'
            )
            
            print(f"Model created: {model_name}")
            return model_name
            
        except Exception as e:
            print(f"Error creating model: {e}")
            return None
    
    def estimate_costs(self, monthly_predictions, instance_type="ml.t2.medium"):
        """
        Estimates monthly deployment costs
        """
        # Approximate AWS prices (€/hour)
        instance_prices = {
            "ml.t2.medium": 0.065,
            "ml.m5.large": 0.115,
            "ml.c5.xlarge": 0.204,
            "ml.p3.2xlarge": 3.825  # With GPU
        }
        
        hourly_price = instance_prices.get(instance_type, 0.065)
        monthly_instance_cost = hourly_price * 24 * 30
        
        # Cost per prediction (estimated)
        cost_per_prediction = 0.0001  # €0.0001 per prediction
        predictions_cost = monthly_predictions * cost_per_prediction
        
        # Additional costs
        s3_cost = 5  # €5/month storage
        transfer_cost = monthly_predictions * 0.00001  # Transfer costs
        
        total_monthly = (
            monthly_instance_cost + 
            predictions_cost + 
            s3_cost + 
            transfer_cost
        )
        
        summary = {
            "instance_type": instance_type,
            "monthly_instance_cost": monthly_instance_cost,
            "predictions_cost": predictions_cost,
            "additional_costs": s3_cost + transfer_cost,
            "total_monthly": total_monthly,
            "cost_per_prediction": total_monthly / monthly_predictions if monthly_predictions > 0 else 0
        }
        
        return summary

# Usage example
if __name__ == "__main__":
    # Initialize
    deployer = SageMakerModel("my-classification-model")
    
    # Train model
    model = deployer.train_example_model()
    
    # Prepare for deployment
    deployer.prepare_for_deployment()
    
    # Estimate costs for different scenarios
    scenarios = [
        {"name": "Small startup", "predictions": 10000},
        {"name": "Growing SME", "predictions": 100000},
        {"name": "Established company", "predictions": 1000000}
    ]
    
    print("\n=== MONTHLY COST ESTIMATION ===")
    for scenario in scenarios:
        costs = deployer.estimate_costs(scenario["predictions"])
        print(f"\n{scenario['name']} ({scenario['predictions']:,} predictions/month):")
        print(f"  • Instance: €{costs['monthly_instance_cost']:.2f}")
        print(f"  • Predictions: €{costs['predictions_cost']:.2f}")
        print(f"  • Total monthly: €{costs['total_monthly']:.2f}")
        print(f"  • Cost per prediction: €{costs['cost_per_prediction']:.6f}")

# Deployment example on Raspberry Pi with TensorFlow Lite
import tflite_runtime.interpreter as tflite
import numpy as np
import cv2
import time
import json
from flask import Flask, request, jsonify
from PIL import Image
import io
import base64

class EdgeAIModel:
    """
    Class to deploy optimized model on edge devices
    """
    
    def __init__(self, model_path="optimized_model.tflite"):
        self.model_path = model_path
        self.interpreter = None
        self.input_details = None
        self.output_details = None
        self.load_model()
        
    def load_model(self):
        """
        Loads optimized TensorFlow Lite model
        """
        try:
            # Load TensorFlow Lite interpreter
            self.interpreter = tflite.Interpreter(model_path=self.model_path)
            self.interpreter.allocate_tensors()
            
            # Get input and output details
            self.input_details = self.interpreter.get_input_details()
            self.output_details = self.interpreter.get_output_details()
            
            print(f"✅ Model loaded: {self.model_path}")
            print(f"Input shape: {self.input_details[0]['shape']}")
            print(f"Output shape: {self.output_details[0]['shape']}")
            
        except Exception as e:
            print(f"❌ Error loading model: {e}")
            self.interpreter = None
    
    def predict(self, input_data):
        """
        Makes prediction on edge device
        """
        if self.interpreter is None:
            return None
        
        try:
            # Prepare input
            input_shape = self.input_details[0]['shape']
            
            # Ensure input has correct shape
            if len(input_data.shape) != len(input_shape):
                input_data = np.expand_dims(input_data, axis=0)
            
            # Convert to expected data type
            input_dtype = self.input_details[0]['dtype']
            input_data = input_data.astype(input_dtype)
            
            # Set input tensor
            self.interpreter.set_tensor(
                self.input_details[0]['index'], 
                input_data
            )
            
            # Execute inference
            start_time = time.time()
            self.interpreter.invoke()
            inference_time = (time.time() - start_time) * 1000
            
            # Get result
            output_data = self.interpreter.get_tensor(
                self.output_details[0]['index']
            )
            
            return {
                "prediction": output_data.tolist(),
                "inference_time_ms": inference_time,
                "device": "edge"
            }
            
        except Exception as e:
            print(f"Prediction error: {e}")
            return None
    
    def process_image(self, image_path_or_bytes):
        """
        Processes image for classification/detection
        """
        try:
            # Load image
            if isinstance(image_path_or_bytes, str):
                image = cv2.imread(image_path_or_bytes)
            else:
                # Convert bytes to image
                image_pil = Image.open(io.BytesIO(image_path_or_bytes))
                image = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
            
            # Resize according to model input
            input_shape = self.input_details[0]['shape']
            height, width = input_shape[1], input_shape[2]
            
            resized_image = cv2.resize(image, (width, height))
            
            # Normalize (adjust according to training)
            normalized_image = resized_image.astype(np.float32) / 255.0
            
            return normalized_image
            
        except Exception as e:
            print(f"Image processing error: {e}")
            return None
    
    def benchmark_performance(self, num_tests=100):
        """
        Evaluates model performance on device
        """
        if self.interpreter is None:
            return None
        
        # Create test data
        input_shape = self.input_details[0]['shape']
        input_dtype = self.input_details[0]['dtype']
        
        test_data = np.random.randn(*input_shape).astype(input_dtype)
        
        times = []
        
        # Warm-up
        for _ in range(10):
            self.predict(test_data)
        
        # Real benchmark
        for _ in range(num_tests):
            start = time.time()
            result = self.predict(test_data)
            if result:
                times.append(result['inference_time_ms'])
        
        if times:
            statistics = {
                "average_time_ms": np.mean(times),
                "median_time_ms": np.median(times),
                "min_time_ms": np.min(times),
                "max_time_ms": np.max(times),
                "predictions_per_second": 1000 / np.mean(times),
                "num_tests": len(times)
            }
            
            return statistics
        
        return None

# Flask API to serve the model
app = Flask(__name__)
edge_model = EdgeAIModel()

@app.route('/predict', methods=['POST'])
def api_predict():
    """
    Endpoint for predictions via REST API
    """
    try:
        data = request.get_json()
        
        if 'image_base64' in data:
            # Process image from base64
            image_bytes = base64.b64decode(data['image_base64'])
            processed_image = edge_model.process_image(image_bytes)
            
            if processed_image is not None:
                result = edge_model.predict(processed_image)
                return jsonify(result)
            else:
                return jsonify({"error": "Image processing error"}), 400
                
        elif 'data' in data:
            # Prediction with structured data
            input_array = np.array(data['data'], dtype=np.float32)
            result = edge_model.predict(input_array)
            return jsonify(result)
        
        else:
            return jsonify({"error": "Invalid data format"}), 400
            
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/status', methods=['GET'])
def api_status():
    """
    Endpoint to check service status
    """
    status = {
        "service": "active",
        "model_loaded": edge_model.interpreter is not None,
        "timestamp": time.time()
    }
    
    # Add performance information if available
    try:
        benchmark = edge_model.benchmark_performance(10)
        if benchmark:
            status["performance"] = benchmark
    except:
        pass
    
    return jsonify(status)

@app.route('/benchmark', methods=['GET'])
def api_benchmark():
    """
    Endpoint to run performance benchmark
    """
    num_tests = request.args.get('tests', 50, type=int)
    result = edge_model.benchmark_performance(num_tests)
    
    if result:
        return jsonify(result)
    else:
        return jsonify({"error": "Could not run benchmark"}), 500

def calculate_edge_costs(devices, device_cost, power_consumption_watts=15):
    """
    Calculates operation costs for edge deployment
    """
    # Initial costs
    initial_investment = devices * device_cost
    
    # Monthly operational costs
    energy_cost_kwh = 0.15  # €0.15 per kWh (Spain average)
    hours_month = 24 * 30
    monthly_consumption_kwh = (power_consumption_watts / 1000) * hours_month
    monthly_energy_cost = monthly_consumption_kwh * energy_cost_kwh * devices
    
    # Maintenance (estimated 5% of annual value)
    monthly_maintenance_cost = (initial_investment * 0.05) / 12
    
    # Connectivity (if needed)
    connectivity_cost = devices * 25  # €25/device/month
    
    total_monthly = (
        monthly_energy_cost + 
        monthly_maintenance_cost + 
        connectivity_cost
    )
    
    return {
        "initial_investment": initial_investment,
        "monthly_energy_cost": monthly_energy_cost,
        "monthly_maintenance_cost": monthly_maintenance_cost,
        "monthly_connectivity_cost": connectivity_cost,
        "total_monthly_operational": total_monthly,
        "total_cost_year_1": initial_investment + (total_monthly * 12)
    }

if __name__ == '__main__':
    # Cost analysis example
    print("\n=== EDGE COMPUTING COST ANALYSIS ===")
    
    edge_scenarios = [
        {"name": "Prototype (1 Pi)", "devices": 1, "unit_cost": 100},
        {"name": "Small office (3 NUCs)", "devices": 3, "unit_cost": 400},
        {"name": "Retail network (10 Jetsons)", "devices": 10, "unit_cost": 200}
    ]
    
    for scenario in edge_scenarios:
        costs = calculate_edge_costs(
            scenario["devices"], 
            scenario["unit_cost"]
        )
        print(f"\n{scenario['name']}:")
        print(f"  • Initial investment: €{costs['initial_investment']:,}")
        print(f"  • Monthly operational: €{costs['total_monthly_operational']:.2f}")
        print(f"  • Total cost year 1: €{costs['total_cost_year_1']:,.2f}")
    
    # Start development server
    print("\nStarting edge AI server on port 5000...")
    app.run(host='0.0.0.0', port=5000, debug=False)

# Complete example of robust AI API using FastAPI
from fastapi import FastAPI, HTTPException, Depends, BackgroundTasks
from fastapi.middleware.cors import CORSMiddleware
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel, validator
import numpy as np
import pickle
import logging
import time
import uuid
from typing import List, Optional, Dict, Any
import redis
import json
from datetime import datetime
import asyncio

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

# Initialize FastAPI
app = FastAPI(
    title="AI API for SME",
    description="Robust API for AI model deployment",
    version="1.0.0",
    docs_url="/docs",
    redoc_url="/redoc"
)

# Configure CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Configure appropriately in production
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Configure authentication
security = HTTPBearer()

# Configure Redis for cache
try:
    redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)
    REDIS_AVAILABLE = True
except:
    REDIS_AVAILABLE = False
    logger.warning("Redis not available, cache disabled")

# Pydantic models for validation
class PredictionRequest(BaseModel):
    """Schema for prediction request"""
    data: List[float]
    model_version: Optional[str] = "v1"
    include_probabilities: Optional[bool] = False
    
    @validator('data')
    def validate_data(cls, v):
        if len(v) == 0:
            raise ValueError('Data cannot be empty')
        if len(v) > 1000:
            raise ValueError('Maximum 1000 features allowed')
        return v

class PredictionResponse(BaseModel):
    """Schema for prediction response"""
    prediction: Any
    probabilities: Optional[List[float]] = None
    confidence: float
    processing_time_ms: float
    model_version: str
    request_id: str
    timestamp: str

class BatchPredictionRequest(BaseModel):
    """Schema for batch predictions"""
    batch_data: List[List[float]]
    model_version: Optional[str] = "v1"
    
    @validator('batch_data')
    def validate_batch(cls, v):
        if len(v) == 0:
            raise ValueError('Batch cannot be empty')
        if len(v) > 100:
            raise ValueError('Maximum 100 predictions per batch')
        return v

class SystemStatus(BaseModel):
    """Schema for system status"""
    status: str
    available_models: List[str]
    api_version: str
    uptime: str
    statistics: Dict[str, Any]

# AI model simulator
class ModelManager:
    def __init__(self):
        self.models = {}
        self.statistics = {
            'total_predictions': 0,
            'average_time_ms': 0,
            'errors': 0,
            'cache_hits': 0
        }
        self.load_models()
    
    def load_models(self):
        """Simulates model loading from disk"""
        # In real implementation, load from pickle/joblib files
        self.models['v1'] = {
            'type': 'classification',
            'classes': ['class_a', 'class_b', 'class_c'],
            'num_features': 20,
            'loaded': datetime.now()
        }
        logger.info("Models loaded successfully")
    
    def predict(self, data: List[float], version: str = 'v1') -> Dict:
        """Makes prediction using specified model"""
        start_time = time.time()
        
        try:
            if version not in self.models:
                raise ValueError(f"Model {version} not found")
            
            model_info = self.models[version]
            
            # Validate dimensions
            if len(data) != model_info['num_features']:
                raise ValueError(
                    f"Expected {model_info['num_features']} features, "
                    f"received {len(data)}"
                )
            
            # Simulate prediction (in real use, use trained model)
            np.random.seed(int(sum(data) * 1000) % 2**31)
            prediction_idx = np.random.randint(0, len(model_info['classes']))
            prediction = model_info['classes'][prediction_idx]
            
            # Simulate probabilities
            probabilities = np.random.dirichlet(np.ones(len(model_info['classes'])))
            confidence = float(np.max(probabilities))
            
            processing_time = (time.time() - start_time) * 1000
            
            # Update statistics
            self.statistics['total_predictions'] += 1
            self.statistics['average_time_ms'] = (
                (self.statistics['average_time_ms'] * 
                 (self.statistics['total_predictions'] - 1) +
                 processing_time) / self.statistics['total_predictions']
            )
            
            return {
                'prediction': prediction,
                'probabilities': probabilities.tolist(),
                'confidence': confidence,
                'processing_time_ms': processing_time,
                'model_version': version
            }
            
        except Exception as e:
            self.statistics['errors'] += 1
            logger.error(f"Prediction error: {e}")
            raise

# Global model manager instance
model_manager = ModelManager()

# Utility functions
def get_cache_key(data: List[float], version: str) -> str:
    """Generates cache key for data"""
    data_str = ','.join(map(str, sorted(data)))
    return f"pred:{version}:{hash(data_str)}"

def verify_authentication(credentials: HTTPAuthorizationCredentials = Depends(security)):
    """Verifies authentication token"""
    # In real implementation, verify JWT token or API key
    token = credentials.credentials
    if token != "my-secret-token":  # Change for real validation
        raise HTTPException(status_code=401, detail="Invalid token")
    return token

def log_metrics(request_id: str, time_ms: float, success: bool):
    """Logs API metrics"""
    logger.info(
        f"Request {request_id}: {time_ms:.2f}ms, "
        f"success: {success}"
    )

# API endpoints
@app.get("/", response_model=Dict[str, str])
async def root():
    """Root endpoint with basic information"""
    return {
        "message": "AI API for SME",
        "version": "1.0.0",
        "documentation": "/docs"
    }

@app.get("/status", response_model=SystemStatus)
async def get_status():
    """Gets current system status"""
    return SystemStatus(
        status="active",
        available_models=list(model_manager.models.keys()),
        api_version="1.0.0",
        uptime=str(datetime.now()),
        statistics=model_manager.statistics
    )

@app.post("/predict", response_model=PredictionResponse)
async def predict(
    request: PredictionRequest,
    background_tasks: BackgroundTasks,
    token: str = Depends(verify_authentication)
):
    """Makes individual prediction"""
    request_id = str(uuid.uuid4())
    start_time = time.time()
    
    try:
        # Check cache
        cache_key = get_cache_key(request.data, request.model_version)
        cached_result = None
        
        if REDIS_AVAILABLE:
            try:
                cached_result = redis_client.get(cache_key)
                if cached_result:
                    model_manager.statistics['cache_hits'] += 1
                    result = json.loads(cached_result)
                    result['request_id'] = request_id
                    result['timestamp'] = datetime.now().isoformat()
                    return PredictionResponse(**result)
            except Exception as e:
                logger.warning(f"Cache error: {e}")
        
        # Make prediction
        result = model_manager.predict(
            request.data, 
            request.model_version
        )
        
        # Prepare response
        response = PredictionResponse(
            prediction=result['prediction'],
            probabilities=result['probabilities'] if request.include_probabilities else None,
            confidence=result['confidence'],
            processing_time_ms=result['processing_time_ms'],
            model_version=result['model_version'],
            request_id=request_id,
            timestamp=datetime.now().isoformat()
        )
        
        # Save to cache
        if REDIS_AVAILABLE:
            try:
                redis_client.setex(
                    cache_key, 
                    300,  # 5 minutes TTL
                    json.dumps(response.dict())
                )
            except Exception as e:
                logger.warning(f"Error saving cache: {e}")
        
        # Log metrics in background
        total_time = (time.time() - start_time) * 1000
        background_tasks.add_task(
            log_metrics, 
            request_id, 
            total_time, 
            True
        )
        
        return response
        
    except Exception as e:
        total_time = (time.time() - start_time) * 1000
        background_tasks.add_task(
            log_metrics, 
            request_id, 
            total_time, 
            False
        )
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/predict/batch")
async def predict_batch(
    request: BatchPredictionRequest,
    token: str = Depends(verify_authentication)
):
    """Makes batch predictions"""
    request_id = str(uuid.uuid4())
    start_time = time.time()
    
    try:
        results = []
        
        for i, data in enumerate(request.batch_data):
            try:
                result = model_manager.predict(
                    data, 
                    request.model_version
                )
                results.append({
                    'index': i,
                    'success': True,
                    'prediction': result['prediction'],
                    'confidence': result['confidence']
                })
            except Exception as e:
                results.append({
                    'index': i,
                    'success': False,
                    'error': str(e)
                })
        
        total_time = (time.time() - start_time) * 1000
        
        return {
            'request_id': request_id,
            'total_processed': len(request.batch_data),
            'successful': sum(1 for r in results if r['success']),
            'total_time_ms': total_time,
            'results': results
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/metrics")
async def get_metrics(token: str = Depends(verify_authentication)):
    """Gets detailed system metrics"""
    return {
        'global_statistics': model_manager.statistics,
        'active_models': len(model_manager.models),
        'cache_available': REDIS_AVAILABLE,
        'timestamp': datetime.now().isoformat()
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "main:app", 
        host="0.0.0.0", 
        port=8000, 
        reload=True,
        log_level="info"
    )

# Tool for AI cost analysis and optimization
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

class AICostOptimizer:
    """
    Tool to analyze and optimize AI deployment costs
    """
    
    def __init__(self):
        self.scenarios = []
        self.usage_metrics = []
        
    def add_scenario(self, name, type, config):
        """
        Adds deployment scenario for comparison
        """
        scenario = {
            'name': name,
            'type': type,
            'config': config,
            'calculated_costs': None
        }
        
        if type == 'cloud':
            scenario['calculated_costs'] = self._calculate_cloud_costs(config)
        elif type == 'edge':
            scenario['calculated_costs'] = self._calculate_edge_costs(config)
        elif type == 'local':
            scenario['calculated_costs'] = self._calculate_local_costs(config)
        
        self.scenarios.append(scenario)
        
    def _calculate_cloud_costs(self, config):
        """
        Calculates costs for cloud deployment
        """
        # Base instance cost
        instance_types = {
            'small': {'hourly_cost': 0.1, 'predictions_per_hour': 1000},
            'medium': {'hourly_cost': 0.3, 'predictions_per_hour': 5000},
            'large': {'hourly_cost': 0.8, 'predictions_per_hour': 15000},
            'xlarge': {'hourly_cost': 2.0, 'predictions_per_hour': 50000}
        }
        
        instance_type = config.get('instance_type', 'medium')
        instance_info = instance_types[instance_type]
        
        monthly_predictions = config.get('monthly_predictions', 100000)
        
        # Calculate needed instances
        predictions_per_hour = monthly_predictions / (30 * 24)
        needed_instances = max(1, np.ceil(predictions_per_hour / instance_info['predictions_per_hour']))
        
        # Monthly costs
        compute_cost = needed_instances * instance_info['hourly_cost'] * 24 * 30
        storage_cost = config.get('storage_gb', 100) * 0.025  # €0.025/GB/month
        transfer_cost = monthly_predictions * 0.00001  # €0.00001/request
        load_balancer_cost = 25 if needed_instances > 1 else 0
        
        # Additional costs
        monitoring_cost = 15
        backup_cost = 10
        
        total_monthly = (
            compute_cost + storage_cost + transfer_cost + 
            load_balancer_cost + monitoring_cost + backup_cost
        )
        
        return {
            'needed_instances': needed_instances,
            'compute_cost': compute_cost,
            'storage_cost': storage_cost,
            'transfer_cost': transfer_cost,
            'additional_costs': load_balancer_cost + monitoring_cost + backup_cost,
            'total_monthly': total_monthly,
            'cost_per_prediction': total_monthly / monthly_predictions if monthly_predictions > 0 else 0
        }
    
    def _calculate_edge_costs(self, config):
        """
        Calculates costs for edge deployment
        """
        devices = config.get('devices', 1)
        cost_per_device = config.get('device_cost', 300)
        
        # Initial investment
        initial_investment = devices * cost_per_device
        
        # Monthly operational costs
        power_consumption_watts = config.get('power_consumption_watts', 20)
        energy_cost_kwh = 0.15
        hours_month = 24 * 30
        
        energy_cost = (power_consumption_watts / 1000) * hours_month * energy_cost_kwh * devices
        connectivity_cost = devices * config.get('monthly_connectivity', 30)
        maintenance_cost = (initial_investment * 0.05) / 12  # 5% annually
        
        total_monthly = energy_cost + connectivity_cost + maintenance_cost
        
        # 3-year amortization
        monthly_amortization = initial_investment / 36
        total_monthly_cost = total_monthly + monthly_amortization
        
        return {
            'initial_investment': initial_investment,
            'energy_cost': energy_cost,
            'connectivity_cost': connectivity_cost,
            'maintenance_cost': maintenance_cost,
            'total_operational': total_monthly,
            'monthly_amortization': monthly_amortization,
            'total_monthly': total_monthly_cost
        }
    
    def _calculate_local_costs(self, config):
        """
        Calculates costs for local infrastructure
        """
        # Initial hardware
        server_cost = config.get('server_cost', 8000)
        gpu_cost = config.get('gpu_cost', 5000) if config.get('with_gpu', False) else 0
        networking_cost = config.get('networking_cost', 1000)
        
        initial_investment = server_cost + gpu_cost + networking_cost
        
        # Operational costs
        power_consumption_watts = config.get('power_consumption_watts', 300)
        energy_cost = (power_consumption_watts / 1000) * 24 * 30 * 0.15
        cooling_cost = energy_cost * 0.3  # 30% additional for cooling
        
        # IT personnel (fraction of time dedicated)
        it_time_fraction = config.get('it_time_fraction', 0.2)  # 20% of time
        monthly_it_salary = config.get('monthly_it_salary', 4000)
        personnel_cost = monthly_it_salary * it_time_fraction
        
        # Maintenance and insurance
        maintenance_cost = (initial_investment * 0.08) / 12  # 8% annually
        insurance_cost = (initial_investment * 0.02) / 12  # 2% annually
        
        total_operational = (
            energy_cost + cooling_cost + personnel_cost + 
            maintenance_cost + insurance_cost
        )
        
        # 5-year amortization
        monthly_amortization = initial_investment / 60
        total_monthly = total_operational + monthly_amortization
        
        return {
            'initial_investment': initial_investment,
            'energy_cooling_cost': energy_cost + cooling_cost,
            'personnel_cost': personnel_cost,
            'maintenance_insurance_cost': maintenance_cost + insurance_cost,
            'total_operational': total_operational,
            'monthly_amortization': monthly_amortization,
            'total_monthly': total_monthly
        }
    
    def compare_scenarios(self):
        """
        Compares all added scenarios
        """
        if not self.scenarios:
            return "No scenarios to compare"
        
        comparison = pd.DataFrame()
        
        for scenario in self.scenarios:
            costs = scenario['calculated_costs']
            row = {
                'Scenario': scenario['name'],
                'Type': scenario['type'],
                'Initial Investment (€)': costs.get('initial_investment', 0),
                'Monthly Cost (€)': costs['total_monthly'],
                'Annual Cost (€)': costs['total_monthly'] * 12,
                'TCO 3 years (€)': costs.get('initial_investment', 0) + (costs['total_monthly'] * 36)
            }
            comparison = pd.concat([comparison, pd.DataFrame([row])], ignore_index=True)
        
        return comparison
    
    def find_breakeven_point(self, scenario1, scenario2):
        """
        Finds breakeven point between two scenarios
        """
        s1 = next((s for s in self.scenarios if s['name'] == scenario1), None)
        s2 = next((s for s in self.scenarios if s['name'] == scenario2), None)
        
        if not s1 or not s2:
            return "Scenarios not found"
        
        # Calculate differences
        initial_diff = s1['calculated_costs'].get('initial_investment', 0) - s2['calculated_costs'].get('initial_investment', 0)
        monthly_diff = s1['calculated_costs']['total_monthly'] - s2['calculated_costs']['total_monthly']
        
        if monthly_diff == 0:
            return "Monthly costs are equal, no breakeven point"
        
        # Breakeven point in months
        breakeven_months = -initial_diff / monthly_diff
        
        return {
            'breakeven_months': max(0, breakeven_months),
            'breakeven_years': max(0, breakeven_months / 12),
            'recommendation': scenario1 if breakeven_months < 24 else scenario2
        }
    
    def optimize_for_volume(self, target_predictions):
        """
        Recommends best option for specific volume
        """
        recommendations = []
        
        # Base scenarios for different volumes
        if target_predictions < 50000:  # Low volume
            recommendations.append({
                'option': 'Edge Computing',
                'reason': 'Low fixed costs, ideal for small volumes',
                'suggested_config': {
                    'devices': 1,
                    'type': 'Raspberry Pi + Neural Stick',
                    'estimated_cost': '€100-200 initial + €50/month operational'
                }
            })
        
        elif target_predictions < 500000:  # Medium volume
            recommendations.append({
                'option': 'Hybrid Cloud',
                'reason': 'Flexibility for spikes, moderate costs',
                'suggested_config': {
                    'base_instance': 'medium',
                    'auto_scaling': True,
                    'estimated_cost': '€200-800/month depending on usage'
                }
            })
        
        else:  # High volume
            recommendations.append({
                'option': 'Local Infrastructure',
                'reason': 'Economies of scale, total control',
                'suggested_config': {
                    'dedicated_server': True,
                    'specialized_gpu': True,
                    'estimated_cost': '€15,000 initial + €800/month operational'
                }
            })
        
        return recommendations

# Usage example
if __name__ == "__main__":
    optimizer = AICostOptimizer()
    
    # Add scenarios for comparison
    optimizer.add_scenario(
        'AWS Cloud Medium',
        'cloud',
        {
            'instance_type': 'medium',
            'monthly_predictions': 200000,
            'storage_gb': 100
        }
    )
    
    optimizer.add_scenario(
        'Edge Jetson',
        'edge',
        {
            'devices': 3,
            'device_cost': 250,
            'power_consumption_watts': 15,
            'monthly_connectivity': 25
        }
    )
    
    optimizer.add_scenario(
        'Local Server',
        'local',
        {
            'server_cost': 8000,
            'with_gpu': True,
            'gpu_cost': 4000,
            'power_consumption_watts': 400,
            'it_time_fraction': 0.15
        }
    )
    
    # Compare scenarios
    comparison = optimizer.compare_scenarios()
    print("=== SCENARIO COMPARISON ===")
    print(comparison.to_string(index=False))
    
    # Find breakeven point
    breakeven = optimizer.find_breakeven_point('AWS Cloud Medium', 'Local Server')
    print(f"\n=== BREAKEVEN POINT ===")
    print(f"Cloud vs Local: {breakeven['breakeven_months']:.1f} months")
    print(f"Recommendation: {breakeven['recommendation']}")
    
    # Volume optimization
    print("\n=== RECOMMENDATIONS BY VOLUME ===")
    for volume in [25000, 250000, 2500000]:
        recs = optimizer.optimize_for_volume(volume)
        print(f"\n{volume:,} predictions/month:")
        for rec in recs:
            print(f"  Option: {rec['option']}")
            print(f"  Reason: {rec['reason']}")
            print(f"  Cost: {rec['suggested_config']['estimated_cost']}")