mauve

Mauve

Esta é uma biblioteca construída nos transformadores de Pytorch e Huggingface para medir a lacuna entre o texto neural e o texto humano com a medida Mauve, introduzida neste artigo Neurips 2021 (prêmio de papel excelente) e este artigo JMLR 2023.

Mauve é uma medida da lacuna entre o texto neural e o texto humano. Ele é calculado usando as divergências Kullback -Leibler (KL) entre as duas distribuições de texto em um espaço de incorporação quantizado de um grande modelo de linguagem. Mauve pode identificar diferenças na qualidade decorrentes dos tamanhos dos modelos e dos algoritmos de decodificação.

Link de documentação

Novo: Mauve está disponível via Huggingface Avalie!

Características :

• Mauve com quantização usando k -means.
• Seleção adaptativa de hiperparâmetros de K -Means.
• Calcule o Mauve usando os recursos GPT-2 pré-computados (ou seja, estado oculto do terminal) ou o texto bruto do Huggingface Transformers + Pytorch.
• O Mauve também pode ser usado para outras modalidades (por exemplo, imagens ou áudio): passe em incorporação de recurso pré-computada à nossa API.

Mais detalhes podem ser encontrados abaixo.

Para os scripts reproduzirem os experimentos no artigo, consulte este repositório.

Instalação

Para uma instalação direta, execute este comando do seu terminal:

 pip install mauve-text

Se você deseja editar ou contribuir para o Mauve, deve instalar a partir da fonte

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

Alguma funcionalidade requer mais pacotes. Por favor, veja os requisitos abaixo.

Requisitos

O comando de instalação acima instala os principais requisitos, que são:

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

Além disso, se você deseja usar a apresentação em Mauve, precisa instalar manualmente:

• torch>=1.1.0 : Instruções
• transformers>=3.2.0 : Simplesmente execute pip install transformers após a instalação do Pytorch (instruções detalhadas)

Início rápido

Seja p_text e q_text uma lista de strings, onde cada string é uma geração completa (incluindo contexto). Para as práticas recomendadas, o Mauve precisa de pelo menos alguns milhares de gerações cada para p_text e q_text (o artigo usa 5000 cada). Para nossa demonstração, usamos 100 gerações cada para o tempo de execução rápido.

Para demonstrar as funcionalidades deste pacote em alguns dados reais, este repositório fornece algumas funcionalidades para baixar e usar dados de amostra na pasta ./examples (estes não fazem parte do pacote Mauve, você precisa clonar o repositório para eles).

Vamos usar download algumas análises de produtos da Amazon, bem como gerações de máquinas, fornecidas pelo repo do conjunto de dados de saída GPT-2, executando este comando em nosso shell (downloads ~ 17m de tamanho):

python examples/download_gpt2_dataset.py

Os dados são baixados na pasta ./data . Podemos carregar os dados (100 amostras do 5000 disponíveis) em Python como

 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

