Ein finetuned LLM mit REST API bereitstellen

Die Feinabstimmung eines Sprachmodells ist ein guter Weg, es an eine spezifische Domäne oder einen Anwendungsfall anzupassen. In unserem vorherigen Konfuzio-Guide zur Feinabstimmung haben wir gezeigt, wie man ein LLM auf strukturierte Daten aus deutschen Fahrzeugscheinen trainiert. Diese Art von Dokumenten, mit hochspezifischen Feldern und rechtlich relevanten Datenformaten, profitiert stark von einem angepassten LLM, das Kontext und Terminologie versteht.

Aber sobald Ihr Modell trainiert ist, besteht der nächste Schritt darin, es zugänglich zu machen – idealerweise in einer skalierbaren, wartbaren und sicheren Umgebung. In diesem Blogpost bauen wir auf dieser Vorarbeit auf. Nun wird das angepasste LLM mit Docker, einer REST API, dem Konfuzio SDK und BentoML bereitgestellt.

Warum Ihr feinabgestimmtes Modell bereitstellen?

Die Feinabstimmung eines Large Language Models (LLM) ermöglicht es Ihnen, allgemeines Sprachverständnis zu nutzen und es gleichzeitig an die einzigartigen Eigenheiten Ihrer Daten anzupassen – sei es bei der Verarbeitung juristischer Dokumente, Finanzberichte oder – wie in unserem Fall – Fahrzeugscheine. Aber ein feinabgestimmtes Modell entfaltet seinen Wert erst, wenn es zuverlässig einsatzbereit ist.

Daher ist die Bereitstellung Ihres LLMs wichtig:

• Bereitstellung über eine HTTP-Schnittstelle: Anwendungen benötigen einfache Schnittstellen zur Interaktion mit dem Modell. Eine REST API ist der Standard, um Vorhersagen eines LLMs bereitzustellen.
• Integration in andere Anwendungen: Ob Dokumenten-Pipeline, Chatbot oder Backend-Service – Sie möchten Ihr Modell nahtlos integrieren können.
• Reproduzierbarkeit und Isolierung: Lokale Experimente können in der Produktion scheitern, wenn Umgebungen nicht stabil sind. Docker sorgt für Konsistenz.
• Skalierbarer Zugriff: Als Container und über API bereitgestellt, wird Ihr Modell zu einem skalierbaren Microservice – Cloud-kompatibel und Kubernetes-ready.
• Versionierte Bereitstellungen: BentoML erlaubt Ihnen, Modellversionen zu tracken, zu aktualisieren oder zurückzurollen – ohne Infrastrukturaufwand.

Die Kombination aus Docker für Isolation und BentoML für Packaging und Bereitstellung legt das Fundament für ein robustes, wartbares Deployment – mit minimalem Overhead. Über eine automatisch generierte REST-API auf Basis von FastAPI wird das Modell dabei komfortabel zugänglich gemacht.

Schritt 1: LLM in eine Konfuzio SDK-Pipeline integrieren

Wir erweitern AbstractExtractionAI und bauen eine vollständige Extraktionspipeline für Fahrzeugscheine mit einem feinabgestimmten LLM. Wir gehen davon aus, dass sich die trainierten Gewichte im aktuellen Arbeitsverzeichnis befinden. Hier im Ordner Vinlora:

