Entraîner des modèles NLU personnalisés avec Ludwig AI

Ludwig AI est un cadre d'apprentissage automatique puissant et low-code qui simplifie le processus de construction et d'entraînement de modèles d'IA. Hexabot exploite Ludwig AI pour proposer un moteur NLU personnalisable et robuste. Cette page vous guidera tout au long du processus d'entraînement de vos propres modèles de compréhension du langage naturel (NLU) en utilisant Ludwig AI, que vous pourrez ensuite intégrer dans votre chatbot Hexabot.

Introduction à Ludwig AI pour le NLU d'Hexabot

Le moteur NLU Hexabot Ludwig vous permet d'utiliser des modèles NLU personnalisés pour la détection d'intention, la reconnaissance d'entités et plus encore, sans écrire beaucoup de code. L'approche déclarative de Ludwig AI utilise des fichiers de configuration (YAML) pour définir l'architecture de votre modèle et le processus d'entraînement. Cela le rend accessible aux utilisateurs de différents niveaux d'expertise en IA pour créer des solutions NLU adaptées à leurs projets Hexabot.

Entraînement de vos modèles NLU : deux approches

Hexabot propose deux approches principales pour entraîner vos modèles NLU Ludwig AI :

Configuration locale : Cette méthode consiste à cloner le dépôt Hexabot Ludwig NLU localement, à configurer un environnement virtuel Python et à entraîner les modèles directement sur votre machine. Cette approche convient aux utilisateurs qui préfèrent un contrôle pratique et le développement local.
Environnement conteneurisé (Docker) : Cette approche utilise des conteneurs Docker pour créer un environnement d'entraînement isolé et reproductible. Elle simplifie la gestion des dépendances et garantit la cohérence entre différents systèmes. Cette méthode est recommandée pour les utilisateurs qui privilégient la facilité d'installation et la portabilité.

Choisissez l'approche qui correspond le mieux à vos préférences techniques et à votre environnement. Les sections suivantes détailleront la configuration et le processus d'entraînement pour les deux méthodes.

Prérequis

Avant de commencer à entraîner vos modèles Ludwig AI, assurez-vous d'avoir installé et configuré les prérequis suivants :

Python : Python 3.8 ou supérieur est requis.
Ludwig AI : Installez Ludwig AI en suivant les instructions sur le site officiel de Ludwig AI.
GPU (optionnel mais recommandé) : Bien que non obligatoire, l'utilisation d'un GPU accélérera considérablement le processus d'entraînement, en particulier pour les modèles complexes et les grands jeux de données.
Docker (optionnel) : Docker est requis si vous avez l'intention d'utiliser l'environnement d'entraînement conteneurisé.

Configuration locale pour l'entraînement

Pour entraîner vos modèles Ludwig localement, suivez ces étapes pour configurer votre environnement :

1. Cloner le dépôt

Tout d'abord, clonez le dépôt du moteur NLU Hexabot Ludwig depuis GitHub :

git clone https://github.com/Hexastack/hexabot-ludwig-nlu.git
cd hexabot-ludwig-nlu

2. Créer un environnement virtuel

Il est recommandé de travailler dans un environnement virtuel pour isoler les dépendances du projet. Ouvrez votre terminal et exécutez les commandes suivantes :

python3 -m venv venv
source venv/bin/activate  # Sur Linux/macOS
# venv\Scripts\activate  # Sur Windows

3. Installer les dépendances

Accédez au répertoire racine de votre projet moteur NLU Ludwig (là où se trouve le fichier requirements.txt ) et installez les paquets Python nécessaires :

pip install -r requirements.txt

Entraîner des modèles localement

Une fois votre environnement configuré, vous pouvez entraîner vos modèles NLU en utilisant l'interface en ligne de commande Ludwig.

