Como usar a LIT com o Gemma

Conferir em IA generativa Executar no Google Colab Veja o código-fonte no GitHub Aprenda em Codelabs

Os produtos de IA generativa são relativamente novos, e os comportamentos deles podem variar mais do que formas anteriores de software. Por isso, é importante sondar o fluxo de machine learning modelos em uso, examinar exemplos de comportamento do modelo e investigar surpresas.

A ferramenta de aprendizado de interpretabilidade (LIT; site, GitHub) é uma plataforma para depurar e analisar modelos de ML para entender por que e como eles se comportam da maneira que fazem.

Aqui, você vai aprender a configurar a LIT para aproveitar ao máximo modelo Gemma (em inglês) usando o módulo de saliência sequencial para analisar diferentes de engenharia de comando.

Como configurar a LIT para depurar comandos do Gemma

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

Este notebook usa a implementação KerasNLP do Gemma (mais sobre como configure isso abaixo). Você precisa de uma versão recente do keras (3.0+) keras-nlp (0.12+) e lit-nlp (1.2+), e uma conta Kaggle para baixar a modelo base.

# Keras is included in Colab runtimes, but needs to be updated to to v3.0+.
# LIT and Keras NLP are not icnldued by default and must be installed.
# Running this cell may require you to restart your session to ensure the newer
# packages are imported correctly.
 pip install -q -U "keras >= 3.0, <4.0" "keras-nlp >= 0.14" "lit-nlp >= 1.2"

Acesso ao Kaggle

O KerasNLP armazena os pesos dos modelos pré-treinados no Kaggle. O O pacote kagglehub é usado. para autenticar com este serviço. Aceite o contrato de licença também para Gemma na sua conta Kaggle.

Consulte o Apêndice no final para obter mais informações sobre como configurar um Kaggle do Compute Engine.

import kagglehub

kagglehub.login()

Como configurar a LIT

A LIT oferece a função make_notebook_widget() para configurar o comando de depuração em um contexto de notebook.

A LIT oferece um conjunto de dados de exemplos de comandos que acompanham o tutorial vinculado mais adiante neste documento.

Leia os comentários abaixo para configurar o widget para usar diferentes modelos e/ou conjuntos de dados.

from lit_nlp.examples.prompt_debugging import notebook as lit_pdbnb

# The following function initializes a LIT Notebook Widget. It's configured by
# two required positional arguments:
#
# * `datasets_config`: A list of strings containing the dataset names and
#       paths to load from, as "dataset:path", where path can be a URL or a
#       local file path. The example below uses a special value,
#       `sample_prompts`, to load the example prompts provided in the LIT
#       distribution; no other special values are supported.
# * `models_config`: A list of strings containing the model names and paths to
#       load from, as "model:path", where path can be a URL, a local file path,
#       or the name of a preset for the configured deep learning framework.
#
# LIT supports salience computation for KerasNLP and Hugging Face Transformers
# models running on TensorFlow or PyTorch. Note that all models passed to the
# `models_config` parameter will be loaded using the same framework and runtime.
# You can cofnigre these with the following keywork arguments.
#
# * `dl_framework`: Must be one of "kerasnlp" or "transformers".
# * `dl_runtime`: Must be one of "tensorflow" or "torch".
#
# Changing the `dl_framework` value will affect the authentication method used
# to access Gemma model weights.

lit_widget = lit_pdbnb.make_notebook_widget(
    ['sample_prompts'],
    ["gemma_2b_it:gemma_1.1_instruct_2b_en"],
    dl_framework="kerasnlp",
    dl_runtime="tensorflow",
    batch_size=1,
    max_examples=5,
    precision="bfloat16",
)

Agora é possível renderizar a interface em uma célula do Colab.

lit_widget.render()

<IPython.core.display.Javascript object>

Depuração de comandos com saliência de sequências

Os modelos de linguagem grande (LLMs) 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 conclusões ou acompanhamentos lógicos.

Os métodos de saliência permitem inspecionar quais partes de um são importantes para o modelo devido a diferentes partes da saída gerada. O módulo de saliência sequencial da LIT estende esses métodos para explicar a importância de sequências em vários níveis de granularidade: de tokens a de palavras a frases e além delas.

É possível usar a LIT na célula acima para testar a saliência da sequência. por conta própria. Para uma experiência de aprendizado mais guiada, você pode acompanhar com o tutorial Como depurar comandos com saliência de sequência (em inglês) neste Colab.

Para mais informações acadêmicas e técnicas sobre como a saliência da sequência funciona, confira nosso artigo.

Apêndice: como acessar o Gemma no Kaggle Hub

Este notebook usa a implementação KerasNLP do Gemma neste documento. O KerasNLP armazena os pesos dos modelos pré-treinados no Kaggle, e o Gemma exige e confirmação de licença para acessar esses pesos.

As instruções a seguir orientam você sobre como configurar uma conta Kaggle e autenticar com o Kaggle usando o pacote kagglehub.

  1. Crie uma conta Kaggle, caso ainda não tenha uma
  2. Pedir acesso ao Gemma
    • Faça login no Kaggle usando a conta acima
    • Acesse a página de consentimento: https://www.kaggle.com/models/google/gemma/license/consent
    • Selecione a opção "Verificar via conta do Kaggle" (a seleção padrão) e clique em "Próximo"
    • Preencher o formulário de consentimento (os campos de nome e sobrenome na parte de cima)
    • Confirme a política usando as caixas de seleção na parte inferior
    • Clique no botão "Aceitar" na parte inferior para receber acesso
    • Isso vai redirecionar você para a página do modelo (https://www.kaggle.com/models/google/gemma).
  3. Criar um token de API
    • Certifique-se de fazer login no Kaggle usando a conta criada acima
    • Acesse a página de configurações: https://www.kaggle.com/settings
    • Role a tela para baixo até a seção "API".
    • Use a opção "Criar novo token" botão para acionar a geração de tokens
    • Use o menu na tela para salvar o arquivo JSON, chamado kaggle.json, que o serviço gera na sua máquina.
    • O arquivo JSON é um objeto com duas propriedades, nome de usuário e chave. Você precisará de ambas para autenticar com o serviço mais tarde.
  4. Usar as credenciais do token de API para fazer a autenticação com o Kagglehub no Colab
    • Acesse o Colab LIT Sequence Sale: https://colab.sandbox.google.com/github/google/generative-ai-docs/blob/main/site/en/gemma/docs/lit_gemma.ipynb#scrollTo=yKw8gDsh_nVR (link em inglês)
    • Conectar-se a um ambiente de execução de GPU
    • Para Gemma 2B, você pode usar o ambiente de execução T4 de nível sem custo financeiro
    • Para o Gemma 7B, você vai precisar de créditos de computação pré-pagos do Colab ou de uma conta do Colab Pro para usar uma GPU V100, L4 ou A100.
    • Execute a célula de código kagglehub para exibir um formulário HTML que solicita seu nome de usuário e um token
    • Copie o campo username do arquivo kaggle.json que você salvou na etapa anterior e cole-o no campo username do formulário.
    • Copie o campo key do arquivo kaggle.json que você salvou na etapa anterior e cole-o no campo token do formulário.
    • Clique no botão de login para salvar essas credenciais no ambiente de execução

Repita a última etapa sempre que o ambiente de execução do Colab for desconectado, já que a desconexão limpa o cache em que as credenciais estão armazenadas.