Implementation Hints

• For Flask API: Use @app.route('/predict', methods=['POST']) decorator
• For Dockerfile: Start with FROM python:3.9-slim base image
• For requirements: Include Flask==2.0.1, scikit-learn==1.0.2, gunicorn==20.1.0
• For Kubernetes: Use kubectl apply -f deployment.yaml to deploy
• For CI/CD: GitHub Actions uses YAML files in .github/workflows/

Complete Solution:

# COMPLETE SOLUTION FOR MODEL DEPLOYMENT

# PART 2: FLASK API SOLUTION (app.py)
from flask import Flask, request, jsonify
import joblib
import numpy as np
import pandas as pd
import logging

app = Flask(__name__)

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

# Load model and metadata
try:
    model = joblib.load('model.joblib')
    with open('model_metadata.json', 'r') as f:
        metadata = json.load(f)
    logger.info(f"Model loaded: {metadata['model_type']} v{metadata['version']}")
except Exception as e:
    logger.error(f"Failed to load model: {str(e)}")
    raise

@app.route('/health', methods=['GET'])
def health_check():
    """Health check endpoint"""
    return jsonify({
        'status': 'healthy',
        'model_version': metadata['version'],
        'model_type': metadata['model_type']
    })

@app.route('/predict', methods=['POST'])
def predict():
    """Single prediction endpoint"""
    try:
        # Get and validate input
        data = request.get_json()
        
        if 'features' not in data:
            return jsonify({'error': 'Missing features field'}), 400
        
        features = np.array(data['features']).reshape(1, -1)
        
        # Validate feature dimensions
        if features.shape[1] != 20:
            return jsonify({'error': f'Expected 20 features, got {features.shape[1]}'}), 400
        
        # Make prediction
        prediction = model.predict(features)[0]
        probabilities = model.predict_proba(features)[0].tolist()
        
        # Log prediction
        logger.info(f"Prediction made: {prediction}")
        
        return jsonify({
            'prediction': int(prediction),
            'probabilities': probabilities,
            'model_version': metadata['version'],
            'status': 'success'
        })
    
    except Exception as e:
        logger.error(f"Prediction error: {str(e)}")
        return jsonify({'error': str(e), 'status': 'error'}), 500

@app.route('/batch_predict', methods=['POST'])
def batch_predict():
    """Batch prediction endpoint"""
    try:
        data = request.get_json()
        
        if 'features' not in data:
            return jsonify({'error': 'Missing features field'}), 400
        
        features = np.array(data['features'])
        
        if features.shape[1] != 20:
            return jsonify({'error': f'Expected 20 features per sample, got {features.shape[1]}'}), 400
        
        predictions = model.predict(features).tolist()
        probabilities = model.predict_proba(features).tolist()
        
        logger.info(f"Batch prediction: {len(predictions)} samples")
        
        return jsonify({
            'predictions': predictions,
            'probabilities': probabilities,
            'count': len(predictions),
            'model_version': metadata['version'],
            'status': 'success'
        })
    
    except Exception as e:
        logger.error(f"Batch prediction error: {str(e)}")
        return jsonify({'error': str(e), 'status': 'error'}), 500

@app.route('/model_info', methods=['GET'])
def model_info():
    """Get model information"""
    return jsonify(metadata)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)

# PART 3: DOCKERFILE SOLUTION
"""
FROM python:3.9-slim

# Install system dependencies
RUN apt-get update && apt-get install -y \
    gcc \
    g++ \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Set working directory
WORKDIR /app

# Copy requirements and install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application files
COPY app.py .
COPY model.joblib .
COPY model_metadata.json .

# Create non-root user
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

# Expose port
EXPOSE 5000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:5000/health || exit 1

# Run with Gunicorn
CMD ["gunicorn", "--bind", "0.0.0.0:5000", \
     "--workers", "4", \
     "--worker-class", "sync", \
     "--access-logfile", "-", \
     "--error-logfile", "-", \
     "app:app"]
"""

# PART 4: REQUIREMENTS.TXT SOLUTION
"""
Flask==2.0.1
scikit-learn==1.0.2
numpy==1.21.2
pandas==1.3.3
joblib==1.1.0
gunicorn==20.1.0
"""

# PART 5: KUBERNETES DEPLOYMENT.YAML SOLUTION
"""
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-model-deployment
  labels:
    app: ml-model
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-model
  template:
    metadata:
      labels:
        app: ml-model
    spec:
      containers:
      - name: ml-api
        image: your-registry/ml-model:1.0.0
        ports:
        - containerPort: 5000
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 5000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 5000
          initialDelaySeconds: 5
          periodSeconds: 5
        env:
        - name: MODEL_VERSION
          value: "1.0.0"
        - name: LOG_LEVEL
          value: "INFO"
---
apiVersion: v1
kind: Service
metadata:
  name: ml-model-service
spec:
  selector:
    app: ml-model
  ports:
  - port: 80
    targetPort: 5000
  type: LoadBalancer
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ml-model-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ml-model-deployment
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
"""

print("Complete deployment solution ready!")

Your Score: 0/10