v2.5KI & Machine Learning

ML Training & Inference

Das intelligence-Modul ermöglicht das Trainieren, Feintunen und lokale Ausführen von Modellen.

Training-Workflows

Velisch bietet High-Level Abstraktionen für das Training von Modellen, während Rust im Hintergrund die rechenintensiven Aufgaben übernimmt.

Fine-Tuning

LLMs auf eigene Daten anpassen

Lokale Inferenz

ONNX/GGUF Modelle lokal ausführen

Monitoring

Trainings-Metriken visualisieren

Modelle trainieren und feintunen

Starten Sie Fine-Tuning-Jobs direkt aus dem Code:

use intelligence

struct TrainingExample { input: string, output: string }

fn fineTuneModel(data: List<TrainingExample>) {
    let trainer = TrainingService.new({
        baseModel: "gpt-3.5-turbo",
        epochs: 3,
        learningRate: 0.001
    });
    
    log.info("Starte Training mit " + data.length() + " Beispielen...");
    
    // Async Job starten
    let jobId = trainer.train(data);
    
    // Auf Fertigstellung warten (oder Webhook nutzen)
    while (trainer.getStatus(jobId) != "succeeded") {
        utils.sleep("10s");
    }
    
    let newModelId = trainer.getModelId(jobId);
    log.info("Neues Modell bereit: " + newModelId);
    
    // Konfiguration aktualisieren, um neues Modell zu nutzen
    config.set("ai.model", newModelId);
}

Lokale Inferenz (ONNX/GGUF)

Velisch kann Modelle lokal auf der CPU/GPU ausführen, ohne Daten an die Cloud zu senden. Ideal für Datenschutz-kritische Anwendungen.

use intelligence

// Lädt ein quantisiertes Llama-3 Modell (GGUF Format)
let model = ModelLoader.load("./models/llama-3-8b-q4.gguf", {
    gpuLayers: 32,
    contextSize: 4096
});

@POST("/api/local/generate")
fn localGenerate(prompt: string): string {
    return model.predict(prompt);
}

// ONNX Modell für Klassifizierung
let classifier = ModelLoader.load("./models/sentiment.onnx");

@POST("/api/local/classify")
fn localClassify(text: string): ClassificationResult {
    let prediction = classifier.predict(text);
    
    return ClassificationResult {
        label: prediction.label,
        confidence: prediction.score,
    };
}

Custom Training Pipeline

use intelligence

fn trainSentimentModel(): void {
    let service = TrainingService.new();
    
    // Training-Daten hinzufügen
    service.add_example("I love this product", "positive");
    service.add_example("This is terrible", "negative");
    service.add_example("It's okay", "neutral");
    
    // ONNX Training Konfiguration
    let config = ONNXTrainingConfig {
        epochs: 100,
        batchSize: 32,
        learningRate: 0.001,
        optimizer: "Adam",
        lossFunction: "CrossEntropy"
    };
    
    let result = service.train_with_onnx("sentiment_model", config);
    
    match result {
        Ok(training_result) => {
            log.info("Accuracy: " + training_result.accuracy);
            log.info("Model saved to: " + training_result.modelPath);
        },
        Err(err) => {
            log.error("Training fehlgeschlagen: " + err.message);
        }
    }
}

// Trainiertes Modell nutzen
let sentimentModel = ModelLoader.load("./models/sentiment_model.onnx");

@POST("/api/sentiment")
fn analyzeSentiment(text: string): SentimentResult {
    let prediction = sentimentModel.predict(text);
    
    return SentimentResult {
        text: text,
        sentiment: prediction.label,
        confidence: prediction.score,
    };
}

Training Monitoring

use intelligence

fn trainWithMonitoring(data: List<TrainingExample>) {
    let trainer = TrainingService.new({
        baseModel: "gpt-3.5-turbo",
        epochs: 10,
    });
    
    // Callback für Trainings-Updates
    trainer.onProgress(|update| {
        log.info("Epoch " + update.epoch + "/" + update.totalEpochs);
        log.info("Loss: " + update.loss);
        log.info("Accuracy: " + update.accuracy);
        
        // Metrics an Dashboard senden
        metrics.gauge("training_loss", update.loss);
        metrics.gauge("training_accuracy", update.accuracy);
    });
    
    trainer.onComplete(|result| {
        log.info("Training abgeschlossen!");
        log.info("Finale Accuracy: " + result.finalAccuracy);
        
        // Slack-Benachrichtigung
        slack.send("#ml-team", "Training fertig: " + result.modelId);
    });
    
    trainer.train(data);
}

Best Practices

Lokale Modelle für Datenschutz

Sensible Daten nicht an Cloud-APIs senden

Quantisierung nutzen

GGUF Q4 Modelle sind schnell und brauchen wenig RAM

Training überwachen

Callbacks für Metriken und Alerts einrichten

Model Versioning

Trainierte Modelle mit Zeitstempel speichern

LLM IntegrationVektor-Datenbanken