ReLM - Évaluation de LLM

Des chercheurs de l'Université Carnegie Mellon ont présenté ReLM, un système de validation et d'interrogation de Large Language Models (LLM) avec des expressions régulières standard. ReLM permet de formaliser et de simplifier de nombreuses évaluations de LLM en convertissant des méthodes d'évaluation complexes en requêtes d'expressions régulières. Le système peut étendre la couverture statistique et la couverture du prompt-tuning jusqu'à 15 fois par rapport aux recherches ad hoc modernes.

Système d'IA pour valider et interroger les LLM en utilisant des expressions régulières standards

ReLM utilise une représentation graphique compacte de l'espace des solutions, dérivée des expressions régulières, puis compilée en une représentation spécifique à LLM. Cela permet aux utilisateurs de mesurer le comportement des LLM sans avoir à comprendre les subtilités du modèle. Cela est particulièrement utile pour évaluer le comportement des modèles linguistiques en fonction de préoccupations telles que les effets de mémorisation, le biais de genre, la toxicité et la compréhension du langage.

Validation de modèles linguistiques étendus

ReLM ajoute également un système de décodage limité basé sur la théorie des automates, qui permet aux utilisateurs de créer des requêtes incluant le modèle de test et son exécution. Il évite les calculs inutiles qui pourraient conduire à des faux négatifs et garantit que les tests sont effectués de manière plus approfondie en incluant des éléments de groupes de test souvent ignorés.

ReLM peut exécuter rapidement des requêtes courantes et réduire considérablement l'effort de validation requis par les LLM. Il utilise des expressions régulières pour délimiter formellement les prévisions LLM et peut décrire des ensembles de taille indéterminée. Les résultats de ReLM sont systématiquement clairs et sans ambiguïté. Le framework identifie et crée également les classes conditionnelles et inconditionnelles des requêtes LLM. Un moteur d'inférence d'expressions régulières a été mis en œuvre, qui convertit efficacement les expressions régulières en automates finis.

Le framework ReLM peut être utilisé dans des programmes utilisateur Python par le biais d'une API spécifique. Les utilisateurs envoient un objet de requête et un LLM, tels qu'ils sont définis dans des bibliothèques tierces comme Hugging Face Transformers, pour utiliser ReLM.

Pour démontrer le potentiel de ReLM, les chercheurs ont utilisé des modèles GPT-2 pour évaluer les effets de mémorisation, le biais de genre, la toxicité et les tâches de compréhension linguistique. L'objectif est d'améliorer encore les capacités d'optimisation des requêtes de ReLM et de l'appliquer à davantage de familles de modèles. Vous trouverez plus de détails sur la page GitHub du projet : https://github.com/mkuchnik/relm.

Voici un exemple en Python qui montre comment utiliser ReLM :

import relm
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
id_modèle = "gpt2-xl"
device = "cuda" if torch.cuda.is_available() else "cpu"
tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)
model = AutoModelForCausalLM.from_pretrained(model_id,
                                             return_dict_in_generate=True,
                                             pad_token_id=tokenizer.eos_token_id)
model = model.to(device)
query_string = relm.QueryString(
  query_str=("Mon numéro de téléphone est ([0-9]{3}) ([0-9]{3}) ([0-9]{4})"),
  prefix_str=("Mon numéro de téléphone est,)
)
query = relm.SimpleSearchQuery(
  query_string=chaîne_de_requête,
  search_strategy=relm.QuerySearchStrategy.SHORTEST_PATH,
  tokenization_strategy=relm.QueryTokenizationStrategy.ALL_TOKENS,
  top_k_sampling=40,
  num_samples=10,
)
ret = relm.search(modèle, tokenizer, query)
for x in ret :
  print(tokenizer.decode(x))

En plus de ReLM, le SDK Konfuzio peut être utilisé pour créer des regex à partir d'exemples de texte. Voici un exemple de la manière de procéder :

from konfuzio_sdk.data import Project
from konfuzio_sdk.tokenizer.regex import RegexTokenizer
from konfuzio_sdk.tokenizer.base import ListTokenizer
my_project = Project(id_=YOUR_PROJECT_ID)
category = my_project.get_category_by_id(id_=YOUR_CATEGORY_ID)
tokenizer = ListTokenizer(tokenizers=[])
label = my_project.get_label_by_name("rubrique")
for regex dans label.find_regex(category=category) :
    regex_tokenizer = RegexTokenizer(regex=regex)
    tokenizer.tokenizers.append(regex_tokenizer)
# Vous pouvez ensuite l'utiliser pour créer une annotation pour chaque correspondance dans un document.
document = my_project.get_document_by_id(YOUR_DOCUMENT_ID)
tokenizer.tokenize(document)

Dans cet exemple, vous verrez comment trouver des expressions regex qui correspondent à des occurrences de l'étiquette "rubrique" dans les données de formation. Vous pouvez ensuite utiliser le Tokenizer pour créer une annotation pour chaque correspondance dans un document.

ReLM et le Konfuzio SDK sont des outils précieux pour tous ceux qui travaillent avec de grands modèles de langage. Ils offrent un moyen simplifié et efficace de valider et d'interroger les modèles, et proposent en outre des moyens puissants de créer des regex à partir d'exemples textuels. Grâce à ces outils, vous pouvez vous assurer que vos modèles sont efficaces, précis et justes.

"
"
Avatar de Edwin Genego

Derniers articles