Consultez le dépôt des livres de recettes Gemma pour des exemples de génération et de réglage ! En savoir plus

Cette page a été traduite par l'API Cloud Translation.

Créer un assistant IA de messagerie professionnelle avec Gemma

La gestion des demandes des clients, y compris des e-mails, est une partie nécessaire de la gestion de nombreuses entreprises, mais elle peut rapidement devenir écrasante. Avec un peu d'effort, les modèles d'intelligence artificielle (IA) tels que Gemma peuvent vous aider à y parvenir plus facilement.

Chaque entreprise gère les demandes comme les e-mails un peu différemment. d'être capable d'adapter des technologies comme l'IA générative aux besoins votre entreprise. Ce projet aborde le problème spécifique d'extraction des informations de commande à partir des e-mails envoyés à une boulangerie et de leur conversion en données structurées afin qu'elles puissent être rapidement ajoutées à un système de gestion des commandes. Utiliser 10 à 20 exemples de demandes et la sortie souhaitée, vous pouvez régler un modèle Gemma pour traiter les e-mails de votre clients, vous permettre de réagir rapidement et de s'intégrer à vos systèmes d'entreprise existants. Ce projet est conçu comme un modèle d'application d'IA que vous pouvez étendre et auquel vous pouvez vous adapter. à dégager de la valeur des modèles Gemma pour votre entreprise.

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 Assistant d'IA pour les e-mails professionnels sur Build with Google AI. 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 à l'aide des éléments suivants : instructions.

Présentation

Ce tutoriel vous explique comment configurer, exécuter et développer une entreprise d'assistant de messagerie créé avec Gemma, Python et Flask. Le projet fournit une interface utilisateur Web de base que vous pouvez modifier selon vos besoins. L'application est conçue pour extraire des données des e-mails des clients dans une structure pour une boulangerie fictive. Vous pouvez utiliser ce modèle d'application pour toute tâche métier qui utilise une entrée et une sortie textuelles.

Capture d'écran de l'interface utilisateur de l'application Web

Figure 1. Interface utilisateur du projet pour le traitement des demandes par e-mail concernant la boulangerie

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 GPU ou TPU 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 construisez ce projet sur Google Cloud Instance de VM, configurez l'instance en respectant les conditions suivantes:

Matériel GPU : un GPU NVIDIA T4 est nécessaire pour exécuter ce projet (NVIDIA L4 ou version ultérieure recommandée)
Système d'exploitation: choisissez une option Deep Learning on Linux. en particulier Deep Learning VM avec CUDA 12.3 M124, pilotes logiciels GPU.
Taille du disque de démarrage: provisionnez au moins 50 Go d'espace disque les données, les modèles et les logiciels associés.

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 du logiciel prérequis, en clonant le projet à partir du dépôt de code, en définissant quelques l'installation de bibliothèques Python et le test de l'application Web.

Installation et configuration

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 devez git pour récupérer le code source, le code source du projet.

Pour télécharger le code du projet:

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

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

Vous pouvez éventuellement configurer votre dépôt Git local pour utiliser le paiement creuse. Vous n'avez donc que les fichiers du projet:
```
cd gemma-cookbook/
git sparse-checkout set Demos/business-email-assistant/
git sparse-checkout init --cone
```

Installer des bibliothèques Python

Installer les bibliothèques Python avec l'environnement virtuel Python venv activée 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:

Dans une fenêtre de terminal, accédez au répertoire business-email-assistant:
```
cd Demos/business-email-assistant/
```
Configurez et activez l'environnement virtuel Python (venv) pour ce projet:
```
python3 -m venv venv
source venv/bin/activate
```
Installez les bibliothèques Python requises pour ce projet à l'aide du script setup_python :
```
./setup_python.sh
```

Définir des variables d'environnement

Pour s'exécuter, ce projet nécessite quelques variables d'environnement, y compris un nom d'utilisateur Kaggle et un jeton d'API Kaggle. Vous devez avoir un Kaggle et demander l'accès aux modèles Gemma afin de pouvoir les télécharger. Pour ce projet, vous ajoutez votre nom d'utilisateur Kaggle et votre jeton d'API Kaggle à deux .env qui sont lus par l'application Web et le programme de réglage, respectivement.

Pour définir les variables d'environnement :

