mauve

MAUVE

Il s'agit d'une bibliothèque construite sur les transformateurs Pytorch et HuggingFace pour mesurer l'écart entre le texte neuronal et le texte humain avec la mesure mauve, introduite dans ce papier Neirips 2021 (Award de papier exceptionnel) et ce document JMLR 2023.

Mauve est une mesure de l'écart entre le texte neuronal et le texte humain. Il est calculé en utilisant les divergences de Kullback - Lebler (KL) entre les deux distributions de texte dans un espace d'intégration quantifié d'un modèle grand langage. Mauve peut identifier les différences de qualité résultant de la taille des modèles et des algorithmes de décodage.

Lien de documentation

Nouveau: Mauve est disponible via HuggingFace Evaluer!

Caractéristiques :

• Mauve avec quantification à l'aide de k -mians.
• Sélection adaptative des hyperparamètres K -means.
• Calculez MAUVE en utilisant des fonctionnalités GPT-2 pré-calculées (c.-à-d. L'état caché terminal), ou en train de présenter du texte brut à l'aide de Transformers HuggingFace + Pytorch.
• Mauve peut également être utilisé pour d'autres modalités (par exemple des images ou audio): passer dans des incorporations pré-calculées à notre API.

De plus amples détails peuvent être trouvés ci-dessous.

Pour que les scripts reproduisent les expériences dans le papier, veuillez consulter ce référentiel.

Installation

Pour une installation directe, exécutez cette commande à partir de votre terminal:

 pip install mauve-text

Si vous souhaitez modifier ou contribuer à Mauve, vous devez installer à partir de Source

 git clone [email protected]:krishnap25/mauve.git
cd mauve
pip install -e .

Certaines fonctionnalités nécessitent plus de packages. Veuillez consulter les exigences ci-dessous.

Exigences

La commande d'installation ci-dessus installe les principales exigences, qui sont:

• numpy>=1.18.1
• scikit-learn>=0.22.1
• faiss-cpu>=1.7.0
• tqdm>=4.40.0

De plus, si vous souhaitez utiliser la feturisation dans Mauve, vous devez installer manuellement:

• torch>=1.1.0 : instructions
• transformers>=3.2.0 : Exécutez simplement pip install transformers après l'installation de Pytorch (instructions détaillées)

Démarrage rapide

Soit p_text et q_text chacun une liste de chaînes, où chaque chaîne est une génération complète (y compris le contexte). Pour les meilleures pratiques, Mauve a besoin d'au moins quelques milliers de générations chacune pour p_text et q_text (le papier utilise 5000 chacun). Pour notre démo, nous utilisons 100 générations chacun pour une durée rapide.

Pour démontrer les fonctionnalités de ce package sur certaines données réelles, ce référentiel fournit des fonctionnalités pour télécharger et utiliser des exemples de données dans le dossier ./examples (ce ne font pas partie du package Mauve, vous devez cloner le référentiel pour ceux-ci).

Laissez-vous télécharger certaines critiques de produits Amazon ainsi que les générations de machines, fournies par le dépôt de jeu de données de sortie GPT-2 en exécutant cette commande dans notre shell (téléchargement ~ 17 m de taille):

python examples/download_gpt2_dataset.py

Les données sont téléchargées dans le dossier ./data . Nous pouvons charger les données (100 échantillons sur les 5000 disponibles) en python comme

 from examples import load_gpt2_dataset
p_text = load_gpt2_dataset ( 'data/amazon.valid.jsonl' , num_examples = 100 ) # human
q_text = load_gpt2_dataset ( 'data/amazon-xl-1542M.valid.jsonl' , num_examples = 100 ) # machine

Nous pouvons désormais calculer MAUVE comme suit (notez que cela nécessite l'installation de transformateurs Pytorch et HF).

 import mauve 

# call mauve.compute_mauve using raw text on GPU 0; each generation is truncated to 256 tokens
out = mauve . compute_mauve ( p_text = p_text , q_text = q_text , device_id = 0 , max_text_length = 256 , verbose = False )
print ( out . mauve ) # prints 0.9917

Cela télécharge d'abord GPT-2 grand tokenizer et modèle pré-formé (si vous ne les avez pas déjà téléchargés). Même si vous avez le modèle hors ligne, il faut jusqu'à 30 secondes pour charger le modèle la première fois. out maintenant contient les champs:

• out.mauve : score mauve, un nombre entre 0 et 1. Des valeurs plus grandes indiquent que P et Q sont plus proches.
• out.frontier_integral : Frontier Integral, un nombre entre 0 et 1. Des valeurs plus petites indiquent que P et Q sont plus proches.
• out.mauve_star et out.frontier_integral_star : leurs versions correspondantes calculées avec le lissage Krichevsky-Trofimov. Voir ce document JMLR 2023 sur les raisons pour lesquelles cela pourrait être préférable.
• out.divergence_curve : un numpy.ndarray de forme (m, 2); Tracez-le avec Matplotlib pour afficher la courbe de divergence
• out.p_hist : une distribution discrète, qui est une version quantifiée de la distribution de texte p_text
• out.q_hist : Identique à ci-dessus, mais avec q_text

Vous pouvez tracer la courbe de divergence en utilisant

 # Make sure matplotlib is installed in your environment
import matplotlib . pyplot as plt  
plt . plot ( out . divergence_curve [:, 1 ], out . divergence_curve [:, 0 ])

D'autres façons d'utiliser Mauve

Pour chaque texte (dans p_text et q_text ), Mauve utilise en interne l'état caché térimal de GPT-2 grand comme représentation de fonctionnalité. Bien sûr, des LLM plus récents peuvent également être utilisées. Généralement, meilleur est les intérêts des fonctionnalités, mieux les performances de Mauve sont meilleures.

Il existe plusieurs façons d'utiliser ce package. Par exemple, vous pouvez utiliser directement les états cachés cachés (cela ne nécessite pas d'installation de transformateurs Pytorch et HF):

 # call mauve.compute_mauve using features obtained directly
# p_feats and q_feats are `np.ndarray`s of shape (n, dim)
# we use a synthetic example here
import numpy as np
p_feats = np . random . randn ( 100 , 1024 )  # feature dimension = 1024
q_feats = np . random . randn ( 100 , 1024 )
out = mauve . compute_mauve ( p_features = p_feats , q_features = q_feats )

Notez que cette API peut être utilisée pour évaluer d'autres modalités telles que les images ou l'audio avec Mauve.

Vous pouvez également calculer MAUVE en utilisant la représentation tokenisée (BPE) en utilisant le vocabulaire GPT-2 (par exemple, obtenu en utilisant un appel explicite à transformers.GPT2Tokenizer ).

 # call mauve.compute_mauve using tokens on GPU 1
# p_toks, q_toks are each a list of LongTensors of shape [1, length]
# we use synthetic examples here
import torch
p_toks = [ torch . LongTensor ( np . random . choice ( 50257 , size = ( 1 , 32 ), replace = True )) for _ in range ( 100 )]
q_toks = [ torch . LongTensor ( np . random . choice ( 50257 , size = ( 1 , 32 ), replace = True )) for _ in range ( 100 )]
out = mauve . compute_mauve ( p_tokens = p_toks , q_tokens = q_toks , device_id = 1 , max_text_length = 1024 )

Pour afficher les messages de progression, passez dans l'argument verbose=True à mauve.compute_mauve . Vous pouvez également utiliser différentes formes comme entrées pour p et q , par exemple, p via p_text et q via q_features .

Options disponibles

mauve.compute_mauve prend les arguments suivants

• p_features : numpy.ndarray de forme (n, d), où n est le nombre de générations
• q_features : numpy.ndarray de forme (n, d), où n est le nombre de générations
• p_tokens : liste de la longueur n, chaque entrée est torch.longtensor de forme (1, longueur); la longueur peut varier entre les générations
• q_tokens : Liste de la longueur n, chaque entrée est TORCH.LongtenSor de forme (1, longueur); la longueur peut varier entre les générations
• p_text : liste de la longueur n, chaque entrée est une chaîne
• q_text : liste de longueur n, chaque entrée est une chaîne
• num_buckets : La taille de l'histogramme pour quantifier P et Q. Options: «Auto» (par défaut) ou un entier
• pca_max_data : Le nombre de données pointe à utiliser pour la réduction de la dimensionnalité PCA avant le clustering. Si -1 , utilisez toutes les données. Par défaut -1
• kmeans_explained_var : quantité de variance des données à conserver dans la réduction de la dimensionnalité par PCA. Par défaut 0.9
• kmeans_num_redo : nombre de fois pour refaire le clustering k-means (le meilleur objectif est conservé). Par défaut 5
• kmeans_max_iter : nombre maximum d'itérations K-means. Par défaut 500
• featurize_model_name : Nom du modèle à partir de laquelle les fonctionnalités sont obtenues. Par défaut 'gpt2-large' Utilisez l'un des ['gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'] .
• device_id : périphérique pour la feturation. Fournir un ID GPU (par exemple 0 ou 3) pour utiliser le GPU. Si aucun GPU avec cet ID n'est trouvé, utilisez le processeur
• max_text_length : nombre maximum de jetons à considérer. Par défaut 1024
• divergence_curve_discretization_size : nombre de points à considérer sur la courbe de divergence. Par défaut 25
• mauve_scaling_factor : "C" du papier. Par défaut 5.
• verbose : si vrai (par défaut), imprimez les mises à jour de temps d'exécution
• seed : graines aléatoires pour initialiser les affectations de grappes K -means.
• batch_size : Taille du lot pour l'extraction des fonctionnalités.

Remarque: p et q peuvent être de longueurs différentes, mais il est recommandé qu'ils soient de la même longueur.

Contact

La meilleure façon de contacter les auteurs en cas de questions ou de clarifications (sur le package ou le document) est de soulever un problème sur GitHub. Nous ne sommes pas en mesure de répondre aux requêtes par e-mail.

Contributif

Si vous trouvez des bogues, veuillez soulever un problème sur GitHub. Si vous souhaitez contribuer, veuillez soumettre une demande de traction. Nous encourageons et apprécions fortement les contributions communautaires.

Certaines fonctionnalités qui seraient bonnes à avoir sont:

• Feature dans les transformateurs en étreintes avec un backend Jax.

Meilleures pratiques pour Mauve

Mauve est très différent de la plupart des mesures à usage courant, alors voici quelques directives sur une utilisation appropriée de Mauve:

1. Comparaisons relatives :

   • Nous constatons que Mauve est le mieux adapté aux comparaisons relatives tandis que le score Mauve absolu est moins significatif.
   • Par exemple, si nous souhaitons trouver lesquels des model1 et model2 sont meilleurs pour générer la distribution humaine, nous pouvons comparer MAUVE(text_model1, text_human) et MAUVE(text_model2, text_human) .
   • Le nombre absolu MAUVE(text_model1, text_human) peut varier en fonction des hyperparamètres sélectionnés ci-dessous, mais les tendances relatives restent les mêmes.
   • Il faut s'assurer que les hyperparamètres sont exactement les mêmes pour les scores MAUVE en comparaison.
   • Certains hyperparamètres sont décrits ci-dessous.

2. Nombre de générations :

   • Mauve calcule la similitude entre deux distributions .
   • Par conséquent, chaque distribution doit contenir au moins quelques milliers d'échantillons (nous utilisons 5000 chacun). Mauve avec un plus petit nombre d'échantillons est biaisé vers l'optimisme (c'est-à-dire que Mauve baisse généralement à mesure que le nombre d'échantillons augmente) et présente un écart-type plus important entre les cycles.

3. Nombre de clusters (taille de discrétisation) :

   • Nous prenons num_buckets à 0,1 * le nombre d'échantillons.
   • Les performances de Mauve sont assez robustes à cela, à condition que le nombre de générations ne soit pas trop faible.

4. Mauve est trop grand ou trop petit :

   • Le paramètre mauve_scaling_parameter contrôle la valeur absolue du score MAUVE, sans modifier l'ordre relatif entre les différentes méthodes. Le but principal de ce paramètre est d'aider à l'interprétabilité.
   • Si vous constatez que toutes vos méthodes obtiennent un score MAUVE très élevé (par exemple, 0,995, 0,994), essayez d'augmenter la valeur de mauve_scaling_factor . (Remarque: Cela augmente également l'écart type par course de Mauve).
   • Si vous constatez que toutes vos méthodes obtiennent un score MAUVE très faible (par exemple <0,4), essayez de diminuer la valeur de mauve_scaling_factor .

