Tarefas em idiomas falados com Gemma

O uso da tecnologia de inteligência artificial (IA) em um idioma falado específico é uma necessidade fundamental para que muitas empresas possam usá-la de maneira eficaz. A família de modelos Gemma tem alguns recursos multilíngues, mas usá-lo em idiomas diferentes do inglês frequentemente produz resultados menos do que o ideal.

Felizmente, você não precisa ensinar a Gemma uma linguagem falada inteira para que ela possa concluir tarefas nesse idioma. Além disso, é possível ajustar os modelos do Gemma para concluir tarefas específicas em uma linguagem com muito menos dados e esforço do que você imagina. Usando cerca de 20 exemplos de solicitações e respostas esperadas no seu idioma de destino, o Gemma pode ajudar você a resolver muitos problemas de negócios diferentes na linguagem que melhor atende você e seus clientes.

Para conferir uma visão geral do projeto e como estendê-lo, incluindo insights dos criadores, assista o vídeo Spoken Language AI Assistant (em inglês) do Build with Google AI. Você também pode analisar o código desse projeto no repositório de código do Gemma Cookbook (link em inglês). Caso contrário, você pode começar a estender o projeto usando as seguintes instruções.

Visão geral

Neste tutorial, você vai aprender a configurar, executar e estender um aplicativo de tarefa de linguagem falada criado com Gemma e Python. Ele oferece uma interface de usuário da Web básica que você pode modificar de acordo com suas necessidades. O aplicativo foi criado para gerar respostas a e-mails de clientes de uma padaria fictícia coreana, e todas as entradas e saídas de linguagem são processadas totalmente em coreano. É possível usar esse padrão de aplicativo com qualquer idioma e qualquer tarefa de negócios que use entrada e saída de texto.

Figura 1. Interface do usuário do projeto, para consultas por e-mail de padaria coreana

Requisitos de hardware

Execute esse processo de ajuste em um computador com uma unidade de processamento gráfico (GPU) ou uma unidade de processamento de tensor (TPU) e memória suficiente para manter o modelo atual e os dados de ajuste. Para executar a configuração de ajuste neste projeto, você precisa de cerca de 16 GB de memória da GPU, aproximadamente a mesma quantidade de RAM normal e um mínimo de 50 GB de espaço em disco.

É possível executar a parte de ajuste de modelos do Gemma deste tutorial usando um ambiente do Colab com um ambiente de execução da GPU T4. Se você estiver criando esse projeto em uma instância de VM do Google Cloud, configure a instância seguindo estes requisitos:

• Hardware de GPU: uma NVIDIA T4 é necessária para executar este projeto, e uma NVIDIA L4 ou mais recente é recomendada.
• Sistema operacional: selecione uma opção de Aprendizado profundo no Linux, especificamente a VM de aprendizado profundo com CUDA 12.3 M124 com drivers de software de GPU pré-instalados.
• Tamanho do disco de inicialização: provisione pelo menos 50 GB de espaço em disco para seus dados, modelos e software de suporte.

Configurar o projeto

Estas instruções mostram como preparar o projeto para desenvolvimento e teste. As etapas gerais de configuração incluem a instalação de um software de pré-requisito, a clonagem do projeto do repositório de código, a configuração de algumas variáveis de ambiente, a instalação de bibliotecas do Python e o teste do aplicativo da Web.

Instalar e configurar

Este projeto usa o Python 3 e ambientes virtuais (venv) para gerenciar pacotes e executar o aplicativo. As instruções de instalação a seguir são para uma máquina host Linux.

Para instalar o software necessário:

• Instale o Python 3 e o pacote de ambiente virtual venv para Python.

  sudo apt update
  sudo apt install git pip python3-venv
  

Clonar o projeto

Faça o download do código do projeto para seu computador de desenvolvimento. Você precisa de um software de controle de origem git para recuperar o código-fonte do projeto.

Para fazer o download do código do projeto:

