Tutoriel Vicuna-13B : guide pour exécuter Vicuna-13B

L’essor des grands modèles de langage a transformé de nombreux secteurs, en apportant la puissance de technologies comme GPT-3.5 et GPT-4 d’OpenAI à une foule d’applications. Cependant, leur coût élevé et les enjeux de confidentialité des données freinent souvent l’adoption. C’est là que les modèles open source comme Vicuna-13B entrent en jeu : des performances proches, sans les dépenses importantes ni les risques liés aux données sensibles.

Pour en savoir plus sur GPT-3.5 et GPT-4, notre tutoriel Using GPT-3.5 and GPT-4 via the OpenAI API in Python est un bon point de départ pour comprendre comment utiliser le package Python d’OpenAI et dialoguer avec ChatGPT par programmation.

Qu’est-ce que Vicuna-13B ?

Vicuna-13B est un modèle conversationnel open source affiné à partir de LLaMa 13B, en s’appuyant sur des conversations partagées par des utilisateurs et collectées via ShareGPT.

Une évaluation préliminaire, avec GPT-4 en tant que juge, a montré que Vicuna-13B atteint plus de 90 % de la qualité de chatGPT et Google Bard, et surpasse d’autres modèles comme LLaMa et Alpaca dans plus de 90 % des cas. Le flux global de fine-tuning et d’évaluation est illustré ci-dessous :

Flux de fine-tuning et d’évaluation de Vicuna-13B (source)

Si cela met en avant la robustesse de Vicuna-13B, le modèle présente aussi des limites et n’excelle pas sur des tâches comme les mathématiques et le raisonnement.

Image de LMSYSORG modifiée par l’auteur

Applications de Vicuna-13B

En tant que chatbot intelligent, les cas d’usage de Vicuna-13B sont innombrables. Voici quelques exemples dans différents secteurs : service client, santé, éducation, finance et voyage/hôtellerie.

Cinq applications concrètes de Vicuna-13

• Service client : grâce à leur disponibilité 24h/24 et 7j/7, les chatbots peuvent assister les clients et automatiser les demandes simples et répétitives. Par exemple, Sephora utilise des chatbots pour aider ses clients à trouver des produits, vérifier le statut de commande et obtenir des conseils maquillage sur son site.

• Santé : les patients peuvent obtenir rapidement des informations de santé personnalisées, ce qui permet aux spécialistes de se concentrer sur la recherche et de nouveaux traitements. Par exemple, Babylon Health exploite des chatbots dopés à l’IA pour réaliser des bilans et mieux suivre les patients.

• Éducation : de nombreuses institutions réputées, comme Duolingo, utilisent des bots d’IA de manière créative pour accroître l’engagement des étudiants et faciliter la compréhension de notions plus avancées.

• Finance : la première interaction avec ma banque quand j’ai besoin d’aide se fait via un bot intelligent ; de nombreuses banques, comme Wells Fargo, utilisent des technologies similaires pour des tâches répétitives comme consulter un solde, transférer de l’argent ou gérer des comptes.

• Voyage/hôtellerie : comme dans la banque, les chatbots aident à trouver des destinations selon le budget et les contraintes de voyage, et peuvent agir en tant que concierge virtuel. Le chatbot Omar de l’hôtel Equinox New York traite près de 85 % des demandes clients : 2 600 nouvelles requêtes en moins de trois mois et 150 leads qualifiés en quatre mois.

Cette liste est loin d’être exhaustive. Notre article How NLP is changing the future of Data Science explore comment le NLP façonne l’avenir de la data science et du machine learning, ses usages à venir, les risques et comment les atténuer.

Pourquoi apprendre à exécuter Vicuna-13B est pertinent

Au vu de ces cas concrets, la demande pour des agents conversationnels dopés à l’IA comme Vicuna-13B est forte dans la plupart des secteurs.

