MLOps: Makine Öğrenmesi Modellerini Production a Taşıma

MLOps Nedir ve Neden Önemlidir?

Makine öğrenmesi projeleri geliştirmek ile bu projeleri production ortamında sürdürülebilir şekilde çalıştırmak arasında devasa bir uçurum vardır. Birçok veri bilimci ve mühendis, Jupyter Notebook'ta harika sonuçlar elde eder ancak modeli gerçek dünyada kullanıma sunma aşamasında ciddi zorluklarla karşılaşır. İşte MLOps (Machine Learning Operations), tam da bu sorunu çözmek için ortaya çıkmış bir disiplindir.

MLOps, DevOps prensiplerini makine öğrenmesi yaşam döngüsüne uygulayan bir pratikler bütünüdür. Veri hazırlama, model eğitimi, test etme, dağıtım, izleme ve yeniden eğitim süreçlerinin tamamını kapsar. Amaç, ML modellerinin güvenilir, tekrarlanabilir ve ölçeklenebilir bir şekilde production ortamına taşınmasını sağlamaktır.

Production'a Giden Yolda Karşılaşılan Temel Zorluklar

• Veri tutarsızlığı: Eğitim verisinin dağılımı ile production verisinin dağılımı arasındaki farklar (data drift) model performansını ciddi şekilde düşürebilir.
• Tekrarlanabilirlik: Aynı veri ve aynı kod ile aynı sonuçları elde edememek, en yaygın sorunlardan biridir. Rastgele tohum değerleri, kütüphane versiyonları ve donanım farklılıkları buna yol açar.
• Model versiyonlama: Hangi modelin hangi veriyle, hangi hiperparametrelerle eğitildiğini takip etmek zamanla karmaşık hale gelir.
• Ölçeklenebilirlik: Notebook ortamında çalışan bir model, saniyede binlerce istek alan bir API'de aynı performansı göstermeyebilir.
• İzleme ve bakım: Production'daki modelin performansını sürekli izlemek ve gerektiğinde müdahale etmek gerekir.

MLOps Yaşam Döngüsü

Olgun bir MLOps pipeline'ı aşağıdaki aşamalardan oluşur:

1. Veri Yönetimi: Verinin toplanması, temizlenmesi, versiyonlanması ve doğrulanması
2. Model Geliştirme: Feature engineering, model seçimi ve hiperparametre optimizasyonu
3. Model Eğitimi: Tekrarlanabilir eğitim pipeline'larının oluşturulması
4. Model Değerlendirme: Metrikler, A/B testleri ve doğrulama
5. Model Dağıtımı: Containerization, serving ve API oluşturma
6. İzleme: Performans takibi, drift algılama ve alerting
7. Yeniden Eğitim: Otomatik veya tetiklemeli yeniden eğitim döngüleri

Temel MLOps Araçları ve Teknolojileri

MLflow ile Deney Takibi

MLflow, makine öğrenmesi deneylerini izlemek, modelleri paketlemek ve dağıtmak için kullanılan açık kaynaklı bir platformdur. Her deney çalıştırmasında hiperparametreler, metrikler ve model artifact'leri otomatik olarak kaydedilir.

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score

# MLflow deney takibini başlat
mlflow.set_experiment("musteri-kayip-tahmini")

with mlflow.start_run(run_name="rf-baseline"):
    # Hiperparametreleri kaydet
    params = {
        "n_estimators": 200,
        "max_depth": 10,
        "min_samples_split": 5,
        "random_state": 42
    }
    mlflow.log_params(params)

    # Modeli eğit
    model = RandomForestClassifier(**params)
    model.fit(X_train, y_train)

    # Tahmin ve metrikleri hesapla
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    f1 = f1_score(y_test, y_pred, average="weighted")

    # Metrikleri kaydet
    mlflow.log_metric("accuracy", accuracy)
    mlflow.log_metric("f1_score", f1)

    # Modeli kaydet
    mlflow.sklearn.log_model(model, "model")
    print(f"Accuracy: {accuracy:.4f}, F1: {f1:.4f}")

DVC ile Veri Versiyonlama

DVC (Data Version Control), büyük veri dosyalarını ve ML pipeline'larını Git benzeri bir yapıyla versiyonlamanızı sağlar. Böylece hangi modelin hangi veriyle eğitildiğini her zaman takip edebilirsiniz.

# DVC'yi başlat
dvc init

# Büyük veri dosyasını DVC ile takibe al
dvc add data/train.csv