1. Clone o repositório do Git usando o comando abaixo.

   git clone https://github.com/google-gemini/gemma-cookbook.git
   

2. Se quiser, configure seu repositório local do Git para usar o checkout esparso, para que você tenha apenas os arquivos do projeto.

   cd gemma-cookbook/
   git sparse-checkout set Gemma/spoken-language-tasks/
   git sparse-checkout init --cone
   

Instalar bibliotecas do Python

Instale as bibliotecas com o ambiente virtual venv do Python ativado para gerenciar pacotes e dependências do Python. Ative o ambiente virtual do Python antes de instalar bibliotecas do Python com o instalador pip. Para mais informações sobre o uso de ambientes virtuais Python, consulte a documentação Python venv.

Para instalar as bibliotecas do Python:

1. Em uma janela de terminal, navegue até o diretório spoken-language-tasks:

   cd Gemma/spoken-language-tasks/
   

2. Configure e ative o ambiente virtual do Python (venv) para este projeto:

   python3 -m venv venv
   source venv/bin/activate
   

3. Instale as bibliotecas Python necessárias para este projeto usando o script setup_python.

   ./setup_python.sh
   

Defina as variáveis de ambiente

Defina algumas variáveis de ambiente necessárias para permitir a execução desse projeto de código, incluindo um nome de usuário e uma chave de token do Kaggle. Você precisa ter uma conta do Kaggle e solicitar acesso aos modelos Gemma para fazer o download deles. Para este projeto, adicione o nome de usuário e a chave de token do Kaggle a dois arquivos .env, que são lidos pelo aplicativo da Web e pelo programa de ajuste, respectivamente.

Para definir as variáveis de ambiente:

1. Receba seu nome de usuário do Kaggle e sua chave de token seguindo as instruções na documentação do Kaggle.
2. Para ter acesso ao modelo Gemma, siga as instruções Como ter acesso ao Gemma na página Configuração do Gemma.
3. Crie arquivos de variáveis de ambiente para o projeto, criando um arquivo de texto .env em cada um desses locais no clone do projeto:

   k-mail-replier/k_mail_replier/.env
   k-gemma-it/.env
   

4. Depois de criar os arquivos de texto .env, adicione as seguintes configurações a ambos os arquivos:

   KAGGLE_USERNAME=<YOUR_KAGGLE_USERNAME_HERE>
   KAGGLE_KEY=<YOUR_KAGGLE_KEY_HERE>
   

Executar e testar o aplicativo

Depois de concluir a instalação e a configuração do projeto, execute o aplicativo da Web para confirmar se você o configurou corretamente. Faça isso como uma verificação de referência antes de editar o projeto para seu próprio uso.

Para executar e testar o projeto:

1. Em uma janela de terminal, navegue até o diretório /k_mail_replier/:

   cd spoken-language-tasks/k-mail-replier/
   

2. Execute o aplicativo usando o script run_flask_app.sh:

   ./run_flask_app.sh
   

3. Depois de iniciar o aplicativo da Web, o código do programa lista um URL em que é possível navegar e testar. Normalmente, esse endereço é:

   http://127.0.0.1:5000/
   

4. Na interface da Web, pressione o botão 답변 작성 abaixo do primeiro campo de entrada para gerar uma resposta do modelo.

A primeira resposta do modelo após a execução do aplicativo leva mais tempo, porque precisa concluir as etapas de inicialização na primeira execução de geração. As solicitações e a geração de comandos subsequentes em um aplicativo da Web em execução são concluídas em menos tempo.

Ampliar o aplicativo

Depois que o aplicativo estiver em execução, você poderá estendê-lo modificando a interface do usuário e a lógica de negócios para que ele funcione em tarefas relevantes para você ou sua empresa. Também é possível modificar o comportamento do modelo Gemma usando o código do aplicativo, mudando os componentes do comando que o app envia para o modelo de IA generativa.