Maîtriser l’implémentation et l’intégration de ces technologies dans les workflows métiers devient donc une compétence clé, à mesure que les entreprises s’en emparent pour améliorer l’engagement client, générer plus de leads et optimiser leur retour sur investissement.

Bonne nouvelle : l’objectif de ce tutoriel est précisément de vous aider à développer les compétences nécessaires pour exécuter Vicuna-13B et l’intégrer à n’importe quel système d’information.

Prérequis

Avant de se lancer dans l’exécution de Vicuna-13B, il est essentiel de préparer les prérequis suivants :

• Comprendre le workflow de Vicuna-13B
• Mettre en place le matériel et les logiciels nécessaires
• Obtenir les poids LLaMa pour Vicuna-13B

Une fois ces éléments en place, vous comprendrez mieux les formats d’entrée et de sortie et pourrez exécuter le modèle avec succès.

Comprendre le workflow de Vicuna-13B

Bien cerner les formats d’entrée et de sortie de Vicuna-13B donne au développeur la base nécessaire pour anticiper les facteurs qui influencent la prise de décision du modèle.

Cette section détaille les principaux paramètres d’entrée requis ainsi que le format de sortie attendu.

Workflow minimaliste de bout en bout

Décryptons le schéma : l’utilisateur soumet d’abord son entrée, qui comprend l’invite (prompt), c’est-à-dire la requête textuelle principale à laquelle il souhaite une réponse.

L’invite est fournie avec les paramètres suivants :

• Max-length : nombre maximal de caractères à considérer dans la réponse finale.
• Temperature : valeur entre 0 et 1. Plus elle est basse, plus le résultat est déterministe ; plus elle est élevée, plus la sortie est aléatoire, donc variée et créative.
• Top-p : contrôle la diversité des prédictions en sélectionnant les tokens les plus probables dont la probabilité cumulée dépasse un seuil donné. À partir de zéro, une valeur plus élevée augmente les chances d’une meilleure sortie mais requiert plus de calcul.
• Repetition_penalty : si un mot revient trop souvent, ce paramètre évite la sur-répétition et rend la réponse plus variée.
• Seed : pour garantir un résultat cohérent pour une même entrée sur plusieurs exécutions.
• Debug : permet d’activer le mode débogage, utile pour diagnostiquer le comportement et les performances du modèle.

Après l’envoi de l’invite avec ces paramètres, Vicuna-13B effectue le traitement nécessaire et génère une sortie conforme au schéma suivant :

• Text : la réponse textuelle produite par le modèle Vicuna
• Metadata : des informations additionnelles générées par le modèle. Nous les détaillons dans les sections suivantes.

Mise en place du matériel et des logiciels

Maintenant que les formats d’entrée et de sortie sont plus clairs, identifions les principales bibliothèques pour exécuter le modèle Vicuna.

• Conda : garantit un environnement propre et isolé pour les dépendances de Vicuna.
• FastAPI : framework moderne pour développer l’API de Vicuna avec analyse automatique des invites utilisateurs.
• Uvicorn : sert l’application FastAPI de Vicuna, pour des performances efficaces et fiables.
• LLaMa.cpp : gère la complexité de traitement des grands modèles de langage qui composent Vicuna.

Créer l’environnement virtuel

Toutes les commandes de cette section se lancent depuis un terminal. À l’aide de conda create, nous créons un environnement virtuel nommé vicuna-env.

conda create --name vicuna-env

Après avoir créé l’environnement virtuel, on l’active avec la commande conda activate :

conda activate vicuna-env

La ligne de commande doit alors afficher le nom de l’environnement entre crochets au début du terminal, comme ci-dessous :

Nom de l’environnement virtuel après activation

Installer les bibliothèques

Deux approches sont possibles. La première consiste à exécuter manuellement pip install pour chaque bibliothèque : chronophage et peu optimale en contexte industriel.

La seconde, recommandée, repose sur un fichier requirements.txt listant les dépendances. Voici son contenu et l’installation via une seule commande pip install.