Préparez vos données d'entraînement : Ludwig AI prend en charge divers formats de données, y compris CSV, JSON, Parquet, et plus encore. Pour cet exemple, nous nous concentrerons sur le format CSV. Consultez la documentation Ludwig sur les formats de jeux de données pris en charge pour une liste complète et des détails.
Exemple de données d'entraînement CSV :
Vos données d'entraînement CSV doivent être structurées avec des colonnes représentant vos caractéristiques d'entrée (par ex., utterance pour le texte utilisateur) et des caractéristiques de sortie (par ex., intent pour l'intention détectée). Voici une structure d'exemple pour la classification d'intentions :
```
utterance,intent
"Quel temps fait-il aujourd'hui ?",weather_inquiry
"Réserver un vol pour Paris",book_flight
"Régler une alarme pour 7h",set_alarm
"Raconte-moi une blague",tell_joke
"Commander une pizza",order_food
```
Dans cet exemple :
- La colonne utterance contient le texte saisi par l'utilisateur.
- La colonne intent spécifie l'étiquette d'intention correspondante pour chaque énoncé.
Vous pouvez étendre cette structure pour inclure des colonnes pour les entités ou d'autres caractéristiques pertinentes, en fonction de vos tâches NLU. Assurez-vous que votre fichier CSV est enregistré dans le /data/train.csv chemin, ou ajustez le chemin dans la commande d'entraînement en conséquence.
Configurer votre modèle : Les modèles Ludwig sont configurés à l'aide de fichiers YAML. Le fichier de configuration d'exemple se trouve à /src/config.yaml. Vous devrez ajuster ce fichier de configuration pour définir l'architecture de votre modèle, les caractéristiques d'entrée (données textuelles) et les caractéristiques de sortie (intentions, entités). Référez-vous à la documentation Ludwig pour des informations détaillées sur les options de configuration.
Exécuter la commande d'entraînement : Exécutez la commande suivante dans votre terminal pour lancer le processus d'entraînement : Ajustez les chemins pour --config, --dataset, et --output_directory en fonction de la structure de votre projet et des emplacements de vos données.
```
ludwig experiment --config /src/config.yaml \
                 --dataset /data/train.csv \
                 --output_directory /results
```
- --config /src/config.yaml : Spécifie le chemin vers votre fichier de configuration Ludwig.
- --dataset /data/train.csv : Spécifie le chemin vers votre jeu de données d'entraînement.
- --output_directory /results : Définit le répertoire où Ludwig enregistrera les résultats d'entraînement, y compris le modèle entraîné.

Entraînement avec Docker

Pour un environnement d'entraînement plus isolé et reproductible, vous pouvez utiliser Docker.

Construire et exécuter le conteneur Docker : Naviguez jusqu'à la racine de votre projet moteur NLU Ludwig. Assurez-vous que Docker est installé et en cours d'exécution. Utilisez la commande suivante pour lancer le processus d'entraînement dans un conteneur Docker :
```
docker compose -f docker-compose.train.yml up
```
- Cette commande utilise le fichier docker-compose.train.yml (fourni dans le dépôt) pour construire et exécuter un conteneur Docker préconfiguré pour l'entraînement Ludwig.
- Variables d'environnement : Le nom du modèle et les chemins des jeux de données sont généralement configurés via des variables d'environnement dans le docker-compose.train.yml fichier ou un .env.train fichier (exemple fourni en tant que .env.train.example). Assurez-vous d'ajuster ces variables d'environnement pour correspondre au nom de modèle souhaité et à l'emplacement du jeu de données.
Surveiller l'entraînement : Docker exécutera le processus d'entraînement dans le conteneur. Vous pouvez surveiller les journaux en utilisant docker compose logs -f pour suivre la progression de l'entraînement.

Utiliser vos modèles entraînés

Une fois le processus d'entraînement terminé, Ludwig enregistrera le modèle entraîné dans le répertoire de sortie spécifié (par ex., /results/experiment_run_0/model).

Vous pouvez ensuite utiliser ce modèle entraîné pour :

Inférence (prédiction) : Testez votre modèle avec de nouvelles données en utilisant la commande ludwig predict comme indiqué dans le README pour évaluer ses performances.
Mise en service (API) : Mettez en place une API locale ou cloud en utilisant ludwig serve ou des options de mise en service conteneurisées ( docker-compose.serve-local.yml ou docker-compose.serve-hf.yml) pour rendre votre modèle NLU accessible à Hexabot pour la détection d'intentions et d'entités en temps réel.

Des instructions détaillées sur l'intégration de votre modèle Ludwig entraîné avec Hexabot, y compris la configuration des paramètres du moteur Ludwig NLU dans l'interface Hexabot et l'utilisation de l'extension Ludwig Helper, se trouvent dans d'autres sections de la documentation Hexabot.

Téléversement des modèles sur Hugging Face (optionnel)

Partager vos modèles entraînés sur le Hub Hugging Face peut être bénéfique pour la collaboration, le déploiement et la mise à disposition publique de vos modèles.

Configuration Hugging Face :
- Créer un compte Hugging Face : Si vous n'en avez pas, inscrivez-vous pour un compte gratuit sur Hugging Face.
- Configurer une clé SSH : Configurez une clé SSH pour votre compte Hugging Face comme décrit dans la documentation Hugging Face. Cela est requis pour pousser des modèles sur le Hub via Git.
Étapes de téléversement :
- Créer un dépôt : Utilisez l'interface en ligne de commande Hugging Face pour créer un nouveau dépôt pour votre modèle :
  huggingface-cli repo create <your-repo-name>
  Remplacez <your-repo-name> par le nom de dépôt souhaité (par ex., hexabot-intent-model).
- Cloner le dépôt : Clonez le dépôt nouvellement créé sur votre machine locale :
  git clone [email protected]:<your-username>/<your-repo-name>.git cd <your-repo-name>
  Remplacez <your-username> et <your-repo-name> avec votre nom d'utilisateur Hugging Face et le nom du dépôt.
- Gérer les fichiers volumineux (Git LFS) : Initialisez Git LFS et suivez les fichiers de poids du modèle (généralement situés dans le répertoire model/model_weights à l'intérieur de la sortie Ludwig) :
  git lfs install git lfs track "model/model_weights"
- Copier les fichiers du modèle : Copiez le contenu du répertoire de votre modèle entraîné (par ex., /results/experiment_run_0/model) dans le répertoire cloné du dépôt.
- Valider et pousser : Ajoutez les fichiers, validez vos modifications et poussez-les vers le Hub Hugging Face :
  git add . git commit -m "Upload trained Ludwig NLU model" git push

Votre modèle NLU Ludwig entraîné est maintenant téléversé dans votre dépôt Hugging Face, prêt à être utilisé et partagé ! Vous pouvez ensuite référencer ce modèle dans la configuration du moteur NLU Ludwig d'Hexabot (par ex., dans le config.yaml ou via des variables d'environnement) pour utiliser votre modèle personnalisé entraîné pour votre chatbot.

Étapes suivantes : intégration avec Hexabot

Maintenant que vous avez appris à entraîner vos modèles NLU personnalisés avec Ludwig AI, l'étape suivante est d'intégrer ces modèles dans votre chatbot Hexabot. Pour comprendre comment configurer le moteur Ludwig NLU dans Hexabot et utiliser vos modèles entraînés pour la reconnaissance d'intentions et d'entités dans vos flux de conversation, veuillez consulter la Moteur NLU Ludwig page du guide de l'utilisateur Hexabot. Cette page fournit des instructions détaillées sur la configuration et l'utilisation du moteur Ludwig NLU dans votre projet Hexabot.

PrécédentCréez votre premier plugin

Mis à jour il y a 9 mois

Ce contenu vous a-t-il été utile ?

Bonsoir