LLM Fine-Tuning avec ses propres données - Un guide pratique

Ce guide vous montre comment adapter de manière ciblée un grand modèle linguistique (LLM) à vos besoins. De l'introduction à l'adaptation de faible rang à la préparation et au déploiement efficaces des données, vous recevrez des instructions claires pour construire un modèle qui répond à vos besoins spécifiques.

Pas à pas, vous apprendrez à utiliser des méthodes modernes comme LoRA, à travailler avec un minimum de ressources et à développer un modèle individuel performant. Que ce soit pour votre entreprise ou pour vos propres projets, ce guide vous offre une base pratique et compréhensible.

Grâce à ces instructions claires, vous serez en mesure d'optimiser un LLM de manière autonome et de mettre en œuvre avec succès vos idées d'application. Commencez par un modèle adapté à vos besoins.

Pourquoi utiliser une carte grise comme exemple ?

Une carte grise (certificat d'immatriculation partie 1) peut sembler anodine à première vue, mais elle représente en pratique un défi d'une complexité impressionnante. Ce document contient de nombreux points de données structurés dans un format clairement défini : du numéro d'identification du véhicule (FIN) aux données techniques telles que la masse totale, la cylindrée ou les valeurs de CO₂, en passant par la date de première immatriculation. En plus de tous les autres documents, Konfuzio IDP peut fournir un Lire la carte grise et valider automatiquement les données qu'il contient.

La mise en page de la carte grise est également exigeante : les données sont réparties sur un espace très restreint, accompagnées de numéros de clés descriptifs et d'éléments parfois infalsifiables. À cela s'ajoutent des orthographes variables ou des abréviations pour les désignations de fabricants et de types, ce qui complique encore l'extraction correcte. Les scans mal exposés ou les images prises sous des angles défavorables rendent la tâche particulièrement difficile - des défis qui font souvent échouer les systèmes OCR traditionnels.

Pourquoi la carte grise est-elle complexe ?

• Volume de données élevé : De nombreuses informations pertinentes doivent être identifiées, extraites et mises en relation de manière correcte.
• Différentes mises en forme : Les éléments tels que les tableaux, les champs et les retours à la ligne varient légèrement en fonction de l'exposition.
• Protection contre la contrefaçon : Les caractéristiques de sécurité telles que les hologrammes, les gaufrages de couleur spéciaux ou les ombres rendent la reconnaissance de texte plus difficile.
• Précision requise : Les données extraites ne doivent pas contenir d'erreurs ; même une lettre supplémentaire dans le FIN a de graves conséquences.

Avec une carte grise, nous pouvons montrer à titre d'exemple comment un LLM peut être accordé de manière à traiter ces structures de données complexes de manière sûre et précise. L'objectif est de créer un système qui reste performant même dans des conditions difficiles - précis, évolutif et robuste.

Instructions : adapter le LLM à ses propres données

Que fait l'adaptation de bas rang ?

Low-Rank Adaptation est une méthode efficace pour le réglage fin de grands modèles linguistiques. Au lieu de modifier tous les poids du modèle, seules des adaptations ciblées et compactes sont effectuées - dans un sous-espace réduit des paramètres initiaux. La performance du modèle est ainsi préservée, tandis que le la consommation de ressources diminue considérablement. Moins de mémoire, temps de formation plus courts, charge de calcul réduite - idéal pour les applications proches de la production ou les déploiements en périphérie.

Pourquoi la QLoRA ?

QLoRA combine l'adaptation à faible rang avec un stockage quantifié - c'est-à-dire une représentation extrêmement compacte du poids des modèles. Cela permet d'exploiter efficacement même de grands modèles sur un matériel limité, par exemple sur un seul serveur GPU ou même localement. Pour les développeurs, cela signifie : pas de réglage fin complet, pas d'infrastructure haut de gamme, mais tout de même de solides résultats. QLoRA réduit les obstacles à la personnalisation des modèles - tout en conservant les mêmes performances.

Domaines d'application

QLoRA est le partenaire idéal pour tout projet nécessitant des modèles linguistiques sur mesure. Que ce soit pour une exploitation locale, pour des workflows spécifiques ou pour des tâches sensibles en matière de protection des données. Pas d'extension de systèmes inutiles, pas de gaspillage de ressources. Rien que la précision, pour aujourd'hui et pour demain.

Préparer les données utiliser

Afin d'entraîner un modèle d'extraction fiable, les documents non structurés doivent être transformés en données structurées. Konfuzio prend en charge ce processus en plusieurs étapes :

1. Définir des labels et des catégories - par exemple Date, Type de véhicule ou Numéro d'immatriculation.
2. Annoter des textes - marquez les passages pertinents du texte et associez-les aux étiquettes correspondantes.
3. Réaliser une assurance qualité - vérifiez que les annotations sont complètes et correctes et corrigez-les si nécessaire.

Konfuzio transforme ainsi les documents en données structurées et lisibles par une machine - une base centrale pour l'entraînement et l'utilisation productive de modèles d'IA pour l'extraction d'informations.

En chargeant la vidéo, vous acceptez la déclaration de confidentialité de YouTube.
En savoir plus

Charger la vidéo

Toujours déverrouiller YouTube

Un ensemble de données pour lequel certaines informations (p. ex. "date d'autorisation") sont marquées de manière sûre et exportables.

Du texte à l'ensemble des données de formation

Exigences relatives à l'enregistrement des données d'entrée

Un modèle a besoin de spécifications structurées pour pouvoir être entraîné. Les formats standard comprennent

• Description de la tâche (Instruction).
• Le texte d'entrée (input).
• Un exemple de réponse (output).

Automatiser le formatage des données

Avec un script Python, vous transférez les données annotées de Konfuzio dans un format adapté à l'entraînement. Exemple de code :

import json
from copy import deepcopy
from konfuzio_sdk.data import Project
# Projekt und Kategorie laden (IDs z. B. aus der Weboberfläche)
project = Project(id_="DEIN_PROJEKT_ID", update=True)
category = project.get_category_by_id("DEINE_KATEGORIE_ID")
for (name, documents) in [("train", category.documents()), ("test", category.test_documents())]:
    dataset = []
    for doc in documents:
        copy_doc = deepcopy(doc)
        entry = {
            "instruction": "Extrahiere Informationen aus Dokumenten.",
            "input": copy_doc.text,
            "output": {label.name: ann.offset_string[0] for label in doc.labels for ann in doc.annotations() if ann.label.id == label.id},
            "id": copy_doc.id_
        }
        dataset.append(entry)
    with open(f"{name}_dataset.json", "w", encoding="utf-8") as f:
        json.dump(dataset, f, indent=4, ensure_ascii=False)

Après l'exécution, vous avez un fichier JSON, par ex :

{
    "instruction": "Extrahiere Kennzeichen und Zulassungsdaten.",
    "input": "1. Kennzeichen: B-MW123...",
    "output": {
        "Kennzeichen": "B-MW123",
        "Zulassungsdatum": "01.01.2020"
    },
    "id": "abc123"
}

Nous utilisons l'instruction dans le Alpaca Format.

# Definition der ALPACA-Prompt-Vorlage
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:
{}"""
EOS_TOKEN = tokenizer.eos_token  # Sicherstellen, dass das EOS-Token angehängt wird

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs = examples["input"]
    outputs = examples["output"]
    texts = []
    for instruction, input_text, output in zip(instructions, inputs, outputs):
        text = alpaca_prompt.format(instruction, input_text, output) + EOS_TOKEN
        texts.append(text)
    return {"text": texts}

Ce fichier peut maintenant être chargé.

import json
import random
import pandas as pd
from datasets import Dataset
from transformers import AutoTokenizer
file_path = "train_dataset.json"  # Pfad zur Datei (bei Bedarf anpassen)
with open(file_path, "r", encoding="utf-8") as f:
    dataset = json.load(f)
# In ein Pandas DataFrame umwandeln
random.shuffle(dataset)
df = pd.DataFrame(dataset)
# Formatierung anwenden
hf_dataset = Dataset.from_pandas(df)
dataset = hf_dataset.map(formatting_prompts_func, batched=True)

Adapter le modèle

Procédure de mise au point

Lors de la mise au point finale, vous avez besoin

1. Un modèle de base (par exemple la gamme Llama ou Mistral).
2. Un outil de formation, comme le Hugging Face Framework.
3. Données formatées de l'étape 3.

Formation avec LoRA

LoRA est efficace, car seules des zones spécifiques du modèle sont modifiées. Les étapes :

• Configurer l'adaptateur.
• Charger des données.
• définir des paramètres tels que la taille du lot et le taux d'apprentissage
• Exécuter l'entraînement.

exemple :

import torch
from unsloth import FastLanguageModel
# Lade das ursprüngliche Modell
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Llama-3.2-3B-Instruct",
    max_seq_length = 4096,
    dtype = None,
    load_in_4bit = True,
)
# Füge QLoRA hinzu
model = FastLanguageModel.get_peft_model(
    model,
    r = 128,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 32,
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,
    loftq_config = None,
)
from transformers import TrainingArguments, Trainer
training_args = TrainingArguments(
    output_dir="./results",
    per_device_train_batch_size=4,
    num_train_epochs=5,
    learning_rate=2e-4,
)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=formatted_data,
)
trainer.train()
model.save_pretrained("finetuned_model") 
tokenizer.save_pretrained("finetuned_model")

Le modèle est adapté de manière à pouvoir traiter efficacement des tâches spécifiques de vos données.

Conclusion

Le système décrit ici démontre de manière impressionnante ce qu'il est possible d'obtenir grâce à un réglage LLM optimisé et à des techniques modernes. Avec seulement 4 GO DE VRAM on obtient des performances impressionnantes :

• 99,57 % Score F1: Une mesure d'exactitude et de précision, mesurée sur niveau de précision des caractères - un niveau qui offre une fiabilité maximale, même pour les documents les plus exigeants.
• 1,5 seconde par document: Une vitesse de traitement non seulement efficace, mais aussi évolutive.

Cette configuration montre comment le traitement de données basé sur l'IA est prêt pour la production, même avec des ressources limitées. sans compromis sur la qualité ou la vitesse.