# Contenu du fichier requirements.txt

llama-cpp-python==0.1.48
fastapi 
uvicorn[standard]

L’installation des trois bibliothèques se fait ainsi :

pip install -r requirements.txt

Obtenir les poids LLaMa

Depuis la plateforme Hugging Face, téléchargez les poids du modèle Vicuna comme illustré ci-dessous :

Deux étapes pour télécharger les poids de Vicuna-13B depuis Hugging Face

Pour mieux organiser le code, déplacez les poids téléchargés dans un dossier model dédié.

Packager et construire une API

Même si tout est prêt pour exécuter le modèle en ligne de commande, déployer une API qui l’expose est plus pratique et le rend accessible à davantage d’utilisateurs.

Pour y parvenir, voici les étapes :

• Charger le modèle en local
• Construire une API pour l’exposer

La structure globale du code source est donnée ci-dessous. Le code complet est disponible sur GitHub.

------ model
         |------- ggml-vicuna-13b-4bit.bin

------ requirements.txt
------ vicuna_app.py

• ggml-vicuna-13b-4bit.bin : poids du modèle téléchargé, placé dans le dossier model
• requirements.txt : dépendances nécessaires à l’exécution
• vicuna_app.py : code Python de création de l’API, cœur de cette section.

Définir les routes principales de l’API

Deux routes principales suffisent ici. Avant cela, importons les bibliothèques, chargeons le modèle et créons l’instance FastAPI.

# Import des bibliothèques
from fastapi import FastAPI, HTTPException
from llama_cpp import Llama

# Chargement du modèle 
vicuna_model_path = "./model/ggml-vicuna-13b-4bit.bin"
vicuna_model = Llama(model_path=vicuna_model_path)

app = FastAPI()

• Première route : la route par défaut "/" renvoie le JSON "Message": "Welcome to the Vicuna Demo FastAPI" via la fonction home() sans paramètre.

# Définition de la route par défaut
@app.get("/")
def home():
   return {"Message": "Welcome to the Vicuna Demo FastAPI"}

• Seconde route : "/vicuna_says" déclenche la fonction answer_prompt(), qui prend l’invite de l’utilisateur en paramètre et renvoie une réponse JSON avec le résultat du modèle Vicuna et des métadonnées.

@app.post("/vicuna_says")
def answer_prompt(user_prompt):

   if (not (user_prompt)):
       raise HTTPException(status_code=400,
                           detail="Please Provide a valid text message")

   response = vicuna_model(user_prompt)

   return {"Answer": response}

Exécuter les routes

Nous pouvons maintenant lancer l’API avec la commande suivante, depuis le répertoire contenant vicuna_app.py.

uvicorn vicuna_app:app --reload

• uvicorn démarre le serveur ASGI Uvicorn.
• vicuna_app : correspond au fichier Python vicuna_app.py, à gauche des deux-points.
• app : c’est l’objet créé dans vicuna_app.py via app = FastAPI(). Si le fichier s’appelait main.py, la commande serait uvicorn main:app --reload.
• --reload : redémarre automatiquement le serveur à chaque modification du code. À réserver au développement, pas à la production.