O aplicativo fornece instruções ao modelo com os dados de entrada do usuário e um comando completo do modelo. É possível modificar essas instruções para mudar o comportamento do modelo, como especificar que o modelo precisa extrair informações da solicitação e colocá-las em um formato de dados estruturado, como JSON. Uma maneira mais simples de mudar o comportamento do modelo é fornecer instruções ou orientações adicionais para a resposta do modelo, como especificar que as respostas geradas devem ser escritas em um tom educado.

Para modificar instruções de comandos:

1. No projeto de tarefa de idioma falado, abra o arquivo de código k-mail-replier/k_mail_replier/app.py.

2. No código app.py, adicione instruções de adição à função get_prompt()::

   def get_prompt():
       return "발신자에게 요청에 대한 감사를 전하고, 곧 자세한 내용을
           알려드리겠다고 정중하게 답장해 주세요. 정중하게 답변해 주세요!:\n"
   

Este exemplo adiciona a frase "Escreva uma resposta educada" às instruções em coreano.

Fornecer instruções adicionais pode influenciar bastante o resultado gerado e exige muito menos esforço para ser implementado. Tente usar esse método primeiro para conferir se é possível conseguir o comportamento desejado do modelo. No entanto, o uso de instruções de comando para modificar o comportamento de um modelo Gemma tem limites. Especificamente, o limite geral de tokens de entrada do modelo, que é 8.192 tokens para o Gemma 2, exige que você equilibre instruções detalhadas de comandos com o tamanho dos novos dados fornecidos para não ultrapassar esse limite.

Além disso, quando você quer que o Gemma execute tarefas em um idioma diferente do inglês, é improvável que apenas acionar o modelo de base produza resultados úteis. Em vez disso, ajuste o modelo com exemplos no idioma de destino e depois considere modificar as instruções do comando para fazer ajustes menores na saída do modelo ajustado.

Ajustar o modelo

Recomendamos o ajuste de um modelo Gemma para que ele responda de maneira eficaz em um idioma falado diferente do inglês. No entanto, você não precisa ter fluência total no idioma de destino para que o modelo possa concluir tarefas nesse idioma. É possível alcançar uma funcionalidade básica no idioma de destino para uma tarefa com cerca de 20 exemplos. Esta seção do tutorial explica como configurar e executar o ajuste fino em um modelo Gemma para uma tarefa específica, em um idioma específico.

As instruções a seguir explicam como realizar a operação de ajuste fino em um ambiente de VM. No entanto, você também pode realizar essa operação de ajuste usando o Colab noteboook associado a este projeto.

Requisitos de hardware

Os requisitos de computação para o ajuste fino são os mesmos que os requisitos de hardware para o restante do projeto. É possível executar a operação de ajuste em um ambiente do Colab com um ambiente de execução da GPU T4 se você limitar os tokens de entrada a 256 e o tamanho do lote a 1.

Preparar dados

Antes de começar a ajustar um modelo do Gemma, é necessário preparar os dados para o ajuste. Ao ajustar um modelo para uma tarefa e um idioma específicos, você precisa de um conjunto de exemplos de solicitação e resposta nesse idioma. Esses exemplos devem mostrar o texto da solicitação, sem instruções, e o texto de resposta esperado. Para começar, prepare um conjunto de dados com cerca de 20 exemplos. Esses exemplos precisam representar uma variedade completa de solicitações e as respostas ideais. Verifique se as solicitações e as respostas não são repetitivas, porque isso pode fazer com que as respostas do modelo sejam repetitivas e não se ajustem adequadamente às variações nas solicitações. A tabela a seguir mostra alguns registros de amostra do conjunto de dados deste exemplo de código:

Tabela 1. Lista parcial do conjunto de dados de ajuste do respondedor de e-mail da padaria coreana.

Formato e carregamento de dados

Você pode armazenar os dados de ajuste em qualquer formato conveniente, incluindo registros de banco de dados, arquivos JSON, CSV ou arquivos de texto simples, desde que você tenha como extrair os registros com código Python. Para sua conveniência, o exemplo de programa de ajuste recebe os registros de um repositório on-line. Neste exemplo de programa de conversão, o conjunto de dados de ajuste é carregado no módulo k-gemma-it/main.py usando a função prepare_tuning_dataset():

