Enterprise AI Infrastructure

from mlflow import MlflowClient
import kubernetes as k8s

def deploy_model(model_name, version):
    # Load model from registry
    client = MlflowClient()
    model = client.get_model_version(model_name, version)
    
    # Create K8s deployment
    deployment = k8s.client.V1Deployment(
        metadata=k8s.client.V1ObjectMeta(name=f"{model_name}-{version}"),
        spec=k8s.client.V1DeploymentSpec(
            replicas=3,
            selector={"matchLabels": {"app": model_name}},
            template={
                "metadata": {"labels": {"app": model_name}},
                "spec": {
                    "containers": [{
                        "name": model_name,
                        "image": f"registry/{model_name}:{version}",
                        "resources": {
                            "limits": {"memory": "2Gi", "cpu": "1"},
                            "requests": {"memory": "1Gi", "cpu": "0.5"}
                        }
                    }]
                }
            }
        )
    )
    
    # Apply deployment
    k8s.client.AppsV1Api().create_namespaced_deployment(
        namespace="production",
        body=deployment
    )

from prometheus_client import Counter, Histogram
import time

# Define metrics
prediction_counter = Counter('model_predictions_total', 'Total number of predictions')
latency_histogram = Histogram('prediction_latency_seconds', 'Prediction latency')
accuracy_gauge = Gauge('model_accuracy', 'Model accuracy score')

def monitor_prediction(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        
        # Execute prediction
        result = func(*args, **kwargs)
        
        # Record metrics
        prediction_counter.inc()
        latency_histogram.observe(time.time() - start_time)
        
        return result
    return wrapper

@monitor_prediction
def predict(input_data):
    # Model prediction logic
    prediction = model.predict(input_data)
    return prediction