Fournir un LLM finetuned avec une API REST

Le réglage fin d'un modèle de langage est un bon moyen de l'adapter à un domaine spécifique ou à un cas d'utilisation. Dans notre précédent Konfuzio-Guide pour un réglage fin nous avons montré comment entraîner un LLM sur des données structurées issues de cartes grises allemandes. Ce type de documents, avec des champs très spécifiques et des formats de données juridiquement pertinents, bénéficie fortement d'un LLM adapté qui comprend le contexte et la terminologie.

Mais une fois que votre modèle est entraîné, l'étape suivante consiste à le rendre accessible - idéalement dans un environnement évolutif, maintenable et sécurisé. Dans ce blog post, nous nous appuyons sur ce travail préliminaire. Maintenant, le LLM personnalisé est utilisé avec Docker, une API REST, le Konfuzio SDK et BentoML fourni.

Pourquoi fournir votre modèle finement ajusté ?

Le réglage fin d'un Large Language Model (LLM) vous permet d'utiliser une compréhension générale du langage tout en l'adaptant aux spécificités uniques de vos données, que ce soit pour le traitement de documents juridiques, de rapports financiers ou, comme dans notre cas, de cartes grises. Mais un modèle finement ajusté ne prend toute sa valeur que lorsqu'il est prêt à être utilisé de manière fiable.

C'est pourquoi la mise à disposition de votre LLM est importante :

• Mise à disposition via une interface HTTPLes applications ont besoin d'interfaces simples pour interagir avec le modèle. Une API REST est la norme pour fournir des prédictions d'un LLM.
• Intégration dans d'autres applications: Qu'il s'agisse d'un pipeline de documents, d'un chatbot ou d'un service de backend, vous souhaitez pouvoir intégrer votre modèle de manière transparente.
• Reproductibilité et isolation: Les expériences locales peuvent échouer en production si les environnements ne sont pas stables. Docker assure la cohérence.
• Accès évolutifEn tant que conteneur et via l'API, votre modèle devient un microservice évolutif - compatible avec le cloud et Kubernetes-ready.
• Déploiements de versions: BentoML vous permet de suivre, de mettre à jour ou de revenir en arrière sur les versions des modèles, sans aucune infrastructure.

La combinaison de Docker pour l'isolation et de BentoML pour le packaging et le déploiement pose les bases d'un déploiement robuste et maintenable - avec un minimum de frais généraux. Une API REST générée automatiquement sur la base de FastAPI permet d'accéder facilement au modèle.

Étape 1 : Intégrer LLM dans un pipeline Konfuzio SDK

Nous élargissons AbstractExtractionAI et construisons un pipeline d'extraction complet pour les cartes grises avec un LLM finement ajusté. Nous partons du principe que les poids entraînés se trouvent dans le répertoire de travail actuel. Ici, dans le dossier 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]
                    )

Étape 2 : Construire automatiquement le service bento

Il n'est pas nécessaire d'avoir son propre service BentoML. Notre LLMExtractionAI contient une méthode build_bentoL'outil de modélisation est un logiciel qui fournit l'ensemble du flux de travail du modèle sous la forme d'un paquet bento :

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

Cette méthode :

• Copie les modèles de service Bento depuis le konfuzio_sdk
• Intègre les métadonnées et l'ID du modèle
• Rassemble tout dans un paquet BentoML prêt à l'emploi

Étape 3 : Construire un conteneur Docker

Utiliser la ligne de commande pour la conteneurisation. Cela permet de créer une image Docker.. :

bentoml containerize extraction_<NAME>:latest

Démarrer le conteneur :

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

Appel à test :

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

L'API fournie est déjà documentée par une interface Swagger avec spécification Open-API.

Conclusion

Ce guide montre comment faire passer votre LLM finement ajusté de l'environnement de développement local à un déploiement prêt pour la production - intégré dans le SDK Konfuzio, livré comme API REST dans le conteneur Docker. Que vous soyez un data scientist ou un ingénieur ML, cette architecture crée une base structurée et évolutive.

La méthode build_bento est un outil utile pour empaqueter des modèles avec des métadonnées, des poids de modèle et des dépendances et pour les rendre versionnables - mais ce n'est pas la panacée. Au centre se trouve une architecture globale robuste : un modèle finement ajusté, intégré dans un pipeline versionné, mis à disposition dans un service conteneurisé.

C'est un pas concret vers une IA prête à la production - maintenable, testable et opérationnelle. Pour en savoir plus sur la conteneurisation et ses avantages, consultez l'article : Pourquoi les entreprises devraient utiliser la conteneurisation