Tâches dans des langues parlées avec Gemma

Pour de nombreuses entreprises, l'utilisation de la technologie d'intelligence artificielle (IA) dans une langue parlée spécifique est un besoin essentiel pour pouvoir l'utiliser efficacement. La famille de modèles Gemma dispose de certaines fonctionnalités multilingues, mais son utilisation dans d'autres langues que l'anglais produit souvent des résultats moins qu'idéaux.

Heureusement, vous n'avez pas besoin d'enseigner à Gemma une langue parlée complète pour qu'elle puisse effectuer des tâches dans cette langue. De plus, vous pouvez ajuster les modèles Gemma pour effectuer des tâches spécifiques dans une langue avec beaucoup moins de données et d'efforts que vous ne le pensez. En utilisant environ 20 exemples de requêtes et de réponses attendues dans votre langue cible, vous pouvez demander à Gemma de vous aider à résoudre de nombreux problèmes commerciaux différents dans la langue qui vous convient le mieux, à vous et à vos clients.

Pour obtenir une présentation vidéo du projet et découvrir comment l'étendre, y compris des insights de ses créateurs, regardez la vidéo de création avec l'IA de Google sur l'assistant d'IA pour la langue parlée. Vous pouvez également consulter le code de ce projet dans le dépôt de code du livre de recettes Gemma. Sinon, vous pouvez commencer à étendre le projet en suivant les instructions ci-dessous.

Présentation

Ce tutoriel vous explique comment configurer, exécuter et étendre une application de tâches de langage parlé créée avec Gemma et Python. L'application fournit une interface utilisateur Web de base que vous pouvez modifier en fonction de vos besoins. L'application est conçue pour générer des réponses aux e-mails des clients d'une boulangerie coréenne fictive. Toutes les entrées et sorties linguistiques sont entièrement gérées en coréen. Vous pouvez utiliser ce modèle d'application avec n'importe quelle langue et n'importe quelle tâche métier qui utilise une entrée et une sortie textuelles.

Figure 1. Interface utilisateur du projet, pour les demandes par e-mail concernant une boulangerie coréenne

Matériel requis

Exécutez ce processus de réglage sur un ordinateur équipé d'un processeur graphique (GPU) ou d'un Tensor Processing Unit (TPU), et d'une mémoire suffisante pour contenir le modèle existant, ainsi que les données de réglage. Pour exécuter la configuration de réglage de ce projet, vous avez besoin d'environ 16 Go de mémoire GPU, d'environ la même quantité de RAM standard et d'au moins 50 Go d'espace disque.

Vous pouvez exécuter la partie de ce tutoriel consacrée au réglage du modèle Gemma à l'aide d'un environnement Colab avec un environnement d'exécution GPU T4. Si vous créez ce projet sur une instance de VM Google Cloud, configurez l'instance en respectant les exigences suivantes :