Voici le résultat après exécution : le serveur tourne en local sur le port 8000 (http://127.0.0.1:8000)

URL de l’API en local

Accéder à la route par défaut est trivial : saisissez simplement l’URL suivante dans votre navigateur.

Réponse de la route par défaut

Autre point intéressant : l’URL http://127.0.0.1:8000/docs fournit une interface complète pour interagir avec l’API, comme ci-dessous.

Visualisation graphique des deux routes

En sélectionnant /vicuna_says (encadré vert), on obtient le guide d’utilisation détaillé de l’API, comme suit.

Les trois étapes pour exécuter l’invite utilisateur

Cliquez sur Try it out et saisissez votre message dans la zone text_message.

Après avoir cliqué sur Execute, vous obtenez le résultat suivant.

Réponse du serveur Vicuna à la requête utilisateur

La réponse du modèle Vicuna apparaît dans le champ « text » ; le résultat est convaincant.

Des métadonnées complémentaires sont fournies : modèle utilisé, date de création de la réponse, nombre de tokens dans l’invite et dans la réponse, etc.

Comment le déploiement facilite l’usage de Vicuna-13B

Déployer un modèle aussi puissant améliore l’expérience utilisateur et l’efficacité opérationnelle de plusieurs façons, notamment :

• Facilité d’accès : accès via API, sans téléchargement ni configuration locale.

• Gestion des ressources : des serveurs dimensionnés gèrent des requêtes simultanées de manière fiable.

• Scalabilité : montée en charge selon la demande, pour des performances constantes.

• Mises à jour et maintenance : centralisées, pour garantir l’accès à la dernière version.

• Intégration : connexion facilitée avec d’autres systèmes et applications, élargissant les cas d’usage.


En bref, le déploiement rend l’usage de Vicuna-13B plus accessible, fiable et polyvalent, et élargit son champ d’application.

Bonnes pratiques et conseils pour Vicuna-13B

Pour travailler efficacement avec Vicuna-13B, quelques bonnes pratiques et conseils aident à optimiser les performances et à résoudre les problèmes fréquents.

Conseils pour optimiser les performances de Vicuna-13B

En suivant ces recommandations, vous gagnerez en fluidité d’usage et en qualité de résultats avec Vicuna-13B.

4 conseils pour optimiser les performances de Vicuna-13B

• Optimisation matérielle : assurez-vous que le serveur hébergeant Vicuna-13B dispose de suffisamment de RAM et de CPU pour répondre aux besoins de calcul.
• Traitement par lots : exploitez le parallélisme du modèle en traitant les données par lots lorsque c’est possible.
• Mise en cache des résultats : mettez en cache les réponses aux requêtes courantes pour réduire les calculs redondants et accélérer les temps de réponse.
• Prétraitement des entrées : préparez les données d’entrée dans un format optimal pour le modèle afin d’améliorer précision et performance.

Dépannage des problèmes courants

Au-delà de l’optimisation, il est crucial de savoir résoudre les problèmes fréquemment rencontrés avec Vicuna-13B. Voici quatre exemples :

Quelques problèmes de dépannage courants

• Erreurs mémoire : augmentez la RAM du serveur ou réduisez la taille des entrées pour rester dans les limites du modèle.
• Lenteurs : améliorez le CPU du serveur ou utilisez un traitement par lots pour réduire les temps de réponse.
• Sorties incorrectes : examinez soigneusement les entrées pour détecter anomalies ou erreurs susceptibles d’influencer le résultat.
• Problèmes d’intégration : relisez la documentation de l’API et vérifiez la configuration de chaque point d’intégration.

Conclusion

En résumé, cet article propose une vue d’ensemble complète de la mise en place et de l’utilisation de Vicuna-13B. Nous avons couvert les prérequis matériels et logiciels, ainsi que l’obtention des poids LLaMa indispensables à l’exécution du modèle.

Nous avons détaillé la création de l’environnement de travail, l’installation des dépendances et la configuration des poids de Vicuna-13B, en soulignant le rôle central des poids dans les modèles de langage.

Nous avons également abordé le packaging et le déploiement de Vicuna-13B, en montrant comment le déploiement facilite son utilisation via une interface web et une API.

Enfin, nous avons partagé des conseils pratiques pour interagir avec Vicuna-13B, des exemples de ses capacités, ainsi que des bonnes pratiques pour optimiser ses performances et dépanner les problèmes courants.

Envie d’aller plus loin dans l’IA et le machine learning ? Développez vos compétences avec le framework de deep learning plébiscité par les professionnels. Rejoignez dès aujourd’hui le cours Deep Learning with PyTorch.