5. Mauve prend trop de temps pour courir :

   • Vous pouvez également essayer de réduire le nombre de clusters à l'aide de l'argument num_buckets . L'algorithme de clustering l'échelle d'exécution est le carré du nombre de clusters. Une fois que le nombre de clusters dépasse 500, le clustering commence vraiment à ralentir. Dans ce cas, il pourrait être utile de définir le nombre de clusters sur 500 en remplaçant la valeur par défaut (qui est num_data_points / 10 , alors utilisez-le lorsque le nombre d'échantillons pour chacun de P et Q est supérieur à 5000).
   • Dans ce cas, essayez de réduire les hyperparamètres de clustering: définissez kmeans_num_redo à 1 , et si cela ne fonctionne pas, kmeans_max_iter à 100 . Cela permet au clustering de s'exécuter plus rapidement au prix du retour d'un clustering pire.

6. La variance de Mauve est importante par rapport aux différences que nous essayons de quantifier :

   • Nous avons observé qu'il est assez facile de capturer des erreurs de base avec MAUVE mais beaucoup plus difficiles à quantifier les erreurs subtiles (par exemple, lorsque vous essayez de s'améliorer sur l'échantillonnage du noyau).
   • Pour mesurer les différences subtiles avec confiance, la meilleure solution consiste à utiliser de meilleures intégres, si vous y avez accès.
   • Vous pouvez également envisager des courses plus aléatoires pour réduire la variance: plus de nombre de graines de k-means (moins chers en termes de calcul), plus de nombre de graines de génération (pour les algorithmes basés sur l'échantillonnage) ou un plus grand nombre d'échantillons de texte.

Citation

Si vous trouvez ce package utile ou si vous l'utilisez dans vos recherches, veuillez citer les articles suivants:

 @article{pillutla-etal:mauve:jmlr2023,
  title={{MAUVE Scores for Generative Models: Theory and Practice}},
  author={Pillutla, Krishna and Liu, Lang and Thickstun, John and Welleck, Sean and Swayamdipta, Swabha and Zellers, Rowan and Oh, Sewoong and Choi, Yejin and Harchaoui, Zaid},
  journal={JMLR},
  year={2023}
}

@inproceedings{pillutla-etal:mauve:neurips2021,
  title={MAUVE: Measuring the Gap Between Neural Text and Human Text using Divergence Frontiers},
  author={Pillutla, Krishna and Swayamdipta, Swabha and Zellers, Rowan and Thickstun, John and Welleck, Sean and Choi, Yejin and Harchaoui, Zaid},
  booktitle = {NeurIPS},
  year      = {2021}
}

@inproceedings{liu-etal:mauve-theory:neurips2021,
  title={{Divergence Frontiers for Generative Models: Sample Complexity, Quantization Effects, and Frontier Integrals}},
  author={Liu, Lang and Pillutla, Krishna and Welleck, Sean and Oh, Sewoong and Choi, Yejin and Harchaoui, Zaid},
  booktitle={NeurIPS},
  year={2021}
}

Remerciements

Ce travail a été soutenu par NSF DMS-2134012, NSF CCF-2019844, NSF DMS-2023166, le programme DARPA MCS via NIWC Pacific (N66001-19-2-4031), le programme CIFAR "Learning in Machines & Brains", un programme de recherche sur l'innovation Qualcomm, et des recherches facultés.