1. Introdução
Os produtos de IA generativa são relativamente novos, e os comportamentos de um aplicativo podem variar mais do que os formatos anteriores de software. Por isso, é importante sondar os modelos de machine learning usados, examinar exemplos do comportamento do modelo e investigar surpresas.
A ferramenta de aprendizado de interpretabilidade (LIT, site e GitHub) é uma plataforma para depurar e analisar modelos de ML para entender por que e como eles se comportam dessa forma.
Neste codelab, você vai aprender a usar a LIT para aproveitar ao máximo o modelo Gemma do Google. Este codelab demonstra como usar a saliência de sequência, uma técnica de interpretabilidade, para analisar diferentes abordagens de engenharia de comando.
Objetivos de aprendizado:
- Entender a saliência da sequência e seus usos na análise de modelos.
- Como configurar a LIT para Gemma calcular saídas de comandos e saliência de sequência.
- Como usar a saliência de sequência no módulo Saliência de LM para entender o impacto dos designs de comandos nas saídas do modelo.
- Testar possíveis melhorias de comando na LIT e analisar o impacto delas.
Observação: este codelab usa a implementação do KerasNLP do Gemma com o TensorFlow v2 como back-end. É altamente recomendável usar um kernel de GPU para acompanhar.
2. Saliência da sequência e seus usos na análise de modelos
Os modelos generativos de texto para texto, como o Gemma, recebem uma sequência de entrada na forma de texto tokenizado e geram novos tokens que são complementos ou conclusões típicos dessa entrada. Essa geração acontece um token por vez, anexando (em loop) cada token recém-gerado à entrada e as gerações anteriores até que o modelo atinja uma condição de parada. Exemplos incluem quando o modelo gera um token de fim de sequência (EOS, na sigla em inglês) ou atinge o tamanho máximo predefinido.
Os métodos de saliência são uma classe de técnicas de Explainable AI (XAI) que podem informar quais partes de uma entrada são importantes para o modelo em diferentes partes da saída. A LIT oferece suporte a métodos de saliência para várias tarefas de classificação, que explicam o impacto de uma sequência de tokens de entrada no rótulo previsto. A saliência da sequência generaliza esses métodos para modelos generativos de texto para texto e explica o impacto dos tokens anteriores nos tokens gerados.
Você vai usar o método Grad L2 Norm para saliência de sequência, que analisa os gradientes do modelo e fornece uma magnitude da influência de cada token anterior na saída. Esse método é simples e eficiente, e foi mostrado para ter um bom desempenho em classificação e outras configurações. Quanto maior a pontuação de saliência, maior a influência. Esse método é usado na LIT porque é bem compreendido e amplamente utilizado na comunidade de pesquisa de interpretabilidade.
Métodos de saliência baseados em gradiente mais avançados incluem Grad ⋅ Entrada e gradientes integrados. Também há métodos baseados em ablação disponíveis, como LIME e SHAP, que podem ser mais robustos, mas muito mais caros de calcular. Consulte este artigo para ver uma comparação detalhada dos diferentes métodos de saliência.
Saiba mais sobre a ciência dos métodos de saliência neste vídeo interativo introdutório sobre saliência (em inglês).
3. Importações, ambiente e outros códigos de configuração
É melhor acompanhar este codelab no novo Colab. Recomendamos o uso do tempo de execução do acelerador, já que você carregará um modelo na memória, mas lembre-se de que as opções de acelerador variam com o tempo e estão sujeitas a limitações. O Colab oferece assinaturas se você quiser acesso a aceleradores mais potentes. Como alternativa, use um ambiente de execução local se sua máquina tiver uma GPU apropriada.
Observação: podem aparecer alguns avisos do formulário
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.
É seguro ignorar essas sugestões.
Instalar a LIT e o Keras NLP
Neste codelab, você precisará de uma versão recente do keras (3) keras-nlp (0.8.0) e do lit-nlp (1.1), além de uma conta do Kaggle para fazer o download do modelo base.
!pip install -q -U lit-nlp
!pip uninstall -y umap-learn
!pip install -q -U keras-nlp
!pip install -q -U keras
Acesso ao Kaggle
Para fazer login no Kaggle, armazene o arquivo de credenciais do kaggle.json em ~/.kaggle/kaggle.json ou execute o seguinte em um ambiente do Colab. Consulte a documentação do pacote kagglehub para mais detalhes.
import kagglehub
kagglehub.login()
Aceite também o contrato de licença do Gemma.
4. Como configurar modelos de 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)
O código a seguir inicializa os wrappers LIT para oferecer suporte ao Salience no modelo Gemma. O framework da LIT se refere a eles como modelos, mas, nesse caso, são apenas endpoints diferentes para o mesmo gemma_model subjacente carregado acima. Isso permite que a LIT calcule gerações, tokenização e saliência sob demanda.
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. Como configurar conjuntos de dados da LIT
O Gemma é um modelo generativo de texto para texto que recebe uma entrada de texto e gera uma saída de texto. Os modelos da LIT presumem que os conjuntos de dados vão fornecer os seguintes campos para dar suporte à geração:
prompt: a entrada para umKerasGenerationModel.target: uma sequência de destino opcional, como "informações empíricas". (ouro) ou uma resposta pré-gerada do modelo.
A LIT inclui um pequeno conjunto de sample_prompts com exemplos de algumas fontes diferentes, como:
- GSM8K: Resolução de problemas de matemática do ensino fundamental com exemplos few-shot.
- Comparativo de mercado do Gigaword: geração de títulos para uma coleção de artigos curtos.
- Comando constitucional: gerar novas ideias sobre como usar objetos com diretrizes/limites.
Também é possível carregar facilmente seus próprios dados, seja como um arquivo .jsonl contendo registros com campos prompt e, opcionalmente, target (exemplo) ou em qualquer formato usando a API Dataset da LIT.
Execute a célula abaixo para carregar os exemplos de comandos.
from lit_nlp.examples.datasets import lm as lm_data
datasets = {
'sample_prompts': lm_data.PromptExamples(
lm_data.PromptExamples.SAMPLE_DATA_PATH
),
}
6. Como configurar a interface da LIT
A LIT é uma ferramenta interativa de compreensão de modelos que permite a avaliação e a sondagem do comportamento do modelo por human-in-the-loop. A interface da LIT facilita essa interação permitindo que você:
- visualizar seus conjuntos de dados e as saídas do modelo em tempo real,
- executar métodos de saliência para entender os tokens de entrada que impulsionam o comportamento do modelo;
- criar contrafatos para testar hipóteses.
A LIT permite tudo isso na mesma interface, reduzindo o atrito ao alternar entre diferentes ferramentas. Isso é particularmente útil para tarefas como engenharia de comando, que você vai abordar mais adiante neste codelab.
Esse layout de interface pode ser usado para qualquer outro modelo de linguagem generativa. Se você tiver interesse em outros recursos, confira a lista completa neste link.
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.',
)
Esse código inicializa o servidor da LIT. Isso pode levar alguns segundos, porque ele também executa o modelo nos comandos de amostra e armazena o resultado em 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',
)
Agora você pode mostrar a interface:
lit_widget.render(height=800)
Você também pode abrir a LIT como uma página inteira em uma nova guia. Execute este código e clique no link exibido:
lit_widget.render(open_in_new_tab=True)
Observação: se você estiver usando a LIT em um script .py normal, use lit_nlp.dev_server.Server() em vez de LitWidget para criar um servidor independente. Consulte a documentação da LIT para mais detalhes.
7. Como analisar alguns comandos Shot para o Gemma na LIT
Atualmente, os comandos são tanto arte quanto ciência, e a LIT pode ajudar você a melhorar empiricamente comandos para modelos de linguagem grandes, como o Gemma. Mais adiante, você vai conferir um exemplo de como a LIT pode ser usada para analisar os comportamentos de Gemma, antecipar possíveis problemas e melhorar a segurança.
Identificar erros em comandos complexos
Duas das técnicas de comando mais importantes para protótipos e aplicativos de alta qualidade baseados em LLMs são os comandos few-shot (incluindo exemplos do comportamento desejado no comando) e a cadeia de pensamento (incluindo uma forma de explicação ou raciocínio antes da saída final do LLM). Mas criar um comando eficaz muitas vezes ainda é um desafio.
Considere um exemplo de ajudar uma pessoa a avaliar se ela vai gostar de comida com base no próprio gosto. Um modelo de comando de cadeia de pensamento inicial do protótipo pode ter a seguinte aparência:
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:"""
Você identificou os problemas com o comando? A LIT vai ajudar você a examinar o comando com o módulo LM Salience.
8. Usar a saliência da sequência para depuração
A saliência é calculada no menor nível possível (ou seja, para cada token de entrada), mas a LIT pode agregar a saliência do token em períodos maiores mais interpretáveis, como linhas, frases ou palavras. Saiba mais sobre o Saliency e como usá-lo para identificar vieses não intencionais no nosso Saliency Explorable.
Vamos começar fornecendo ao comando uma nova entrada de exemplo para as variáveis do modelo de comando:
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:
Se a interface da LIT estiver aberta na célula acima ou em uma guia separada, use o Editor de ponto de dados da LIT para adicionar este prompt:
Outra maneira é renderizar novamente o widget diretamente com o comando desejado:
lit_widget.render(data=[fewshot_mistake_example])
Observe a surpreendente conclusão do modelo:
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.
Por que o modelo está sugerindo que você coma algo que disse claramente que não pode comer?
A saliência da sequência pode ajudar a destacar o problema raiz, que está em nossos exemplos few-shot. No primeiro exemplo, o raciocínio da cadeia de pensamento na seção de análise it has cooked onions in it, which you don't like não corresponde à recomendação final You have to try it.
No módulo LM Salience, selecione "Sentences" e selecione a linha de recomendação. A interface agora terá esta aparência:
Isso destaca um erro humano: uma cópia e colagem acidental da parte da recomendação e falha ao atualizá-la.
Agora, vamos corrigir a "Recomendação" no primeiro exemplo para Avoid e tente de novo. A LIT tem este exemplo pré-carregado nos prompts de amostra, para que você possa usar esta pequena função utilitária para capturá-lo:
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')}])
Agora, a conclusão do modelo se torna:
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.
Uma lição importante a ser retirada disso é: a prototipagem antecipada ajuda a revelar riscos nos quais você pode não pensar com antecedência, e a natureza propensa a erros dos modelos de linguagem significa que é necessário projetar proativamente para evitar erros. Se quiser mais detalhes sobre isso, consulte nosso guia de pessoas e IA sobre design com IA.
Embora o comando de poucas doses corrigido seja melhor, ele ainda não está certo. Ele diz corretamente ao usuário para evitar ovos, mas o raciocínio não está certo, diz que ele não gosta de ovos, quando na verdade o usuário declarou que não pode comer ovos. Na seção a seguir, você vai saber como melhorar.
9. Testar hipóteses para melhorar o comportamento do modelo
Com a LIT, é possível testar mudanças em comandos na mesma interface. Neste caso, você vai testar a adição de uma constituição para melhorar o comportamento do modelo. Constituições se referem a instruções de design com princípios que ajudam a orientar a geração do modelo. Os métodos recentes permitem até mesmo a derivação interativa de princípios constitucionais.
Vamos usar essa ideia para melhorar ainda mais o comando. Adicione uma seção com os princípios para a geração na parte de cima do comando, que começa assim:
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')}])
Com essa atualização, o exemplo pode ser executado novamente e observar uma saída muito diferente:
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.
A saliência do comando pode ser reavaliada para ajudar a entender por que essa mudança está acontecendo:
Observe que a recomendação é muito mais segura. Além disso, a mensagem "Não adequado para você" é influenciada pelo princípio de declarar claramente a adequação de acordo com a restrição alimentar, junto com a análise (a chamada cadeia de pensamento). Isso dá mais confiança de que a saída está acontecendo pela razão certa.
10. Incluir equipes não técnicas na sondagem e exploração de modelos
A interpretabilidade é um esforço de equipe que abrange conhecimentos sobre XAI, políticas, jurídicos e muito mais.
A interação com modelos nos estágios iniciais de desenvolvimento sempre exigia conhecimento técnico significativo, o que dificultava o acesso e a sondagem de alguns colaboradores. Historicamente, as ferramentas não existiram para permitir que essas equipes participassem das fases iniciais da prototipagem.
Com a LIT, a esperança é que esse paradigma possa mudar. Como você viu neste codelab, o meio visual e a capacidade interativa da LIT de examinar a saliência e explorar exemplos podem ajudar diferentes partes interessadas a compartilhar e comunicar descobertas. Assim, é possível trazer uma diversidade mais ampla de colegas de equipe para exploração, sondagem e depuração de modelos. A exposição a esses métodos técnicos pode aumentar a compreensão deles sobre como os modelos funcionam. Além disso, um conjunto mais diversificado de conhecimentos em testes iniciais de modelos também pode ajudar a descobrir resultados indesejados que podem ser melhorados.
11. Recapitulação
Em resumo:
- A interface da LIT oferece uma interface para execução interativa de modelos, permitindo que os usuários gerem saídas diretamente e testem "e se" diferentes. Isso é muito útil para testar diferentes variações de comandos.
- O módulo Salience do LM oferece uma representação visual de saliência e granularidade de dados controlável para que você possa se comunicar sobre construções centradas no ser humano (por exemplo, frases e palavras), em vez de construções centradas no modelo (por exemplo, tokens).
Quando encontrar exemplos problemáticos nas avaliações do modelo, coloque-os na LIT para depuração. Comece analisando a maior unidade sensível de conteúdo que se relaciona de maneira lógica à tarefa de modelagem, use as visualizações para saber onde o modelo está correto ou incorretamente atendendo ao conteúdo do comando e, em seguida, detalhe unidades menores de conteúdo para descrever ainda mais o comportamento incorreto observado e identificar possíveis correções.
Por fim: o Lit está sempre melhorando. Saiba mais sobre nossos recursos e compartilhe suas sugestões aqui.