Machine Learning mit Python: Integration in Django

Machine Learning in der Produktion

Die Integration von Machine-Learning-Modellen in eine Django-Webanwendung ermöglicht es, den Benutzern intelligente Funktionen anzubieten. Schauen wir uns an, wie man das richtig macht.

1. Systemarchitektur

Es gibt verschiedene Ansätze zur Integration von ML in Django:

• Inline-Modell: direkt in der Django-App geladen
• Microservice: separate API für Vorhersagen
• Celery-Tasks: für asynchrone Vorhersagen

2. Modellvorbereitung

Training mit scikit-learn

import joblib
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Daten vorbereiten
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Modell trainieren
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Evaluieren
accuracy = model.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2%}")

# Modell speichern
joblib.dump(model, 'models/classifier.joblib')

3. Vorhersage-Service in Django

# ml_service.py
import joblib
import numpy as np
from django.conf import settings
import os

class MLService:
    _instance = None
    _model = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    @property
    def model(self):
        if self._model is None:
            model_path = os.path.join(settings.BASE_DIR, 'models', 'classifier.joblib')
            self._model = joblib.load(model_path)
        return self._model

    def predict(self, features: list) -> dict:
        """Führt eine Vorhersage durch"""
        X = np.array(features).reshape(1, -1)
        prediction = self.model.predict(X)[0]
        probabilities = self.model.predict_proba(X)[0]

        return {
            'prediction': int(prediction),
            'confidence': float(max(probabilities)),
            'probabilities': probabilities.tolist()
        }

# Singleton
ml_service = MLService()

4. API-View für Vorhersagen

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .ml_service import ml_service

class PredictionView(APIView):
    def post(self, request):
        features = request.data.get('features')

        if not features:
            return Response(
                {'error': 'Features erforderlich'},
                status=status.HTTP_400_BAD_REQUEST
            )

        try:
            result = ml_service.predict(features)
            return Response(result)
        except Exception as e:
            return Response(
                {'error': str(e)},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )

5. Asynchrone Vorhersagen mit Celery

# tasks.py
from celery import shared_task
from .ml_service import ml_service
from .models import PredictionResult

@shared_task
def async_prediction(prediction_id, features):
    """Celery-Task für aufwendige Vorhersagen"""
    result = ml_service.predict(features)

    # Ergebnis speichern
    PredictionResult.objects.filter(id=prediction_id).update(
        prediction=result['prediction'],
        confidence=result['confidence'],
        status='completed'
    )

    return result

6. TensorFlow-Integration

import tensorflow as tf

class TensorFlowService:
    def __init__(self):
        self.model = tf.keras.models.load_model('models/neural_network.h5')

    def predict(self, image_path):
        # Bild vorverarbeiten
        img = tf.keras.preprocessing.image.load_img(
            image_path, target_size=(224, 224)
        )
        img_array = tf.keras.preprocessing.image.img_to_array(img)
        img_array = tf.expand_dims(img_array, 0)
        img_array = img_array / 255.0

        # Vorhersage
        predictions = self.model.predict(img_array)
        return predictions[0].tolist()

7. Modell-Versionierung

# models.py
from django.db import models

class MLModel(models.Model):
    name = models.CharField(max_length=100)
    version = models.CharField(max_length=20)
    file_path = models.CharField(max_length=255)
    accuracy = models.FloatField()
    is_active = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ['name', 'version']

    @classmethod
    def get_active_model(cls, name):
        return cls.objects.filter(name=name, is_active=True).first()

Best Practices

• Verwenden Sie das Singleton-Muster, um das Modell nur einmal zu laden
• Implementieren Sie Caching für häufige Vorhersagen
• Überwachen Sie die Leistung mit detailliertem Logging
• Versionieren Sie Modelle für einfache Rollbacks
• Verwenden Sie Celery für zeitaufwendige Vorhersagen

Fazit

Die Integration von ML in Django eröffnet unendliche Möglichkeiten: Empfehlungen, automatische Klassifizierung, prädiktive Analysen und vieles mehr.