from konfuzio_sdk.trainer.information_extraction import AbstractExtractionAI
class LLMExtractionAI(AbstractExtractionAI):
    alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
        ### Instruction:
        {}
        ### Input:
        {}
        ### Response:
        {}"""
    llm_model_name = "vinlora"
    llm_model = None
    llm_tokenizer = None
    def check_is_ready(self):
        pass
    def load_llm(self):
        from unsloth import FastLanguageModel
        max_seq_length = 2048
        self.llm_model, self.llm_tokenizer = FastLanguageModel.from_pretrained(
            model_name=self.llm_model_name,
            max_seq_length=max_seq_length,
            dtype=None,
            load_in_4bit=True,
        )
        FastLanguageModel.for_inference(self.llm_model)
    def run_llm(self, instruction: str, text: str) -> str:
        self.load_llm()
        inputs = self.llm_tokenizer([
            self.alpaca_prompt.format(instruction, text, "")
        ], return_tensors="pt").to("cuda")
        outputs = self.llm_model.generate(**inputs, max_new_tokens=128, use_cache=True)
        response = self.llm_tokenizer.batch_decode(outputs)
        return response[-1].split("\n")[-1].split("<|end_of_text|>")[0].strip()
    def extract(self, document: Document) -> Document:
        json_str = self.run_llm("Extract values from german car registration certificate and return them as JSON.", document.text)
        self.parse_json_to_annotations(json_str, document)
        return document
    def parse_json_to_annotations(self, json_str: str, document: Document) -> None:
        import re, json
        def normalize_ws(s: str) -> str:
            return re.sub(r'\s+', ' ', s).strip()
        data = json.loads(json_str)
        annotation_set = document.default_annotation_set
        label_mapping = {label.name: label for label in document.project.labels}
        for field_name, value in data.items():
            if field_name in label_mapping:
                label = label_mapping[field_name]
                value_pattern = re.escape(value.strip()).replace(r'\ ', r'\s+')
                match = re.search(value_pattern, document.text)
                if match:
                    span = Span(start_offset=match.start(), end_offset=match.end())
                    Annotation(
                        document=document,
                        label=label,
                        confidence=1.0,
                        label_set=label.label_sets[0],
                        annotation_set=annotation_set,
                        spans=[span]
                    )

Schritt 2: Bento-Service automatisch bauen

Es ist kein eigener BentoML-Service nötig. Unsere LLMExtractionAI enthält eine Methode build_bento, die den gesamten Modell-Workflow als Bento-Paket bereitstellt:

project = Project(id_=PROJECT_ID, update=True)
pipeline = LLMExtractionAI(category=project.categories[0])
bento = pipeline.build_bento(pipeline)

Diese Methode:

• Kopiert Bento-Service-Templates aus dem konfuzio_sdk
• Integriert Metadaten und Modell-ID
• Packt alles in ein einsatzfertiges BentoML-Paket

Schritt 3: Docker-Container bauen

Nutzen Sie die Kommandozeile zur Containerisierung. Hierdurch wird ein Docker Image erstellt.:

bentoml containerize extraction_<NAME>:latest

Container starten:

docker run -p 3000:3000 extraction_<NAME>:latest

Testaufruf:

curl -X POST http://localhost:3000/predict -H "Content-Type: application/json" -d '{"text": "..."}'

Die bereitgestellte API ist bereits durch ein Swagger Interface with Open-API Spezifikation dokumentiert.

Fazit

Dieser Leitfaden zeigt, wie Sie Ihr feinabgestimmtes LLM von der lokalen Entwicklungsumgebung bis hin zur produktionsreifen Bereitstellung bringen – integriert im Konfuzio SDK, ausgeliefert als REST API im Docker Container. Ob Data Scientist oder ML Engineer: Diese Architektur schafft eine strukturierte und skalierbare Grundlage.

Die Methode build_bento ist dabei ein nützliches Werkzeug, um Modelle mitsamt Metadaten, Modellgewichten und Abhängigkeiten zu verpacken und versionierbar zu machen – jedoch kein Allheilmittel. Im Zentrum steht eine robuste Gesamtarchitektur: Ein feinabgestimmtes Modell, eingebettet in eine versionierte Pipeline, bereitgestellt in einem containerisierten Service.

Das ist ein konkreter Schritt in Richtung produktionsreifer KI – wartbar, testbar und einsatzbereit. Mehr Hintergründe zur Containerisierung und ihren Vorteilen gibt es im Artikel: Warum Unternehmen Containerisierung nutzen sollten