1. Introdução
Os produtos de IA generativa são relativamente novos, e o comportamento de um aplicativo pode variar mais do que as formas anteriores de software. Por isso, é importante investigar os modelos de machine learning usados, examinar exemplos do comportamento deles e investigar surpresas.
A ferramenta de interpretabilidade de aprendizado (LIT, na sigla em inglês; site, 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 o 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 como ela é usada na análise de modelos.
- Configurando o LIT para Gemma para calcular as saídas de comando e a saliência da sequência.
- Usar a saliência de sequência no módulo Saliência de LM para entender o impacto dos designs de comando nas saídas do modelo.
- Testar as melhorias hipotéticas de comando no LIT e conferir o impacto delas.
Observação: este codelab usa a implementação KerasNLP do Gemma e o TensorFlow v2 para o back-end. É altamente recomendável usar um kernel de GPU para acompanhar.
2. Importância da sequência e 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 com tokens e geram novos tokens que são complementos ou conclusões típicas para essa entrada. Essa geração acontece um token por vez, anexando (em um loop) cada token recém-gerado à entrada, além de todas as gerações anteriores até que o modelo atinja uma condição de parada. Por exemplo, quando o modelo gera um token de fim de sequência (EOS, na sigla em inglês) ou atinge o comprimento máximo predefinido.
Os métodos de saliência são uma classe de técnicas de IA explicável (XAI, na sigla em inglês) 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 de 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 aqui para a saliência da sequência, que analisa os gradientes do modelo e fornece uma magnitude da influência que cada token anterior tem na saída. Esse método é simples e eficiente, e foi comprovado que ele tem bom desempenho na classificação e em outras configurações. Quanto maior a pontuação de destaque, maior a influência. Esse método é usado na LIT porque é bem compreendido e utilizado amplamente na comunidade de pesquisa de interpretabilidade.
Os métodos de saliência mais avançados baseados em gradiente incluem Grad ⋅ Input e gradientes integrados. Também há métodos baseados em ablação disponíveis, como LIME e SHAP, que podem ser mais robustos, mas significativamente mais caros de calcular. Consulte este artigo para uma comparação detalhada de diferentes métodos de destaque.
Saiba mais sobre a ciência dos métodos de destaque em este recurso interativo introdutório sobre destaque.
3. Importações, ambiente e outro código de configuração
É melhor acompanhar este codelab no novo Colab. Recomendamos o uso de um ambiente de execução de acelerador, já que você vai carregar um modelo na memória. No entanto, as opções de acelerador variam ao longo do tempo e estão sujeitas a limitações. O Colab oferece assinaturas pagas se você quiser ter acesso a aceleradores mais potentes. Como alternativa, use um ambiente de execução local se a máquina tiver uma GPU adequada.
Observação: talvez você receba 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.
Você pode ignorá-los com segurança.
Instalar o LIT e o Keras NLP
Para este codelab, você vai precisar de uma versão recente de keras (3) keras-nlp (0.14.) e lit-nlp (1.2) e uma conta do Kaggle para fazer o download do modelo base.
pip install -q -U 'keras >= 3.0' 'keras-nlp >= 0.14' 'lit-nlp >= 1.2'
Acesso ao Kaggle
Para fazer a autenticação com o Kaggle, você pode:
- Armazene suas credenciais em um arquivo, como
~/.kaggle/kaggle.json. - Use as variáveis de ambiente
KAGGLE_USERNAMEeKAGGLE_KEY. - Execute o seguinte em um ambiente Python interativo, como o Google Colab.
import kagglehub
kagglehub.login()
Consulte a documentação do kagglehub para mais detalhes e aceite o contrato de licença do Gemma.
Como configurar o Keras
O Keras 3 oferece suporte a vários back-ends de aprendizado profundo, incluindo o Tensorflow (padrão), o PyTorch e o JAX. O back-end é configurado usando a variável de ambiente KERAS_BACKEND, que precisa ser definida antes de importar a biblioteca Keras. O snippet de código abaixo mostra como definir essa variável em um ambiente interativo do Python.
import os
os.environ["KERAS_BACKEND"] = "tensorflow" # or "jax" or "torch"
4. Configurar o LIT
O LIT pode ser usado em notebooks Python ou em um servidor da Web. Este codelab se concentra no caso de uso do notebook. Recomendamos que você o siga no Google Colab.
Neste codelab, você vai carregar o Gemma v2 2B IT usando a predefinição KerasNLP. O snippet a seguir inicializa o Gemma e carrega um conjunto de dados de exemplo em um widget do LIT Notebook.
from lit_nlp.examples.prompt_debugging import notebook as lit_pdbnb
lit_widget = lit_pdbnb.make_notebook_widget(
['sample_prompts'],
["gemma2_2b_it:gemma2_instruct_2b_en"],
)
É possível configurar o widget mudando os valores transmitidos para os dois argumentos posicionais necessários:
datasets_config: uma lista de strings que contém os nomes e caminhos dos conjuntos de dados para carregamento, como "dataset:path", em que o caminho pode ser um URL ou um caminho de arquivo local. O exemplo abaixo usa o valor especialsample_promptspara carregar as instruções de exemplo fornecidas na distribuição do LIT.models_config: uma lista de strings que contém os nomes e caminhos dos modelos para carregamento, como "modelo:caminho", em que o caminho pode ser um URL, um caminho de arquivo local ou o nome de uma predefinição para o framework de aprendizado profundo configurado.
Depois de configurar o LIT para usar o modelo de interesse, execute o snippet de código a seguir para renderizar o widget no seu notebook.
lit_widget.render(open_in_new_tab=True)
Como usar seus próprios dados
Como um modelo generativo de texto para texto, o Gemma recebe entradas de texto e gera saídas de texto. O LIT usa uma API opinativa para comunicar a estrutura dos conjuntos de dados carregados aos modelos. Os LLMs no LIT foram projetados para funcionar com conjuntos de dados que fornecem dois campos:
prompt: a entrada do modelo a partir da qual o texto será gerado; etarget: uma sequência de destino opcional, como uma resposta de "informações empíricas" de avaliadores humanos ou uma resposta pré-gerada de outro modelo.
O LIT inclui um pequeno conjunto de sample_prompts com exemplos das seguintes fontes que oferecem suporte a este Codelab e ao tutorial de depuração de comandos estendido do LIT.
- GSM8K: resolve problemas de matemática da escola com exemplos rápidos.
- Comparativo Gigaword: geração de títulos para uma coleção de artigos curtos.
- Instrução constitucional: gerar novas ideias sobre como usar objetos com diretrizes/limites.
Também é possível carregar seus próprios dados como um arquivo .jsonl contendo registros com campos prompt e, opcionalmente, target (exemplo) ou de qualquer formato usando a API Dataset do LIT.
Execute a célula abaixo para carregar as solicitações de exemplo.
5. Como analisar comandos de poucos disparos para o Gemma no LIT
Hoje, a criação de comandos é uma arte e uma ciência, e o LIT pode ajudar a melhorar empiricamente os comandos para modelos de linguagem grandes, como o Gemma. A seguir, você vai conferir um exemplo de como a LIT pode ser usada para analisar os comportamentos do 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 LLM são a comandos de few-shot (incluindo exemplos do comportamento desejado no comando) e a cadeia de pensamentos (incluindo uma forma de explicação ou raciocínio antes da saída final do LLM). No entanto, criar uma instrução eficaz ainda é um desafio.
Considere um exemplo de como ajudar alguém a avaliar se vai gostar de um alimento com base nos gostos dele. Um modelo de comando de fluxo de consciência de protótipo inicial pode ser assim:
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 essa solicitação? O LIT vai ajudar você a examinar a instrução com o módulo de saliência do LM.
6. 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 o LIT pode agregar a saliência do token em intervalos maiores e mais interpretáveis, como linhas, frases ou palavras. Saiba mais sobre a saliência e como usá-la para identificar vieses involuntários na Saliency Explorable.
Vamos começar 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 do LIT estiver aberta na célula acima ou em uma guia separada, use o Editor de pontos de dados do LIT para adicionar esta solicitação:
Outra maneira é renderizar o widget novamente diretamente com o comando de interesse:
lit_widget.render(data=[fewshot_mistake_example])
Observe a conclusão surpreendente 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 sugere que você coma algo que você disse claramente que não pode comer?
A saliência da sequência pode ajudar a destacar o problema raiz, que está nos nossos exemplos de poucas fotos. 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 de saliência do LM, selecione "Sentenças" e a linha de recomendação. A interface agora vai ficar assim:
Isso destaca um erro humano: uma cópia e colagem acidental da parte de recomendação e a falha na atualização.
Agora, vamos corrigir a "Recomendação" no primeiro exemplo para Avoid e tentar novamente. O LIT tem esse exemplo pré-carregado nas instruções de exemplo. Use esta pequena função utilitária para acessá-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 fica assim:
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 é que o protótipo inicial ajuda a revelar riscos que você talvez não tenha pensado com antecedência, e a natureza propensa a erros dos modelos de linguagem significa que é preciso projetar proativamente para erros. Para mais informações, consulte o People + AI Guidebook (em inglês) sobre como projetar com IA.
Embora a correção do comando de poucas fotos seja melhor, ela ainda não está correta: ela diz corretamente ao usuário para evitar ovos, mas o raciocínio não está certo, ele diz que o usuário não gosta de ovos, quando na verdade o usuário disse que não pode comer ovos. Na próxima seção, você vai saber como melhorar.
7. Testar hipóteses para melhorar o comportamento do modelo
O LIT permite testar mudanças nos comandos na mesma interface. Neste caso, você vai testar a adição de uma constituição para melhorar o comportamento do modelo. As constituições se referem a propostas de design com princípios para ajudar a orientar a geração do modelo. Métodos recentes até permitem a derivação interativa de princípios constitucionais.
Vamos usar essa ideia para melhorar ainda mais a proposta. Adicionamos uma seção com os princípios da geração na parte de cima do comando, que agora 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 reexaminada para ajudar a entender por que essa mudança está acontecendo:
Observe que a recomendação é muito mais segura. Além disso, a opção "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 ajuda a ter mais confiança de que a saída está acontecendo pelo motivo certo.
8. Incluir equipes não técnicas na análise e investigação de modelos
A interpretabilidade é um esforço de equipe, abrangendo a experiência em XAI, políticas, questões legais e muito mais.
Tradicionalmente, a interação com modelos nos estágios iniciais de desenvolvimento exigia uma grande experiência técnica, o que dificultava o acesso e a análise deles por alguns colaboradores. Historicamente, não existiam ferramentas que permitissem que essas equipes participassem das primeiras fases de prototipagem.
A esperança é que esse paradigma mude com a LIT. Como você viu neste codelab, a capacidade visual e interativa do LIT de examinar a saliência e explorar exemplos pode ajudar diferentes partes interessadas a compartilhar e comunicar as descobertas. Isso permite que você traga uma diversidade maior de colegas de equipe para a exploração, investigação e depuração de modelos. A exposição a esses métodos técnicos pode melhorar a compreensão de 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 indesejáveis que podem ser melhorados.
9. Recapitulação
Em resumo:
- A interface do LIT oferece uma interface para execução de modelos interativos, permitindo que os usuários gerem saídas diretamente e testem cenários de "e se". Isso é útil principalmente para testar diferentes variações de comando.
- O módulo de saliência do LM fornece uma representação visual da saliência e oferece 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 você encontrar exemplos problemáticos nas avaliações do modelo, leve-os para o LIT para depuração. Comece analisando a maior unidade de conteúdo que você conseguir pensar que se relaciona de forma lógica à tarefa de modelagem. Use as visualizações para saber onde o modelo está atendendo corretamente ou incorretamente ao conteúdo do comando e, em seguida, acesse unidades de conteúdo menores para descrever melhor o comportamento incorreto que você está vendo e identificar possíveis correções.
Por último, o Lit está sempre melhorando. Saiba mais sobre nossos recursos e compartilhe suas sugestões aqui.