• Matériel GPU : Un GPU NVIDIA T4 est nécessaire pour exécuter ce projet, et un GPU NVIDIA L4 ou version ultérieure est recommandé.
• Operating System (Système d'exploitation) : sélectionnez une option Deep Learning on Linux (Deep Learning sous Linux), en particulier la Deep Learning VM with CUDA 12.3 M124 (VM Deep Learning avec CUDA 12.3 M124) avec des pilotes logiciels de GPU préinstallés.
• Taille du disque de démarrage: provisionnez au moins 50 Go d'espace disque pour vos données, vos modèles et vos logiciels complémentaires.

Configuration du projet

Ces instructions vous expliquent comment préparer ce projet pour le développement et les tests. Les étapes de configuration générales incluent l'installation des logiciels préalables, le clonage du projet à partir du dépôt de code, la configuration de quelques variables d'environnement, l'installation de bibliothèques Python et le test de l'application Web.

Installer et configurer

Ce projet utilise Python 3 et des environnements virtuels (venv) pour gérer les packages et exécuter l'application. Les instructions d'installation suivantes s'appliquent à une machine hôte Linux.

Pour installer le logiciel requis :

• Installez Python 3 et le package d'environnement virtuel venv pour Python.

  sudo apt update
  sudo apt install git pip python3-venv
  

Cloner le projet

Téléchargez le code du projet sur votre ordinateur de développement. Vous avez besoin du logiciel de contrôle des versions git pour récupérer le code source du projet.

Pour télécharger le code du projet:

1. Clonez le dépôt Git à l'aide de la commande suivante.

   git clone https://github.com/google-gemini/gemma-cookbook.git
   

2. Vous pouvez également configurer votre dépôt Git local pour utiliser un "checkout" clairsemé afin de ne conserver que les fichiers du projet.

   cd gemma-cookbook/
   git sparse-checkout set Gemma/spoken-language-tasks/
   git sparse-checkout init --cone
   

Installer des bibliothèques Python

Installez les bibliothèques Python avec l'environnement virtuel Python venv activé pour gérer les packages et les dépendances Python. Assurez-vous d'activer l'environnement virtuel Python avant d'installer les bibliothèques Python avec l'installateur pip. Pour en savoir plus sur l'utilisation des environnements virtuels Python, consultez la documentation sur Python venv.

Pour installer les bibliothèques Python :

1. Dans une fenêtre de terminal, accédez au répertoire spoken-language-tasks :

   cd Gemma/spoken-language-tasks/
   

2. Configurez et activez l'environnement virtuel Python (venv) pour ce projet:

   python3 -m venv venv
   source venv/bin/activate
   

3. Installez les bibliothèques Python requises pour ce projet à l'aide du script setup_python.

   ./setup_python.sh
   

Définir des variables d'environnement

Définissez quelques variables d'environnement requises pour permettre l'exécution de ce projet de code, y compris un nom d'utilisateur Kaggle et une clé de jeton Kaggle. Pour pouvoir les télécharger, vous devez disposer d'un compte Kaggle et demander l'accès aux modèles Gemma. Pour ce projet, vous ajoutez votre nom d'utilisateur Kaggle et votre clé de jeton Kaggle à deux fichiers .env, qui sont lus respectivement par l'application Web et le programme de réglage.

Pour définir les variables d'environnement :

1. Obtenez votre nom d'utilisateur Kaggle et votre clé de jeton en suivant les instructions de la documentation Kaggle.
2. Pour accéder au modèle Gemma, suivez les instructions Accéder à Gemma sur la page Configuration de Gemma.
3. Créez des fichiers de variables d'environnement pour le projet en créant un fichier texte .env à chacun des emplacements suivants dans votre clone du projet:

   k-mail-replier/k_mail_replier/.env
   k-gemma-it/.env
   

4. Après avoir créé les fichiers texte .env, ajoutez les paramètres suivants aux deux fichiers :

   KAGGLE_USERNAME=<YOUR_KAGGLE_USERNAME_HERE>
   KAGGLE_KEY=<YOUR_KAGGLE_KEY_HERE>
   

Exécuter et tester l'application

Une fois l'installation et la configuration du projet terminées, exécutez l'application Web pour vérifier que vous l'avez correctement configurée. Vous devez effectuer cette opération comme vérification de référence avant de modifier le projet pour votre usage personnel.

Pour exécuter et tester le projet :

1. Dans une fenêtre de terminal, accédez au répertoire /k_mail_replier/ :

   cd spoken-language-tasks/k-mail-replier/
   

2. Exécutez l'application à l'aide du script run_flask_app.sh:

   ./run_flask_app.sh
   

3. Une fois l'application Web démarrée, le code du programme liste une URL que vous pouvez parcourir et tester. Généralement, il s'agit de l'adresse suivante:

   http://127.0.0.1:5000/
   

4. Dans l'interface Web, appuyez sur le bouton 답변 작성 sous le premier champ d'entrée pour générer une réponse du modèle.

La première réponse du modèle après l'exécution de l'application prend plus de temps, car il doit effectuer les étapes d'initialisation lors de la première génération. Les requêtes et la génération d'invites ultérieures sur une application Web déjà en cours d'exécution sont effectuées plus rapidement.

Développer l'application

Une fois l'application en cours d'exécution, vous pouvez l'étendre en modifiant l'interface utilisateur et la logique métier pour qu'elle fonctionne pour les tâches qui vous intéressent ou qui concernent votre entreprise. Vous pouvez également modifier le comportement du modèle Gemma à l'aide du code de l'application en modifiant les composants de la requête que l'application envoie au modèle d'IA générative.

L'application fournit des instructions au modèle, ainsi que les données d'entrée de l'utilisateur, pour une requête complète du modèle. Vous pouvez modifier ces instructions pour changer le comportement du modèle, par exemple en spécifiant que le modèle doit extraire des informations de la requête et les placer dans un format de données structurées, tel que JSON. Un moyen plus simple de modifier le comportement du modèle consiste à fournir des instructions ou des conseils supplémentaires pour la réponse du modèle, par exemple en spécifiant que les réponses générées doivent être rédigées dans un ton poli.

Pour modifier les instructions d'une requête:

1. Dans le projet "tâche de langue parlée", ouvrez le fichier de code k-mail-replier/k_mail_replier/app.py.

2. Dans le code app.py, ajoutez des instructions d'addition à la fonction get_prompt(): :

   def get_prompt():
       return "발신자에게 요청에 대한 감사를 전하고, 곧 자세한 내용을
           알려드리겠다고 정중하게 답장해 주세요. 정중하게 답변해 주세요!:\n"
   

Dans cet exemple, l'expression "Veuillez écrire une réponse polie !" est ajoutée aux instructions en coréen.

Fournir des instructions d'invite supplémentaires peut fortement influencer la sortie générée et nécessite beaucoup moins d'efforts à implémenter. Vous devez d'abord essayer cette méthode pour voir si vous pouvez obtenir le comportement souhaité du modèle. Toutefois, l'utilisation d'instructions d'invite pour modifier le comportement d'un modèle Gemma a ses limites. En particulier, la limite globale de jetons d'entrée du modèle, qui est de 8 192 jetons pour Gemma 2, vous oblige à équilibrer les instructions d'invite détaillées avec la taille des nouvelles données que vous fournissez afin de rester en dessous de cette limite.

De plus, lorsque vous souhaitez que Gemma effectue des tâches dans une langue autre que l'anglais, il est peu probable qu'une simple requête au modèle de base produise des résultats utiles. Vous devez plutôt ajuster le modèle avec des exemples dans la langue cible, puis ensuite envisager de modifier les instructions de requête pour effectuer des ajustements plus précis sur la sortie du modèle ajusté.

Régler le modèle

Le réglage fin d'un modèle Gemma est le moyen recommandé de le faire répondre efficacement dans une langue parlée autre que l'anglais. Toutefois, vous n'avez pas besoin de viser une maîtrise parfaite de votre langue cible pour que le modèle puisse effectuer des tâches dans cette langue. Vous pouvez effectuer des fonctionnalités de base dans votre langue cible pour une tâche avec environ 20 exemples. Cette section du tutoriel explique comment configurer et exécuter un ajustement fin sur un modèle Gemma pour une tâche spécifique, dans une langue spécifique.

Les instructions suivantes expliquent comment effectuer l'opération de réglage fin dans un environnement de VM. Toutefois, vous pouvez également effectuer cette opération de réglage à l'aide du notebook Colab associé à ce projet.

Matériel requis

Les exigences de calcul pour le réglage fin sont les mêmes que les exigences matérielles pour le reste du projet. Vous pouvez exécuter l'opération de réglage dans un environnement Colab avec un environnement d'exécution GPU T4 si vous limitez les jetons d'entrée à 256 et la taille de lot à 1.

Préparer les données

Avant de commencer à régler un modèle Gemma, vous devez préparer les données pour le réglage. Lorsque vous ajustez un modèle pour une tâche et une langue spécifiques, vous avez besoin d'un ensemble d'exemples de requêtes et de réponses dans cette langue cible. Ces exemples doivent afficher le texte de la requête, sans aucune instruction, et le texte de la réponse attendue. Pour commencer, vous devez préparer un ensemble de données d'environ 20 exemples. Ces exemples doivent représenter une grande variété de requêtes et les réponses idéales. Assurez-vous que les requêtes et les réponses ne sont pas répétitives, car cela peut entraîner la répétition des réponses des modèles et leur non-adaptation appropriée aux variations des requêtes. Le tableau suivant présente quelques exemples d'enregistrements du jeu de données de cet exemple de code :

Tableau 1. Liste partielle de l'ensemble de données de réglage pour le répondeur par e-mail de la boulangerie coréenne.

Format et chargement des données

Vous pouvez stocker vos données de réglage dans le format qui vous convient, y compris des enregistrements de base de données, des fichiers JSON, des fichiers CSV ou des fichiers texte brut, à condition que vous ayez les moyens de récupérer les enregistrements avec du code Python. Pour plus de commodité, l'exemple de programme de réglage récupère les enregistrements à partir d'un dépôt en ligne. Dans cet exemple de programme de tournage, l'ensemble de données de réglage est chargé dans le module k-gemma-it/main.py à l'aide de la fonction prepare_tuning_dataset() :

def prepare_tuning_dataset():
    tokenizer = keras_nlp.models.GemmaTokenizer.from_preset(model_id)

    # load data from repository (or local directory)
    from datasets import load_dataset
    ds = load_dataset(
        # Dataset : https://huggingface.co/datasets/bebechien/korean_cake_boss
        "bebechien/korean_cake_boss",
        split="train",
    )
    ...

Comme indiqué précédemment, vous pouvez stocker l'ensemble de données dans un format pratique, à condition de pouvoir récupérer les requêtes avec les réponses associées et de les assembler dans une chaîne de texte utilisée comme enregistrement de réglage.

Rassembler les enregistrements de réglage

Pour le processus de réglage, chaque requête et chaque réponse est assemblée dans une seule chaîne avec les instructions et les balises d'invite pour indiquer le contenu de la requête et le contenu de la réponse. Ce programme de réglage tokenize ensuite la chaîne pour qu'elle soit utilisée par le modèle. Vous pouvez consulter le code d'assemblage d'un enregistrement de réglage dans la fonction prepare_tuning_dataset() du module k-gemma-it/main.py, comme suit:

def prepare_tuning_dataset():
    ...
    prompt_instruction = "다음에 대한 이메일 답장을 작성해줘."

    for x in data:
        item = f"<start_of_turn>user\n{prompt_instruction}\n\"{x['input']}\"<end_of_turn>\n<start_of_turn>model\n{x['output']}<end_of_turn>"
        length = len(tokenizer(item))
        # skip data if the token length is longer than our limit
        if length < token_limit:
            tuning_dataset.append(item)
            if(len(tuning_dataset)>=num_data_limit):
                break
    ...

Cette fonction lit les données et les met en forme en ajoutant des balises start_of_turn et end_of_turn, qui sont le format requis lorsque vous fournissez des données pour régler un modèle Gemma. Ce code insère également un prompt_instruction pour chaque requête, que vous devez modifier en fonction de votre application.

Générer des pondérations de modèle

Une fois que les données de réglage sont en place et chargées, vous pouvez exécuter le programme de réglage. Le processus de réglage de cet exemple d'application utilise la bibliothèque NLP Keras pour ajuster le modèle avec une adaptation à faible rang, ou technique LoRA, afin de générer de nouvelles pondérations de modèle. Par rapport au réglage de précision totale, la LoRA est beaucoup plus économe en mémoire, car elle se rapproche des modifications apportées aux pondérations du modèle. Vous pouvez ensuite superposer ces pondérations approchées aux pondérations du modèle existantes pour modifier le comportement du modèle.

Pour effectuer l'exécution de réglage et calculer de nouveaux poids :

1. Dans une fenêtre de terminal, accédez au répertoire k-gemma-it/.

   cd spoken-language-tasks/k-gemma-it/
   

2. Exécutez le processus de réglage à l'aide du script tune_model:

   ./tune_model.sh
   

Le processus de réglage prend plusieurs minutes en fonction de vos ressources de calcul disponibles. Une fois l'opération terminée, le programme de réglage écrit de nouveaux fichiers de poids *.h5 dans le répertoire k-gemma-it/weights au format suivant :

gemma2-2b_k-tuned_4_epoch##.lora.h5

Dépannage

Si l'ajustement ne s'effectue pas correctement, deux raisons sont possibles :

1. Mémoire saturée/Ressources épuisées : ces erreurs se produisent lorsque le processus de réglage demande de la mémoire qui dépasse la mémoire GPU ou CPU disponible. Assurez-vous de ne pas exécuter l'application Web pendant le processus d'ajustement. Si vous effectuez le réglage sur un appareil disposant de 16 Go de mémoire GPU, assurez-vous que token_limit est défini sur 256 et batch_size sur 1.
2. Pilotes de GPU non installés ou incompatibles avec JAX : le processus de conversion nécessite que l'appareil de calcul dispose de pilotes matériels installés qui sont compatibles avec la version des bibliothèques JAX. Pour en savoir plus, consultez la documentation sur l'installation de JAX.

Déployer le modèle affiné

Le processus de réglage génère plusieurs poids en fonction des données de réglage et du nombre total d'époques défini dans l'application de réglage. Par défaut, le programme de réglage génère 20 fichiers de poids de modèle, un pour chaque époque de réglage. Chaque époque de réglage successive produit des poids qui reproduisent plus précisément les résultats des données de réglage. Vous pouvez consulter les taux de justesse pour chaque époque dans la sortie du terminal du processus de réglage, comme suit :

...
Epoch 14/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 567ms/step - loss: 0.4026 - sparse_categorical_accuracy: 0.8235
Epoch 15/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 569ms/step - loss: 0.3659 - sparse_categorical_accuracy: 0.8382
Epoch 16/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 571ms/step - loss: 0.3314 - sparse_categorical_accuracy: 0.8538
Epoch 17/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 572ms/step - loss: 0.2996 - sparse_categorical_accuracy: 0.8686
Epoch 18/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 574ms/step - loss: 0.2710 - sparse_categorical_accuracy: 0.8801
Epoch 19/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 575ms/step - loss: 0.2451 - sparse_categorical_accuracy: 0.8903
Epoch 20/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 575ms/step - loss: 0.2212 - sparse_categorical_accuracy: 0.9021

Bien que vous souhaitiez que le taux de précision soit relativement élevé, entre 0,80 et 0,90, vous ne voulez pas qu'il soit trop élevé ou très proche de 1,00, car cela signifie que les poids ont presque surappris les données de réglage. Dans ce cas, le modèle ne fonctionne pas bien avec les requêtes qui sont très différentes des exemples de réglage. Par défaut, le script de déploiement sélectionne les pondérations de l'épopée 17, qui ont généralement un taux de précision d'environ 0,90.

Pour déployer les poids générés dans l'application Web :

1. Dans une fenêtre de terminal, accédez au répertoire k-gemma-it/.

   cd spoken-language-tasks/k-gemma-it/
   

2. Exécutez le processus de réglage à l'aide du script deploy_weights :

   ./deploy_weights.sh
   

Une fois ce script exécuté, un nouveau fichier *.h5 devrait s'afficher dans le répertoire k-mail-replier/k_mail_replier/weights/.

Tester le nouveau modèle

Une fois que vous avez déployé les nouveaux poids dans l'application, il est temps de tester le nouveau modèle affiné. Pour ce faire, exécutez à nouveau l'application Web et générez une réponse.

Pour exécuter et tester le projet :

1. Dans une fenêtre de terminal, accédez au répertoire /k_mail_replier/.

   cd spoken-language-tasks/k-mail-replier/
   

2. Exécutez l'application à l'aide du script run_flask_app.sh :

   ./run_flask_app.sh
   

3. Après avoir démarré l'application Web, le code du programme affiche une URL que vous pouvez parcourir et tester. En général, cette adresse est la suivante:

   http://127.0.0.1:5000/
   

4. Dans l'interface Web, appuyez sur le bouton 답변 작성 sous le premier champ de saisie pour générer une réponse du modèle.

Vous avez maintenant affiné et déployé un modèle Gemma dans une application. Testez l'application et essayez de déterminer les limites des capacités de génération du modèle affiné pour votre tâche. Si vous trouvez des scénarios dans lesquels le modèle ne fonctionne pas bien, envisagez d'ajouter certaines de ces requêtes à votre liste d'exemples de données de réglage en ajoutant la requête et en fournissant une réponse idéale. Exécutez ensuite à nouveau le processus de réglage, redéployez les nouveaux poids et testez la sortie.

Autres ressources

Pour en savoir plus sur ce projet, consultez le dépôt de code du livre de recettes Gemma. Si vous avez besoin d'aide pour créer l'application ou si vous souhaitez collaborer avec d'autres développeurs, consultez le serveur Discord de la communauté des développeurs Google. Pour découvrir d'autres projets "Créer avec l'IA de Google", consultez la playlist vidéo.