1. Introduction
Les produits d'IA générative sont relativement récents, et les comportements d'une application peuvent varier plus que les versions logicielles plus anciennes. Il est donc important de vérifier les modèles de machine learning utilisés, d'examiner des exemples de comportement des modèles et d'étudier les surprises.
Learning Interpretability Tool (LIT, site Web, GitHub) est une plate-forme de débogage et d'analyse de modèles de ML pour comprendre pourquoi et comment ils se comportent de cette manière.
Dans cet atelier de programmation, vous allez apprendre à utiliser LIT pour exploiter tout le potentiel du modèle Gemma de Google. Cet atelier de programmation explique comment utiliser la saillance de séquence, une technique d'interprétabilité, pour analyser différentes approches d'ingénierie des requêtes.
Objectifs de la formation :
- Comprendre la saillance de la séquence et ses utilisations dans l'analyse de modèles.
- Configurer le LIT pour Gemma afin de calculer les sorties des requêtes et la saillance des séquences
- Utiliser la saillance séquentielle dans le module Sallience LM pour comprendre l'impact de la conception de requêtes sur les résultats du modèle.
- Tester des suggestions d'amélioration des requêtes dans LIT et voir leur impact.
Remarque: Cet atelier de programmation utilise l'implémentation Keras NLP de Gemma, et TensorFlow v2 pour le backend. Nous vous recommandons vivement d'utiliser un noyau GPU.
2. Saillance séquence et ses utilisations dans l'analyse de modèles
Les modèles génératifs texte-vers-texte, tels que Gemma, prennent une séquence d'entrée sous la forme de texte tokenisé et génèrent de nouveaux jetons qui sont des suites ou des achèvements typiques de cette entrée. Cette génération se produit un jeton à la fois, en ajoutant (en boucle) chaque nouveau jeton généré à l'entrée et aux générations précédentes jusqu'à ce que le modèle atteigne une condition d'arrêt. par exemple lorsque le modèle génère un jeton de fin de séquence (EOS) ou atteint la longueur maximale prédéfinie.
Les méthodes de saillance sont une classe de techniques d'IA explicable (XAI) qui peuvent vous indiquer quelles parties d'une entrée sont importantes pour le modèle pour différentes parties de sa sortie. LIT est compatible avec les méthodes de saillance pour diverses tâches de classification, qui expliquent l'impact d'une séquence de jetons d'entrée sur l'étiquette prédite. La saillance de séquence généralise ces méthodes aux modèles génératifs texte-vers-texte et explique l'impact des jetons précédents sur les jetons générés.
Ici, vous allez utiliser la norme L2 de gradient pour la saillance de la séquence, qui analyse les gradients du modèle et fournit une magnitude de l'influence de chaque jeton précédent sur la sortie. Cette méthode simple et efficace a fait ses preuves en termes de classification et d'autres paramètres. Plus le score de saillance est élevé, plus l'influence est importante. Cette méthode est utilisée dans LIT, car elle est bien comprise et largement utilisée au sein de la communauté des chercheurs en interprétabilité.
Les méthodes de saillance basées sur les gradients plus avancées incluent Grad ⋅ Entrée et gradients intégrés. Il existe également des méthodes basées sur des ablations, telles que LIME et SHAP, qui peuvent être plus robustes, mais beaucoup plus coûteuses à calculer. Consultez cet article pour une comparaison détaillée des différentes méthodes de saillance.
Pour en savoir plus sur la science des méthodes de saillance, consultez cette présentation interactive et explorable jusqu'à la saillance.
3. Importations, environnement et autres codes de configuration
Il est préférable de suivre cet atelier de programmation dans la nouvelle version de Colab. Nous vous recommandons d'utiliser un environnement d'exécution d'accélérateur, puisque vous allez charger un modèle en mémoire. Sachez toutefois que les options de l'accélérateur varient au fil du temps et sont soumises à des restrictions. Colab propose des abonnements payants si vous souhaitez accéder à des accélérateurs plus puissants. Vous pouvez également utiliser un environnement d'exécution local si votre machine dispose d'un GPU approprié.
Remarque: Des avertissements du formulaire peuvent s'afficher.
ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts. bigframes 0.21.0 requires scikit-learn>=1.2.2, but you have scikit-learn 1.0.2 which is incompatible. google-colab 1.0.0 requires ipython==7.34.0, but you have ipython 8.14.0 which is incompatible.
Vous pouvez les ignorer.
Installer LIT et Keras NLP
Pour cet atelier de programmation, vous aurez besoin d'une version récente de keras (3) keras-nlp (0.8.0) et de lit-nlp (1.1) et d'un compte Kaggle pour télécharger le modèle de base.
!pip install -q -U lit-nlp
!pip uninstall -y umap-learn
!pip install -q -U keras-nlp
!pip install -q -U keras
Accès à Kaggle
Pour vous connecter à Kaggle, vous pouvez soit stocker votre fichier d'identifiants kaggle.json sur ~/.kaggle/kaggle.json, soit exécuter la commande suivante dans un environnement Colab. Pour en savoir plus, consultez la documentation du package kagglehub.
import kagglehub
kagglehub.login()
Veillez également à accepter le contrat de licence pour Gemma.
4. Configurer des modèles LIT
import os
os.environ["KERAS_BACKEND"] = "tensorflow"
import keras
import keras_nlp
# Run at half precision.
keras.config.set_floatx("bfloat16")
model_name = 'gemma_instruct_2b_en'
gemma_model = keras_nlp.models.GemmaCausalLM.from_preset(model_name)
Le code suivant initialise les wrappers LIT pour prendre en charge la saillance sur le modèle Gemma. Le framework LIT les désigne comme des modèles, mais dans ce cas, il ne s'agit que de points de terminaison différents pour le même gemma_model sous-jacent que vous avez chargé ci-dessus. LIT peut ainsi calculer les générations, la tokenisation et la saillance à la demande.
from lit_nlp.examples.models import instrumented_keras_lms
batch_size = 1
max_sequence_length = 512
init_models = instrumented_keras_lms.initialize_model_group_for_salience
models = init_models(model_name, gemma_model,
batch_size=batch_size,
max_length=max_sequence_length)
5. Configurer des ensembles de données LIT
Gemma est un modèle génératif de texte-vers-texte qui reçoit du texte en entrée et génère une sortie textuelle. Les modèles LIT supposent que les ensembles de données fourniront les champs suivants pour permettre la génération:
prompt: entrée d'unKerasGenerationModel.target: séquence cible facultative, telle qu'une "vérité terrain" (or) ou une réponse prégénérée à partir du modèle.
LIT comprend un petit ensemble de sample_prompts avec des exemples provenant de différentes sources, telles que:
- GSM8K: résoudre des problèmes de mathématiques en classe à l'aide d'exemples few-shot.
- Gigaword Benchmark: génération de titres pour un ensemble d'articles courts.
- Invite constitutionnelle: recherche de nouvelles idées sur la façon d'utiliser des objets avec des consignes ou des limites.
Vous pouvez également charger facilement vos propres données, soit sous la forme d'un fichier .jsonl contenant des enregistrements avec les champs prompt et éventuellement target (exemple), ou dans n'importe quel format à l'aide de l'API Dataset de LIT.
Exécutez la cellule ci-dessous pour charger les exemples de requêtes.
from lit_nlp.examples.datasets import lm as lm_data
datasets = {
'sample_prompts': lm_data.PromptExamples(
lm_data.PromptExamples.SAMPLE_DATA_PATH
),
}
6. Configurer l'UI LIT
LIT est un outil interactif de compréhension de modèles qui permet d'évaluer et de tester le comportement du modèle de façon humaine. L'interface utilisateur LIT facilite cette interaction en vous permettant de:
- visualiser vos ensembles de données et les résultats du modèle en direct,
- exécuter des méthodes de saillance pour comprendre les jetons d'entrée qui influencent le comportement du modèle ;
- créer des contrefactuels pour tester des hypothèses.
La fonctionnalité LIT permet d'effectuer toutes ces opérations dans la même interface, ce qui facilite le basculement entre les différents outils. Cela est particulièrement utile pour les tâches telles que l'ingénierie des requêtes, que nous étudierons plus tard dans cet atelier de programmation.
Cette mise en page d'UI peut être utilisée pour tout autre modèle de langage génératif. Si d'autres fonctionnalités que celles listées ici vous intéressent, cliquez ici pour consulter la liste complète.
from lit_nlp.api import layout
modules = layout.LitModuleName
LM_SALIENCE_LAYOUT = layout.LitCanonicalLayout(
left={
'Data Table': [modules.DataTableModule],
'Datapoint Editor': [modules.DatapointEditorModule],
},
upper={ # if 'lower' not specified, this fills the right side
'Salience': [modules.LMSalienceModule],
},
layoutSettings=layout.LayoutSettings(leftWidth=40),
description='Custom layout for language model salience.',
)
Ce code initialise le serveur LIT. Cette opération peut prendre quelques secondes, car le modèle est également exécuté sur les exemples de requêtes et le résultat est mis en cache.
from lit_nlp import notebook as lit_notebook
lit_widget = lit_notebook.LitWidget(
models=models,
datasets=datasets,
layouts={'default': LM_SALIENCE_LAYOUT},
default_layout='default',
)
Vous pouvez maintenant afficher l'interface utilisateur:
lit_widget.render(height=800)
Vous pouvez également ouvrir LIT en pleine page dans un nouvel onglet. Exécutez ce code et cliquez sur le lien qui s'affiche:
lit_widget.render(open_in_new_tab=True)
Remarque: Si vous utilisez LIT dans un script .py standard, utilisez lit_nlp.dev_server.Server() au lieu de LitWidget pour afficher un serveur autonome. Pour en savoir plus, consultez la documentation LIT.
7. Analyser peu de requêtes de tir pour Gemma dans LIT
Aujourd'hui, les requêtes relèvent autant de l'art que de la science, et LIT peut vous aider à améliorer de manière empirique les requêtes pour les grands modèles de langage, tels que Gemma. Vous verrez ensuite un exemple d'utilisation de LIT pour explorer les comportements de Gemma, anticiper les problèmes potentiels et améliorer sa sécurité.
Identifier les erreurs dans les requêtes complexes
Les requêtes few-shot (qui incluent des exemples du comportement souhaité dans la requête) et la chaîne de pensée (y compris une forme d'explication ou de raisonnement avant la sortie finale du LLM) sont deux des techniques de requête les plus importantes pour les prototypes et les applications basés sur des LLM de haute qualité. Mais créer une requête efficace reste souvent difficile.
Prenons l'exemple d'une personne qui peut aider quelqu'un à déterminer s'il aimera un plat en fonction de ses goûts. Un modèle initial de chaîne de pensée d'un prototype pourrait ressembler à ceci:
def analyze_menu_item_template(food_likes, food_dislikes, menu_item):
return f"""Analyze a menu item in a restaurant.
## For example:
Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.
Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.
Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.
## Now analyze one more example:
Taste-likes: {food_likes}
Taste-dislikes: {food_dislikes}
Suggestion: {menu_item}
Analysis:"""
Avez-vous repéré les problèmes avec cette invite ? LIT vous aidera à examiner la requête avec le module LM.
8. Utiliser la saillance de séquence pour le débogage
La saillance est calculée au niveau le plus petit possible (c'est-à-dire pour chaque jeton d'entrée), mais LIT peut agréger la saillance des jetons dans des étendues plus grandes, plus interprétables, telles que des lignes, des phrases ou des mots. Pour en savoir plus sur la saillance et son utilisation pour identifier les biais involontaires, consultez notre article Saliency Explorable (Salience explorable).
Commençons par donner à la requête un nouvel exemple d'entrée pour les variables du modèle de requête:
food_likes = """Cheese"""
food_dislikes = """Can't eat eggs"""
menu_item = """Quiche Lorraine"""
prompt = analyze_menu_item_template(food_likes, food_dislikes, menu_item)
print(prompt)
fewshot_mistake_example = {'prompt': prompt} # you'll use this below
Analyze a menu item in a restaurant. ## For example: Taste-likes: I've a sweet-tooth Taste-dislikes: Don't like onions or garlic Suggestion: Onion soup Analysis: it has cooked onions in it, which you don't like. Recommendation: You have to try it. Taste-likes: I've a sweet-tooth Taste-dislikes: Don't like onions or garlic Suggestion: Baguette maison au levain Analysis: Home-made leaven bread in france is usually great Recommendation: Likely good. Taste-likes: I've a sweet-tooth Taste-dislikes: Don't like onions or garlic Suggestion: Macaron in france Analysis: Sweet with many kinds of flavours Recommendation: You have to try it. ## Now analyze one more example: Taste-likes: Cheese Taste-dislikes: Can't eat eggs Suggestion: Quiche Lorraine Analysis:
Si l'interface utilisateur de LIT est ouverte dans la cellule au-dessus ou dans un onglet distinct, vous pouvez utiliser l'éditeur de points de données de LIT pour ajouter la requête suivante:
Vous pouvez également afficher à nouveau le widget directement avec la requête qui vous intéresse:
lit_widget.render(data=[fewshot_mistake_example])
Notez l'achèvement surprenant du modèle:
Taste-likes: Cheese Taste-dislikes: Can't eat eggs Suggestion: Quiche Lorraine Analysis: A savoury tart with cheese and eggs Recommendation: You might not like it, but it's worth trying.
Pourquoi le modèle vous suggère-t-il de manger quelque chose que vous avez clairement dit que vous ne pouvez pas manger ?
La saillance de la séquence peut aider à mettre en évidence le problème racine, qui est illustré dans nos exemples few-shot. Dans le premier exemple, le raisonnement en chaîne de pensée de la section d'analyse it has cooked onions in it, which you don't like ne correspond pas à la recommandation finale You have to try it.
Dans le module Salience LM, sélectionnez "Phrases" puis sélectionnez la ligne de recommandation. L'interface utilisateur doit maintenant se présenter comme suit:
Cela met en évidence une erreur humaine: un copier-coller accidentel de la partie "recommandation" et l'échec de sa mise à jour.
À présent, corrigeons la "recommandation" dans le premier exemple à Avoid, puis réessayez. Cet exemple est préchargé dans LIT dans les exemples de requêtes. Vous pouvez donc utiliser cette petite fonction utilitaire pour le récupérer:
def get_fewshot_example(source: str) -> str:
for example in datasets['sample_prompts'].examples:
if example['source'] == source:
return example['prompt']
raise ValueError(f'Source "{source}" not found in the dataset.')
lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-fixed')}])
La complétion du modèle se présente comme suit:
Taste-likes: Cheese Taste-dislikes: Can't eat eggs Suggestion: Quiche Lorraine Analysis: This dish contains eggs and cheese, which you don't like. Recommendation: Avoid.
Une leçon importante à retenir de cela est: le prototypage précoce permet de révéler des risques auxquels vous n'auriez pas pensé à l'avance, et la nature sujette aux erreurs des modèles de langage signifie que l'on doit concevoir de manière proactive pour les erreurs. Pour en savoir plus à ce sujet, consultez notre guide People + AI sur la conception avec l'IA.
Bien que la requête "quelques coups" corrigée soit meilleure, ce n'est pas tout à fait correct: elle indique bien à l'utilisateur d'éviter les œufs, mais le raisonnement n'est pas correct, elle indique qu'il n'aime pas les œufs, alors qu'en fait l'utilisateur a déclaré qu'il ne peut pas les manger. Dans la section suivante, vous allez découvrir comment améliorer vos performances.
9. Tester des hypothèses pour améliorer le comportement du modèle
LIT vous permet de tester les modifications apportées aux requêtes dans la même interface. Dans cet exemple, vous allez tester l'ajout d'une constitution pour améliorer le comportement du modèle. Les constitutions font référence aux requêtes de conception avec des principes qui guident la génération du modèle. Les méthodes récentes permettent même de dériver de manière interactive des principes constitutionnels.
Utilisons cette idée pour améliorer davantage la requête. Ajoutez une section avec les principes de génération en haut de notre requête, qui commence maintenant comme suit:
Analyze a menu item in a restaurant. * The analysis should be brief and to the point. * The analysis and recommendation should both be clear about the suitability for someone with a specified dietary restriction. ## For example: Taste-likes: I've a sweet-tooth Taste-dislikes: Don't like onions or garlic Suggestion: Onion soup Analysis: it has cooked onions in it, which you don't like. Recommendation: Avoid. ...
lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-constitution')}])
Avec cette mise à jour, l'exemple peut être réexécuté et observer un résultat très différent:
Taste-likes: Cheese Taste-dislikes: Can't eat eggs Suggestion: Quiche Lorraine Analysis: This dish contains eggs, which you can't eat. Recommendation: Not suitable for you.
La saillance de l'invite peut ensuite être réexaminée pour mieux comprendre pourquoi ce changement se produit:
Notez que la recommandation est beaucoup plus sûre. De plus, la catégorie "Non adaptée à vos besoins" est influencé par le principe qui consiste à indiquer clairement l'adéquation en fonction de la restriction alimentaire, ainsi que par l'analyse (ce qu'on appelle la chaîne de pensée). Vous gagnez ainsi en confiance quant au fait que la sortie se produit pour la bonne raison.
10. Inclure les équipes non techniques dans la vérification et l'exploration du modèle
L'interprétabilité doit être un travail d'équipe couvrant l'expertise de l'IA, des règles, du droit, etc.
Traditionnellement, l'interaction avec les modèles aux premières étapes de leur développement nécessitait une grande expertise technique, ce qui rendait plus difficile pour certains collaborateurs d'y accéder et de les vérifier. Jusqu'à présent, les outils n'existaient pas pour permettre à ces équipes de participer aux premières phases de prototypage.
Grâce à LIT, nous espérons que ce paradigme peut changer. Comme vous l'avez vu dans cet atelier de programmation, le support visuel et la capacité interactive de LIT à examiner la saillance et à explorer des exemples peuvent aider différentes personnes concernées à partager et à communiquer leurs conclusions. Vous pouvez ainsi réunir une plus grande diversité de collègues pour l'exploration, l'analyse et le débogage du modèle. En les exposant à ces méthodes techniques, vous les aiderez à mieux comprendre le fonctionnement des modèles. En outre, un ensemble plus varié d’expertise dans les premiers tests de modèles peut également aider à découvrir des résultats indésirables qui peuvent être améliorés.
11. Récapitulatif
En résumé :
- L'UI LIT fournit une interface pour l'exécution interactive du modèle, qui permet aux utilisateurs de générer directement des sorties et de tester les solutions différents scénarios. Cela est particulièrement utile pour tester différentes variantes de requête.
- Le module Salience LM fournit une représentation visuelle de la saillance et permet de contrôler la précision des données pour vous permettre de communiquer sur des constructions centrées sur l'humain (des phrases et des mots, par exemple) plutôt que sur des constructions centrées sur un modèle (comme les jetons).
Lorsque vous trouvez des exemples problématiques dans vos évaluations de modèles, importez-les dans LIT pour le débogage. Commencez par analyser la plus grande unité de contenu sensible que vous pouvez considérer et liée de manière logique à la tâche de modélisation. Utilisez les visualisations pour voir si le modèle suit correctement ou de manière incorrecte le contenu de la requête, puis affichez le détail en unités de contenu plus petites pour décrire plus en détail le comportement incorrect que vous observez afin d'identifier les correctifs possibles.
Enfin, Lit s'améliore constamment. Pour en savoir plus sur nos fonctionnalités et partager vos suggestions, cliquez ici.