Obtenez votre nom d'utilisateur Kaggle et votre clé de jeton en suivant les instructions dans la documentation Kaggle.
Pour accéder au modèle Gemma, suivez les instructions Accéder à Gemma sur la page Configuration de Gemma.
Créez des fichiers de variables d'environnement pour le projet en créant un fichier texte .env à chaque emplacement dans votre clone du projet :
```
email-processing-webapp/.env
model-tuning/.env
```
Après avoir créé les fichiers texte .env, ajoutez les paramètres suivants pour les deux :
```
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 faites-le comme une vérification de référence avant de modifier le projet pour votre usage personnel.

Pour exécuter et tester le projet:

Dans une fenêtre de terminal, accédez au répertoire email-processing-webapp :
```
cd business-email-assistant/email-processing-webapp/
```
Exécutez l'application à l'aide du script run_app :
```
./run_app.sh
```
Après le démarrage de l'application Web, le code du programme liste une URL à laquelle vous pouvez accéder pour la parcourir et la tester. Cette adresse est généralement la suivante :
```
http://127.0.0.1:5000/
```
Dans l'interface Web, appuyez sur le bouton Get data (Obtenir des données) sous la première 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. Requêtes d'invite ultérieures et génération sur une application Web déjà en cours d'exécution et les terminer en moins de temps.

Étendre 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 avec les données d'entrée. de l'utilisateur une requête complète du modèle. Vous pouvez modifier ces instructions pour modifier le comportement du modèle, par exemple en spécifiant les noms des paramètres et la structure du fichier JSON à générer. Un moyen plus simple de modifier le comportement le modèle consiste à fournir des instructions ou des conseils supplémentaires en spécifiant, par exemple, que les réponses générées ne doivent pas inclure Mise en forme Markdown.

Pour modifier les instructions de requête :

Dans le projet de développement, ouvrez le business-email-assistant/email-processing-webapp/app.py.

Dans le code app.py, ajoutez des instructions supplémentaires au Fonction get_prompt()::

def get_prompt():
  return """
    Extract the relevant details of this request and return them in
    JSON code, with no additional markdown formatting:\n"""

Cet exemple ajoute la phrase "sans mise en forme Markdown supplémentaire" aux instructions.

Le fait de fournir des instructions supplémentaires pour la requête peut fortement influencer et nécessite beaucoup moins d'efforts à mettre en œuvre. Tu devrais essayer ceci 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 des jetons d'entrée du modèle, qui est 8 192 jetons pour Gemma 2, nécessite d'équilibrer les instructions de requête détaillées avec la taille des nouvelles données que vous fournissez afin de rester en dessous de cette limite.

Régler le modèle

Le réglage fin d'un modèle Gemma est le moyen recommandé de le faire répondre plus fiablement pour des tâches spécifiques. En particulier, si vous souhaitez que le modèle pour générer du code JSON dans une structure spécifique, y compris vous devez envisager d'adapter le modèle à ce comportement. Selon la tâche que vous souhaitez que le modèle effectue, vous pouvez effectuer des tâches avec 10 à 20 exemples. Cette section du tutoriel explique comment configurer et exécuter le réglage d'un modèle Gemma pour une tâche spécifique.

Les instructions suivantes expliquent comment effectuer l'affinage sur une environnement de VM, vous pouvez également effectuer cette opération de réglage à l'aide du associés Bloc-notes Colab pour 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. Quand ? vous réglez un modèle pour une tâche spécifique, vous avez besoin d'un ensemble de requêtes des exemples de réponse. 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 vous préparer un jeu de données avec environ 10 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. Si vous utilisez régler le modèle pour produire un format de données structurées, assurez-vous que toutes les strictement conformes au format de sortie de données que vous souhaitez. Les éléments suivants : contient quelques exemples d'enregistrements issus de l'ensemble de données de cet exemple de code:

Requête	Réponse
Bonjour Indian Bakery Central,\nAvez-vous 10 pendas, et trente bundi ladoos à portée de main ? Vendez-vous aussi du glaçage à la vanille et gâteaux au chocolat. Je cherche une taille de 6 pouces	{ "type": "inquiry", "items": [ { "name": "pendas", "quantity": 10 }, { "name": "bundi ladoos", "quantity": 30 }, { "name": "cake", "filling": null, "frosting": "vanilla", "flavor": "chocolate", "size": "6 in" } ] }
J'ai vu votre établissement sur Google Maps. Vendez-vous du jellabi et du gulab ? Jamun ?	{ "type": "inquiry", "items": [ { "name": "jellabi", "quantity": null }, { "name": "gulab jamun", "quantity": null } ] }

Tableau 1. Liste partielle de l'ensemble de données de réglage de l'extracteur de données de messagerie de la boulangerie.

Format et chargement des données

Vous pouvez stocker vos données de réglage dans n'importe quel format pratique, y compris des enregistrements de base de données, des fichiers JSON, CSV ou de texte brut, à condition de disposer des moyens de récupérer les enregistrements avec du code Python. Ce projet lit les fichiers JSON d'un répertoire data dans un tableau d'objets de dictionnaire. Dans cet exemple de programme de tournage, l'ensemble de données de réglage est chargé dans le module model-tuning/main.py à l'aide de la fonction prepare_tuning_dataset() :

def prepare_tuning_dataset():
    # collect data from JSON files
    prompt_data = read_json_files_to_dicts("./data")
    ...

Comme indiqué précédemment, vous pouvez stocker l'ensemble de données dans un format tant que vous pouvez récupérer les demandes avec les identifiants et les assembler en une chaîne de texte qui sera utilisée comme enregistrement de réglage.

Rassembler les enregistrements de réglage

Pour le processus de réglage, le programme assemble chaque requête et réponse. en une seule chaîne contenant les instructions de requête et le contenu des de réponse. Le programme de réglage segmente ensuite la chaîne afin qu'elle soit consommée par le du modèle. Vous pouvez voir le code permettant d'assembler un enregistrement de réglage dans la fonction prepare_tuning_dataset() du module model-tuning/main.py, comme suit :

def prepare_tuning_dataset():
    ...
    # prepare data for tuning
    tuning_dataset = []
    template = "{instruction}\n{response}"

    for prompt in prompt_data:
        tuning_dataset.append(template.format(instruction=prompt["prompt"],
                                              response=prompt["response"]))

    return tuning_dataset

Cette fonction prend les données en entrée et les met en forme en ajoutant un saut de ligne entre l'instruction et la réponse.

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

Une fois les données de réglage 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 le langage Keras NLP pour régler le modèle la technique d'adaptation de faible classement, ou LoRA, pour générer de nouvelles pondérations de modèle. Par rapport au réglage de précision complet, l'utilisation de LoRA est beaucoup plus efficace en termes de mémoire, car elle s'approche des modifications apportées aux poids du modèle. Vous pouvez ensuite superposer ces pondérations approximatives les pondérations du modèle pour modifier son comportement.

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

Dans une fenêtre de terminal, accédez au répertoire model-tuning/.
```
cd business-email-assistant/model-tuning/
```
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 model-tuning/weights au format suivant :

gemma2-2b_inquiry_tuned_4_epoch##.lora.h5

Dépannage

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

Mémoire insuffisante ou épuisement des ressources: ces erreurs se produisent lorsque le le processus de réglage demande de la mémoire qui dépasse la mémoire GPU ou le CPU disponible mémoire. Assurez-vous de ne pas exécuter l'application Web pendant le réglage est en cours d'exécution. Si vous effectuez le réglage sur un appareil avec 16 Go de mémoire GPU, vérifiez que token_limit est défini sur 256 et que batch_size définie sur 1.
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 réglé

Le processus de réglage génère plusieurs pondérations 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 réglage génère trois fichiers de pondération du 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 :

...
8/8 ━━━━━━━━━━━━━━━━━━━━ 121s 195ms/step - loss: 0.5432 - sparse_categorical_accuracy: 0.5982
Epoch 2/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 194ms/step - loss: 0.3320 - sparse_categorical_accuracy: 0.6966
Epoch 3/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 192ms/step - loss: 0.2135 - sparse_categorical_accuracy: 0.7848

Si vous souhaitez que le taux de précision soit relativement élevé, que le taux soit trop élevé ou très proche de 1,00. les pondérations s'approchent du surapprentissage des données de réglage. Lorsque cela se produit, le ne fonctionne pas bien avec des requêtes très différentes les exemples de réglage. Par défaut, le script de déploiement sélectionne les poids de l'épopée 3, qui ont généralement un taux de précision d'environ 0,80.

Pour déployer les pondérations générées dans l'application Web:

Dans une fenêtre de terminal, accédez au répertoire model-tuning :
```
cd business-email-assistant/model-tuning/
```
Exécutez le processus de réglage à l'aide du script deploy_weights :
```
./deploy_weights.sh
```

Après avoir exécuté ce script, vous devriez voir un nouveau fichier *.h5 dans le email-processing-webapp/weights/.

Tester le nouveau modèle

Après avoir déployé les nouvelles pondérations dans l'application, vous pouvez les tester le modèle nouvellement réglé. Pour ce faire, exécutez à nouveau l'application Web générer une réponse.

Pour exécuter et tester le projet:

Dans une fenêtre de terminal, accédez au répertoire email-processing-webapp :
```
cd business-email-assistant/email-processing-webapp/
```
Exécutez l'application à l'aide du script run_app:
```
./run_app.sh
```
Après avoir démarré l'application Web, le code du programme liste une URL à laquelle vous pouvez accéder et tester. Cette adresse est généralement la suivante :
```
http://127.0.0.1:5000/
```
Dans l'interface Web, appuyez sur le bouton Get data (Obtenir des données) sous la première entrée. pour générer une réponse du modèle.

Vous venez de régler et de déployer un modèle Gemma dans une application. Testez différents l'application et essayer de déterminer les limites de génération du modèle réglé 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.

Ressources supplémentaires

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 Build with Google avec l'IA, consultez le playlist vidéo.