# Remote depolama yapılandır (S3 örneği)
dvc remote add -d myremote s3://mlops-bucket/dvc-store

# Pipeline aşamalarını tanımla
dvc run -n prepare \
    -d src/prepare.py -d data/raw \
    -o data/processed \
    python src/prepare.py

dvc run -n train \
    -d src/train.py -d data/processed \
    -o models/model.pkl \
    -m metrics.json \
    python src/train.py

# Pipeline'ı tekrarla
dvc repro

Docker ile Model Containerization

Modeli production ortamına taşırken en kritik adımlardan biri, tüm bağımlılıkları içeren tekrarlanabilir bir ortam oluşturmaktır. Docker bu konuda vazgeçilmezdir.

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/
COPY models/ ./models/

EXPOSE 8000

CMD ["uvicorn", "src.api:app", "--host", "0.0.0.0", "--port", "8000"]

FastAPI ile Model Serving

Eğitilmiş modeli bir REST API olarak sunmak, en yaygın production dağıtım yöntemlerinden biridir. FastAPI, yüksek performanslı ve tip güvenli bir API oluşturmayı kolaylaştırır.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib
import numpy as np

app = FastAPI(title="Müşteri Kayıp Tahmin API")

# Modeli uygulama başlangıcında yükle
model = joblib.load("models/model.pkl")

class PredictionRequest(BaseModel):
    age: int
    monthly_charges: float
    tenure_months: int
    total_charges: float
    contract_type: int

class PredictionResponse(BaseModel):
    prediction: int
    probability: float
    label: str

@app.post("/predict", response_model=PredictionResponse)
def predict(request: PredictionRequest):
    features = np.array([[
        request.age,
        request.monthly_charges,
        request.tenure_months,
        request.total_charges,
        request.contract_type
    ]])

    prediction = model.predict(features)[0]
    probability = model.predict_proba(features)[0].max()

    return PredictionResponse(
        prediction=int(prediction),
        probability=float(probability),
        label="Kayıp Riski Var" if prediction == 1 else "Kayıp Riski Yok"
    )

@app.get("/health")
def health_check():
    return {"status": "healthy", "model_version": "1.0.0"}

CI/CD Pipeline Oluşturma

MLOps'un temel taşlarından biri, model eğitiminden dağıtıma kadar tüm sürecin otomatize edilmesidir. GitHub Actions ile basit bir ML CI/CD pipeline'ı aşağıdaki gibi kurulabilir:

name: ML Pipeline

on:
  push:
    branches: [main]
    paths:
      - 'src/**'
      - 'data/**'

jobs:
  train-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Python ortamını kur
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Bağımlılıkları yükle
        run: pip install -r requirements.txt

      - name: Veri doğrulama
        run: python src/validate_data.py

      - name: Model eğitimi
        run: python src/train.py

      - name: Model testleri
        run: pytest tests/test_model.py -v

      - name: Docker image oluştur
        run: docker build -t ml-api:${{ github.sha }} .

      - name: Registry'ye gönder
        run: |
          docker tag ml-api:${{ github.sha }} registry.example.com/ml-api:latest
          docker push registry.example.com/ml-api:latest

Model İzleme ve Data Drift Algılama

Model production'a çıktıktan sonra asıl iş başlar. Modelin zamanla performans kaybedip kaybetmediğini, gelen verinin eğitim verisinden sapıp sapmadığını sürekli izlemeniz gerekir. Bu aşamada Evidently AI gibi araçlar oldukça faydalıdır.

from evidently.report import Report
from evidently.metric_preset import DataDriftPreset, TargetDriftPreset
import pandas as pd

# Referans veri (eğitim verisi) ve güncel production verisi
reference_data = pd.read_csv("data/reference.csv")
current_data = pd.read_csv("data/production_latest.csv")

# Data drift raporu oluştur
report = Report(metrics=[
    DataDriftPreset(),
    TargetDriftPreset()
])

report.run(
    reference_data=reference_data,
    current_data=current_data
)

# Raporu HTML olarak kaydet
report.save_html("reports/drift_report.html")

# Programatik olarak drift kontrolü
result = report.as_dict()
dataset_drift = result["metrics"][0]["result"]["dataset_drift"]

if dataset_drift:
    print("UYARI: Data drift tespit edildi! Yeniden eğitim gerekebilir.")
else:
    print("Data drift tespit edilmedi. Model stabil.")

Kubernetes ile Ölçeklenebilir Dağıtım