def prepare_tuning_dataset():
    tokenizer = keras_nlp.models.GemmaTokenizer.from_preset(model_id)

    # load data from repository (or local directory)
    from datasets import load_dataset
    ds = load_dataset(
        # Dataset : https://huggingface.co/datasets/bebechien/korean_cake_boss
        "bebechien/korean_cake_boss",
        split="train",
    )
    ...

Como mencionado anteriormente, é possível armazenar o conjunto de dados em um formato conveniente, desde que você possa recuperar as solicitações com as respostas associadas e montá-las em uma string de texto usada como um registro de ajuste.

Montar registros de ajuste

Para o processo de ajuste real, cada solicitação e resposta é montada em uma string única com as instruções e tags do comando para indicar o conteúdo da solicitação e da resposta. Esse programa de ajuste tokeniza a string para consumo pelo modelo. Confira o código para montar um registro de ajuste na função prepare_tuning_dataset() do módulo k-gemma-it/main.py, conforme mostrado abaixo:

def prepare_tuning_dataset():
    ...
    prompt_instruction = "다음에 대한 이메일 답장을 작성해줘."

    for x in data:
        item = f"<start_of_turn>user\n{prompt_instruction}\n\"{x['input']}\"<end_of_turn>\n<start_of_turn>model\n{x['output']}<end_of_turn>"
        length = len(tokenizer(item))
        # skip data if the token length is longer than our limit
        if length < token_limit:
            tuning_dataset.append(item)
            if(len(tuning_dataset)>=num_data_limit):
                break
    ...

Essa função lê os dados e os formata adicionando tags start_of_turn e end_of_turn, que são o formato necessário ao fornecer dados para ajustar um modelo Gemma. Esse código também insere um prompt_instruction para cada solicitação, que você precisa editar conforme apropriado para seu aplicativo.

Gerar pesos do modelo

Depois de carregar e colocar os dados de ajuste no lugar, é possível executar o programa de ajuste. O processo de ajuste para este aplicativo de exemplo usa a biblioteca Keras NLP para ajustar o modelo com uma adaptação de classificação baixa, ou técnica LoRA, para gerar novos pesos de modelo. Em comparação com o ajuste de precisão total, o uso da LoRA é significativamente mais eficiente em termos de memória, porque aproxima as mudanças nos pesos do modelo. Em seguida, é possível sobrepor esses pesos aproximados aos pesos do modelo atual para alterar o comportamento do modelo.

Para realizar o ajuste e calcular novos pesos:

1. Em uma janela de terminal, navegue até o diretório k-gemma-it/.

   cd spoken-language-tasks/k-gemma-it/
   

2. Execute o processo de ajuste usando o script tune_model:

   ./tune_model.sh
   

O processo de ajuste leva vários minutos, dependendo dos recursos de computação disponíveis. Quando ele for concluído, o programa de ajuste vai gravar novos arquivos de peso *.h5 no diretório k-gemma-it/weights com o seguinte formato:

gemma2-2b_k-tuned_4_epoch##.lora.h5

Solução de problemas

Se a otimização não for concluída, há duas razões prováveis:

1. Memória insuficiente / recursos esgotados: esses erros ocorrem quando o processo de ajuste solicita memória que excede a memória disponível da GPU ou da CPU. Verifique se você não está executando o aplicativo da Web enquanto o processo de ajuste está em execução. Se você estiver ajustando um dispositivo com 16 GB de memória GPU, confira se token_limit está definido como 256 e batch_size como 1.
2. Drivers de GPU não instalados ou incompatíveis com o JAX: o processo de ativação exige que o dispositivo de computação tenha drivers de hardware instalados que sejam compatíveis com a versão das bibliotecas JAX. Para mais detalhes, consulte a documentação de instalação do JAX.