Agora podemos calcular o Mauve da seguinte forma (observe que isso requer a instalação dos transformadores Pytorch e 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

Este primeiro baixa o GPT-2 Large Tokenizer e o modelo pré-treinado (se você ainda não os tiver baixado). Mesmo se você tiver o modelo offline, leva até 30 segundos para carregar o modelo pela primeira vez. out agora contém os campos:

• out.mauve : Pontuação Mauve, um número entre 0 e 1. Valores maiores indicam que P e Q estão mais próximos.
• out.frontier_integral : Frontier Integral, um número entre 0 e 1. Valores menores indicam que P e Q estão mais próximos.
• out.mauve_star e out.frontier_integral_star : suas versões correspondentes calculadas com a suavização de Krichevsky-Trofimov. Veja este artigo JMLR 2023 sobre por que isso pode ser preferível.
• out.divergence_curve : um numpy.ndarray de forma (m, 2); Plote -o com matplotlib para ver a curva de divergência
• out.p_hist : uma distribuição discreta, que é uma versão quantizada da distribuição de texto p_text
• out.q_hist : o mesmo que acima, mas com q_text

Você pode plotar a curva de divergência usando

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

Outras maneiras de usar Mauve

Para cada texto (em p_text e q_text ), o Mauve usa internamente o estado oculto terimal do GPT-2 grande como uma representação de recursos. Obviamente, LLMs mais recentes também podem ser usados. Geralmente, quanto melhor o recurso incorporação, melhor é o desempenho de Mauve.

Existem várias maneiras de usar este pacote. Por exemplo, você pode usar diretamente os estados ocultos em cache (isso não requer que os transformadores de Pytorch e HF sejam instalados):

 # 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 )

Observe que esta API pode ser usada para avaliar outras modalidades, como imagens ou áudio com o Mauve.

Você também pode calcular o Mauve usando a representação tokenizada (BPE) usando o vocabulário GPT-2 (por exemplo, obtido do uso de uma chamada explícita para 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 )

Para visualizar as mensagens de progresso, passe no argumento verbose=True para mauve.compute_mauve . Você também pode usar formas diferentes como entradas para p e q , por exemplo, p via p_text e q via q_features .

Opções disponíveis

mauve.compute_mauve leva os seguintes argumentos

• p_features : numpy.ndarray of Shape (n, d), onde n é o número de gerações
• q_features : numpy.ndarray of Shape (n, d), onde n é o número de gerações
• p_tokens : Lista de comprimento n, cada entrada é tocha.Longtensor of Shape (1, comprimento); o comprimento pode variar entre gerações
• q_tokens : Lista de comprimento n, cada entrada é tocha. o comprimento pode variar entre gerações
• p_text : lista de comprimento n, cada entrada é uma string
• q_text : Lista de comprimento n, cada entrada é uma string
• num_buckets : o tamanho do histograma para quantizar as opções P e Q.: 'Auto' (padrão) ou um número inteiro
• pca_max_data : os pontos de dados numéricos a serem usados ​​para redução da dimensionalidade do PCA antes do cluster. Se -1 , use todos os dados. Padrão -1
• kmeans_explained_var : quantidade de variação dos dados a se manter na redução da dimensionalidade pelo PCA. Padrão 0,9
• kmeans_num_redo : Número de vezes para refazer o cluster K-Means (o melhor objetivo é mantido). Padrão 5
• kmeans_max_iter : número máximo de iterações K-means. Padrão 500
• featurize_model_name : nome do modelo a partir do qual os recursos são obtidos. O padrão 'gpt2-large' usa um dos ['gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'] .
• device_id : dispositivo para featurização. Forneça um ID da GPU (por exemplo, 0 ou 3) para usar a GPU. Se nenhuma GPU com este ID for encontrada, use a CPU
• max_text_length : número máximo de tokens a serem considerados. Padrão 1024
• divergence_curve_discretization_size : Número de pontos a serem considerados na curva de divergência. Padrão 25
• mauve_scaling_factor : "c" do papel. Padrão 5.
• verbose : se true (padrão), imprimir atualizações de tempo de execução
• seed : semente aleatória para inicializar as atribuições de cluster de k -means.
• batch_size : Tamanho do lote para extração de recursos.

Nota: p e q podem ter comprimentos diferentes, mas é recomendável que eles tenham o mesmo comprimento.

Contato

A melhor maneira de entrar em contato com os autores em caso de perguntas ou esclarecimentos (sobre o pacote ou o artigo) é levantar um problema no Github. Não somos capazes de responder a consultas por e -mail.

Contribuindo

Se você encontrar algum bug, por favor, levante um problema no Github. Se você deseja contribuir, envie uma solicitação de tração. Incentivamos e valorizamos muito as contribuições da comunidade.

Alguns recursos que seriam bons de ter são:

• Featurização em Transformers Huggingface com um back -end JAX.

Melhores práticas para Mauve

Mauve é bem diferente da maioria das métricas de uso comum, então aqui estão algumas diretrizes sobre o uso adequado de Mauve:

1. Comparações relativas :

   • Descobrimos que Mauve é mais adequado para comparações relativas, enquanto a pontuação absoluta de Mauve é menos significativa.
   • Por exemplo, se desejarmos encontrar qual model1 e model2 são melhores na geração da distribuição humana, podemos comparar MAUVE(text_model1, text_human) e MAUVE(text_model2, text_human) .
   • O número absoluto MAUVE(text_model1, text_human) pode variar com base nos hiperparâmetros selecionados abaixo, mas as tendências relativas permanecem as mesmas.
   • É preciso garantir que os hiperparâmetros sejam exatamente os mesmos para as pontuações de Mauve em comparação.
   • Alguns hiperparâmetros são descritos abaixo.

2. Número de gerações :

   • Mauve calcula a semelhança entre duas distribuições .
   • Portanto, cada distribuição deve conter pelo menos alguns milhares de amostras (usamos 5000 cada). O Mauve com um número menor de amostras é tendencioso em relação ao otimismo (ou seja, o Mauve normalmente diminui à medida que o número de amostras aumenta) e exibe um desvio padrão maior entre as execuções.

3. Número de clusters (tamanho da discretização) :

   • Tomamos num_buckets para ser 0,1 * o número de amostras.
   • O desempenho de Mauve é bastante robusto para isso, desde que o número de gerações não seja muito pequeno.

4. Mauve é muito grande ou muito pequeno :

   • O parâmetro mauve_scaling_parameter controla o valor absoluto da pontuação do Mauve, sem alterar a ordem relativa entre vários métodos. O principal objetivo deste parâmetro é ajudar na interpretabilidade.
   • Se você achar que todos os seus métodos obtêm uma pontuação de Mauve muito alta (por exemplo, 0,995, 0,994), tente aumentar o valor de mauve_scaling_factor . (Nota: isso também aumenta o desvio padrão por execução de Mauve).
   • Se você achar que todos os seus métodos obtêm uma pontuação muito baixa em Mauve (por exemplo, <0,4), tente diminuir o valor de mauve_scaling_factor .

5. Mauve leva muito tempo para correr :

   • Você também pode tentar reduzir o número de clusters usando o argumento num_buckets . O tempo de execução do algoritmo de agrupamento é escala como o quadrado do número de clusters. Uma vez que o número de clusters excede 500, o cluster realmente começa a desacelerar. Nesse caso, pode ser útil definir o número de clusters como 500, substituindo o padrão (que é num_data_points / 10 ; portanto, use isso quando o número de amostras para cada um de P e Q for superior a 5000).
   • Nesse caso, tente reduzir os hiperparâmetros de cluster: defina kmeans_num_redo como 1 e, se isso não funcionar, kmeans_max_iter como 100 . Isso permite que o cluster seja mais rápido à custa de retornar um agrupamento pior.

6. A variação de Mauve é grande em relação às diferenças que tentamos quantificar :

   • Observamos que é muito fácil capturar erros básicos com Mauve, mas muito mais difícil quantificar erros sutis (por exemplo, ao tentar melhorar a amostragem de núcleos).
   • Para medir diferenças sutis com a confiança, a melhor solução é usar melhores incorporações, se você tiver acesso a eles.
   • Você também pode considerar mais execuções aleatórias para reduzir a variação: mais número de sementes K-means (mais barato em termos de computação), mais número de sementes de geração (para algoritmos baseados em amostragem) ou maior número de amostras de texto.

Citação

Se você achar este pacote útil ou usa -o em sua pesquisa, cite os seguintes trabalhos:

 @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}
}

Agradecimentos

Este trabalho foi suportado pelo NSF DMS-2134012, NSF CCF-2019844, NSF DMS-2023166, o programa DARPA MCS por meio do programa NIWC Pacific (N666001-19-2-4031), o Cifar ", o Cifar em Machines & Breains" Program ", um seguinte.