Yüksek trafikli uygulamalarda modelin ölçeklenebilir şekilde sunulması gerekir. Kubernetes, otomatik ölçeklendirme ve yük dengeleme gibi özellikleriyle bu ihtiyacı karşılar.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-api
  template:
    metadata:
      labels:
        app: ml-api
    spec:
      containers:
      - name: ml-api
        image: registry.example.com/ml-api:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 10
          periodSeconds: 30
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ml-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ml-api
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Feature Store Kullanımı

Production ortamında feature'ların tutarlı ve performanslı bir şekilde sunulması kritik öneme sahiptir. Feature store, eğitim ve serving arasındaki feature tutarsızlığını (training-serving skew) ortadan kaldırır. Feast bu alanda en popüler açık kaynak çözümlerden biridir.

from feast import FeatureStore

store = FeatureStore(repo_path="feature_repo/")

# Online serving için feature'ları çek
features = store.get_online_features(
    features=[
        "customer_features:monthly_charges",
        "customer_features:tenure_months",
        "customer_features:total_charges",
        "customer_features:contract_type"
    ],
    entity_rows=[{"customer_id": 1001}]
).to_dict()

print(features)

MLOps Olgunluk Seviyeleri

Google, MLOps olgunluğunu üç seviyede tanımlar. Organizasyonunuzun hangi seviyede olduğunu anlamak, bir sonraki adımı planlamak için faydalıdır:

• Seviye 0 — Manuel Süreç: Model eğitimi ve dağıtımı tamamen manueldir. Notebook'ta geliştirilen model, elle production'a taşınır. Küçük ekipler ve az sayıda model için kabul edilebilir olsa da ölçeklenmez.
• Seviye 1 — ML Pipeline Otomasyonu: Eğitim pipeline'ı otomatize edilmiştir. Yeni veri geldiğinde model otomatik olarak yeniden eğitilebilir. Sürekli eğitim (continuous training) bu seviyenin temel özelliğidir.
• Seviye 2 — CI/CD Pipeline Otomasyonu: Hem model hem de pipeline kodu için CI/CD süreçleri mevcuttur. Pipeline bileşenleri test edilir, versiyonlanır ve otomatik olarak dağıtılır. Bu seviye, büyük ölçekli ML sistemleri için hedeflenen olgunluk düzeyidir.

Best Practice'ler ve Öneriler

• Her şeyi versiyonlayın: Kod, veri, model, konfigürasyon ve ortam — hepsi versiyonlanmalıdır. Tekrarlanabilirlik ancak bu şekilde sağlanır.
• Testleri ihmal etmeyin: Birim testleri, entegrasyon testleri ve model performans testleri pipeline'ın ayrılmaz parçası olmalıdır. Veri şeması doğrulama testleri de eklemeyi unutmayın.
• Küçük başlayın: İlk günden Kubernetes ve Kubeflow gibi karmaşık araçlarla başlamak yerine, basit bir Docker container ve CI/CD pipeline'ı ile production'a çıkın. İhtiyaç arttıkça karmaşıklığı artırın.
• İzlemeyi birinci sınıf vatandaş yapın: Model performans metrikleri, veri kalitesi metrikleri ve sistem metrikleri (latency, throughput) ayrı ayrı izlenmelidir.
• Rollback stratejiniz olsun: Yeni model beklendiği gibi çalışmadığında önceki versiyona hızlıca dönebilmelisiniz. Blue-green veya canary deployment stratejileri bu konuda yardımcı olur.
• Dokümantasyon: Her modelin bir model kartı (model card) olmalıdır. Modelin ne yaptığı, hangi veriyle eğitildiği, bilinen kısıtlamaları ve etik değerlendirmeleri içermelidir.

Sonuç

MLOps, makine öğrenmesi projelerinin deneysel ortamdan production ortamına güvenilir bir şekilde geçişini sağlayan kritik bir disiplindir. Doğru araçlar, süreçler ve kültürel alışkanlıklarla ML modellerinizi sürdürülebilir, ölçeklenebilir ve güvenilir bir şekilde production'da çalıştırabilirsiniz. Unutmayın: bir modelin değeri, notebook'ta gösterdiği metriklerle değil, production'da gerçek kullanıcılara sağladığı faydayla ölçülür. Küçük adımlarla başlayın, süreçlerinizi otomatize edin ve sürekli iyileştirme döngüsünü benimseyerek MLOps olgunluğunuzu kademeli olarak artırın.