Implantar o modelo ajustado

O processo de ajuste gera vários pesos com base nos dados de ajuste e no número total de épocas definidas no aplicativo de ajuste. Por padrão, o programa de ajuste gera 20 arquivos de peso do modelo, um para cada período de ajuste. Cada época de ajuste sucessiva produz pesos que reproduzem com mais precisão os resultados dos dados de ajuste. É possível conferir as taxas de acurácia de cada época na saída do terminal do processo de ajuste, conforme abaixo:

...
Epoch 14/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 567ms/step - loss: 0.4026 - sparse_categorical_accuracy: 0.8235
Epoch 15/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 569ms/step - loss: 0.3659 - sparse_categorical_accuracy: 0.8382
Epoch 16/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 571ms/step - loss: 0.3314 - sparse_categorical_accuracy: 0.8538
Epoch 17/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 572ms/step - loss: 0.2996 - sparse_categorical_accuracy: 0.8686
Epoch 18/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 574ms/step - loss: 0.2710 - sparse_categorical_accuracy: 0.8801
Epoch 19/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 575ms/step - loss: 0.2451 - sparse_categorical_accuracy: 0.8903
Epoch 20/20
10/10 ━━━━━━━━━━━━━━━━━━━━ 6s 575ms/step - loss: 0.2212 - sparse_categorical_accuracy: 0.9021

Embora você queira que a taxa de precisão seja relativamente alta, em torno de 0,80 a 0,90, não é recomendável que ela seja muito alta ou muito próxima de 1,00, porque isso significa que os pesos estão próximos de um overfitting dos dados de ajuste. Quando isso acontece, o modelo não tem um bom desempenho em solicitações significativamente diferentes dos exemplos de ajuste. Por padrão, o script de implantação escolhe as ponderações da época 17, que normalmente têm uma taxa de precisão em torno de 0,90.

Para implantar os pesos gerados no aplicativo da Web:

1. Em uma janela do terminal, navegue até o diretório k-gemma-it/.

   cd spoken-language-tasks/k-gemma-it/
   

2. Execute o processo de ajuste usando o script deploy_weights:

   ./deploy_weights.sh
   

Depois de executar esse script, você vai encontrar um novo arquivo *.h5 no diretório k-mail-replier/k_mail_replier/weights/.

Testar o novo modelo

Depois de implantar os novos pesos no aplicativo, é hora de testar o modelo recém-ajustado. Para isso, execute novamente o aplicativo da Web e gerencie uma resposta.

Para executar e testar o projeto:

1. Em uma janela de terminal, navegue até o diretório /k_mail_replier/.

   cd spoken-language-tasks/k-mail-replier/
   

2. Execute o aplicativo usando o script run_flask_app.sh:

   ./run_flask_app.sh
   

3. Depois de iniciar o aplicativo da Web, o código do programa lista um URL em que é possível navegar e testar. Normalmente, esse endereço é:

   http://127.0.0.1:5000/
   

4. Na interface da Web, pressione o botão 답변 작성 abaixo do primeiro campo de entrada para gerar uma resposta do modelo.

Agora você já ajustou e implantou um modelo Gemma em um aplicativo. Teste o aplicativo e tente determinar os limites do recurso de geração do modelo ajustado para sua tarefa. Se você encontrar cenários em que o modelo não tem um bom desempenho, adicione algumas dessas solicitações à lista de dados de exemplo de ajuste, adicionando a solicitação e fornecendo uma resposta ideal. Em seguida, execute novamente o processo de ajuste, reimplante os novos pesos e teste a saída.

Outros recursos

Para mais informações sobre esse projeto, consulte o repositório de código do Gemma Cookbook. Se você precisar de ajuda para criar o aplicativo ou quiser colaborar com outros desenvolvedores, confira o servidor do Discord da Comunidade de Desenvolvedores do Google. Para conferir mais projetos do Build with Google AI, acesse a playlist de vídeos.