Guia de inferência do LLM

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) totalmente no dispositivo, que podem ser usados para realizar uma ampla gama de tarefas, como gerar texto, recuperar informações em linguagem natural e resumir documentos. A tarefa oferece suporte integrado a vários modelos de linguagem grandes de texto para texto, para que você possa aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps e produtos.

Teste!arrow_forward

A tarefa é compatível com as seguintes variantes do Gemma: Gemma 2 2B, Gemma 2B e Gemma 7B. O Gemma é uma família de modelos abertos leves e de última geração criados com base na mesma pesquisa e tecnologia usadas para criar os modelos do Gemini. Ele também oferece suporte aos seguintes modelos externos: Phi-2, Falcon-RW-1B e StableLM-3B.

Além dos modelos compatíveis, você pode usar o AI Edge Torch do Google para exportar modelos PyTorch para modelos LiteRT (tflite) com várias assinaturas, que são agrupados com parâmetros de tokenizer para criar pacotes de tarefas compatíveis com a API Inference LLM. Os modelos convertidos com a AI Edge Torch só podem ser executados no back-end da CPU e, portanto, são limitados ao Android e ao iOS.

Começar

Para começar a usar essa tarefa, siga um destes guias de implementação para sua plataforma. Estes guias específicos para plataformas orientam você em uma implementação básica dessa tarefa, com exemplos de código que usam um modelo disponível e as opções de configuração recomendadas:

• Web:

  • Guia
  • Exemplo de código

• Android:

  • Guia
  • Exemplo de código

• iOS

  • Guia
  • Exemplo de código

Detalhes da tarefa

Esta seção descreve os recursos, entradas, saídas e opções de configuração desta tarefa.

Recursos

A API LLM Inference contém os seguintes recursos principais:

1. Text-to-text generation: gera texto com base em um comando de texto de entrada.
2. Seleção de LLM: aplique vários modelos para personalizar o app para seus casos de uso específicos. Também é possível treinar novamente e aplicar pesos personalizados ao modelo.
3. Suporte à LoRA: estenda e personalize o recurso de LLM com o modelo LoRA treinando em todo o conjunto de dados ou usando modelos LoRA pré-criados da comunidade de código aberto (não compatível com modelos convertidos com a API Gerativa AI Edge Torch).

Opções de configuração

Esta tarefa tem as seguintes opções de configuração:

Modelos

A API LLM Inference oferece suporte a muitos modelos de linguagem grandes de texto para texto, incluindo suporte integrado a vários modelos otimizados para execução em navegadores e dispositivos móveis. Esses modelos leves podem ser usados para executar inferências completamente no dispositivo.

Antes de inicializar a API LLM Inference, faça o download de um modelo e armazene o arquivo no diretório do projeto. É possível usar um modelo pré-convertido ou converter um modelo para um formato compatível com o MediaPipe.

A API de inferência de LLM é compatível com dois tipos de modelos de categorias, alguns dos quais exigem conversão de modelos. Use a tabela para identificar o método de etapas necessário para seu modelo.

Os arquivos .bin convertidos para Gemma 2B, Gemma 7B e Gemma-2 2B estão hospedados no Kaggle. Esses modelos podem ser implantados diretamente usando nossa API de inferência de LLM. Para aprender a converter outros modelos, consulte a seção Conversão de modelos.

Gemma-2 2B

O Gemma-2 2B é o modelo mais recente da família Gemma de modelos abertos leves e de última geração criados com a mesma pesquisa e tecnologia usadas para criar os modelos Gemini. O modelo contém parâmetros 2B e pesos abertos. A Gemma-2 2B é conhecida por habilidades de raciocínio de última geração para modelos da classe.

Fazer o download do Gemma-2 2B

Os modelos Gemma-2 2B estão disponíveis nas seguintes variantes:

• gemma2-2b-it-cpu-int8: modelo Gemma-2 2B de 8 bits com compatibilidade de CPU.
• gemma2-2b-it-gpu-int8: modelo Gemma-2 2B de 8 bits com compatibilidade com GPU.

Você também pode ajustar o modelo e adicionar novos pesos antes de adicioná-lo ao app. Para mais informações sobre como ajustar e personalizar o Gemma, consulte Ajustar o Gemma. Depois de fazer o download do Gemma-2 2B no Kaggle Models, o modelo já está no formato adequado para uso com o MediaPipe Tasks.

Gemma 2B

O Gemma 2B faz parte de uma família de modelos abertos leves e de última geração criados com a mesma pesquisa e tecnologia usadas para criar os modelos do Gemini. O modelo contém parâmetros 2B e pesos abertos. Esse modelo é adequado para várias tarefas de geração de texto, incluindo resposta a perguntas, resumo e raciocínio.

Fazer o download do Gemma 2B

Os modelos Gemma 2B estão disponíveis nas seguintes variantes:

• gemma-2b-it-cpu-int4: modelo Gemma 2B de 4 bits com compatibilidade de CPU.
• gemma-2b-it-cpu-int8: modelo Gemma 2B de 8 bits com compatibilidade de CPU.
• gemma-2b-it-gpu-int4: modelo Gemma 2B de 4 bits com compatibilidade com GPU.
• gemma-2b-it-gpu-int8: modelo Gemma 2B de 8 bits com compatibilidade com GPU.

Você também pode ajustar o modelo e adicionar novos pesos antes de adicioná-lo ao app. Para mais informações sobre como ajustar e personalizar o Gemma, consulte Ajustar o Gemma. Depois de fazer o download do Gemma 2B no Kaggle Models, o modelo já está no formato adequado para uso com as tarefas do MediaPipe.

Gemma 7B

O Gemma 7B é um modelo maior do Gemma com 7B parâmetros e pesos abertos. O modelo é mais poderoso para várias tarefas de geração de texto, incluindo resposta a perguntas, resumo e raciocínio. O Gemma 7B só tem suporte na Web.

Fazer o download do Gemma 7B

O modelo Gemma 7B tem uma variante:

• gemma-1.1-7b-it-gpu-int8: modelo Gemma 7B de 8 bits com compatibilidade com GPU.

Depois de fazer o download do Gemma 7B no Kaggle Models, o modelo já está no formato adequado para uso com o MediaPipe.

Falcon 1B

O Falcon-1B é um modelo de decodificador causal de 1 bilhão de parâmetros treinado em 350 bilhões de tokens do RefinedWeb.

Faça o download do Falcon 1B

A API de inferência de LLM exige que os seguintes arquivos sejam transferidos por download e armazenados localmente:

• tokenizer.json
• tokenizer_config.json
• pytorch_model.bin

Depois de fazer o download dos arquivos do modelo Falcon, o modelo fica pronto para ser convertido para o formato MediaPipe com um script de conversão. Siga as etapas na seção Script de conversão para modelos compatíveis.

StableLM 3B

O StableLM-3B é um modelo de linguagem somente decodificador de 3 bilhões de parâmetros pré-treinado em 1 trilhão de tokens de diversos conjuntos de dados de inglês e código por 4 épocas.

Fazer o download do StableLM 3B

A API de inferência de LLM exige que os seguintes arquivos sejam transferidos por download e armazenados localmente:

• tokenizer.json
• tokenizer_config.json
• model.safetensors

Depois de fazer o download dos arquivos do modelo StableLM, o modelo fica pronto para ser convertido para o formato MediaPipe com um script de conversão. Siga as etapas na seção Script de conversão para modelos compatíveis.

Phi-2

O Phi-2 é um modelo de transformador de 2,7 bilhões de parâmetros. Ele foi treinado usando vários textos sintéticos de PNL e sites filtrados. O modelo é mais adequado para comandos que usam o formato de perguntas e respostas, chat e código.

Fazer o download do Phi-2

A API de inferência de LLM exige que os seguintes arquivos sejam transferidos por download e armazenados localmente:

• tokenizer.json
• tokenizer_config.json
• model-00001-of-00002.safetensors
• model-00002-of-00002.safetensors

Depois de fazer o download dos arquivos do modelo Phi-2, ele fica pronto para ser convertido para o formato MediaPipe com um script de conversão. Siga as etapas na seção Script de conversão para modelos compatíveis.

Modelos geradores do PyTorch

Os modelos generativos do PyTorch podem ser convertidos em um formato compatível com o MediaPipe com a API AI Edge Torch Generative. É possível usar a API para converter modelos do PyTorch em modelos do LiteRT (TensorFlow Lite) com várias assinaturas. Para mais detalhes sobre o mapeamento e a exportação de modelos, acesse a página do GitHub AI Edge Torch (link em inglês).

Se você pretende usar a API AI Edge Torch Generative para converter um modelo do PyTorch, siga as etapas na seção Torch Generative converter for PyTorch models.

Conversão de modelos

A API MediaPipe LLM Inference permite executar uma ampla variedade de modelos de linguagem grandes no dispositivo. Isso inclui modelos que foram pré-convertidos para um formato compatível com o MediaPipe, bem como outros modelos que podem ser convertidos com um script de conversão ou a biblioteca AI Edge Torch.

A API LLM Inference aceita modelos nos formatos de arquivo .bin e .task. Os modelos pré-convertidos e convertidos com o script de conversão serão arquivos .bin, enquanto os modelos convertidos com a biblioteca AI Edge Torch serão arquivos .task. Não altere manualmente os formatos de arquivo dos modelos convertidos.

A API de inferência de LLM contém três caminhos de conversão de modelo:

• Modelos pré-convertidos (Gemma 2B, Gemma 7B, Gemma-2 2B): não é necessária conversão.
• Modelos compatíveis (Phi-2, StableLM, Falcon): script de conversão do MediaPipe.
• Outros modelos do PyTorch (todos os modelos LLM do PyTorch): API AI Edge Torch Generative.

Modelos pré-convertidos

Os modelos Gemma-2 2B, Gemma 2B e Gemma 7B estão disponíveis como modelos pré-convertidos no formato MediaPipe. Esses modelos não exigem nenhuma etapa de conversão adicional do usuário e podem ser executados como estão com a API de inferência de LLM.

É possível fazer o download do Gemma-2 2B nos modelos do Kaggle:

• gemma2-2b-it-cpu-int8: modelo Gemma-2 2B de 8 bits com compatibilidade de CPU.
• gemma2-2b-it-gpu-int8: modelo Gemma-2 2B de 8 bits com compatibilidade com GPU.

É possível fazer o download de variantes do Gemma 2B nos modelos do Kaggle:

• gemma-2b-it-cpu-int4: modelo Gemma 2B de 4 bits com compatibilidade de CPU.
• gemma-2b-it-cpu-int8: modelo Gemma 2B de 8 bits com compatibilidade de CPU.
• gemma-2b-it-gpu-int4: modelo Gemma 2B de 4 bits com compatibilidade com GPU.
• gemma-2b-it-gpu-int8: modelo Gemma 2B de 8 bits com compatibilidade com GPU.

É possível fazer o download do Gemma 7B nos modelos do Kaggle:

• gemma-1.1-7b-it-gpu-int8: modelo Gemma 7B de 8 bits com compatibilidade com GPU.

Para mais informações sobre os modelos Gemma, consulte a documentação sobre Gemma-2 2B, Gemma 2B e Gemma 7B.

Script de conversão para modelos compatíveis

O pacote MediaPipe oferece um script de conversão para converter os seguintes modelos externos em um formato compatível com o MediaPipe:

• Falcon 1B
• StableLM 3B
• Phi-2

Para mais informações sobre os modelos externos compatíveis, consulte a documentação sobre Falcon 1B, StableLM 3B e Phi-2.

O processo de conversão do modelo requer o pacote PyPI do MediaPipe. O script de conversão está disponível em todos os pacotes do MediaPipe após 0.10.11.

Instale e importe as dependências com o seguinte:

$ python3 -m pip install mediapipe

Use a biblioteca genai.converter para converter o modelo:

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Para converter o modelo LoRA, o ConversionConfig precisa especificar as opções do modelo base e outras opções LoRA. Como a API só oferece suporte à inferência LoRA com GPU, o back-end precisa ser definido como 'gpu'.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

O conversor vai gerar dois arquivos flatbuffer do TFLite, um para o modelo base e outro para o modelo LoRA.

Conversor generativo do Torch para modelos PyTorch

Os modelos generativos do PyTorch podem ser convertidos em um formato compatível com o MediaPipe com a API AI Edge Torch Generative. É possível usar a API para criar, converter e quantificar LLMs do PyTorch para usar com a API LLM Inference. O conversor generativo do Torch só converte para CPU e requer uma máquina Linux com pelo menos 64 GB de RAM.

A conversão de um modelo PyTorch com a API generativa AI Edge Torch envolve o seguinte:

1. Fazer o download dos checkpoints do modelo PyTorch
2. Use a API AI Edge Torch Generative para criar, converter e quantificar o modelo em um formato de arquivo compatível com o MediaPipe (.tflite).
3. Crie um pacote de tarefas (.task) com base no arquivo tflite e no tokenizador do modelo.

Para criar um pacote de tarefas, use o script de agrupamento para criar um pacote de tarefas. O processo de agrupamento empacota o modelo mapeado com metadados adicionais (por exemplo, Parâmetros do Tokenizer) necessários para executar a inferência de ponta a ponta.

O processo de agrupamento de modelos requer o pacote PyPI do MediaPipe. O script de conversão está disponível em todos os pacotes do MediaPipe após 0.10.14.

Instale e importe as dependências com o seguinte:

$ python3 -m pip install mediapipe

Use a biblioteca genai.bundler para agrupar o modelo:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Personalização da LoRA

O suporte da API de inferência de LLM à LoRA funciona para todas as variantes do Gemma e modelos Phi-2 para o back-end da GPU, com pesos da LoRA aplicáveis apenas a camadas de atenção. Essa implementação inicial serve como uma API experimental para futuros desenvolvimentos com planos de oferecer suporte a mais modelos e vários tipos de camadas nas próximas atualizações.

Preparar modelos LoRA

Siga as instruções no HuggingFace para treinar um modelo LoRA ajustado no seu próprio conjunto de dados com os tipos de modelo compatíveis, Gemma ou Phi-2. Os modelos Gemma-2 2B, Gemma 2B e Phi-2 estão disponíveis no HuggingFace no formato safetensors. Como a API de inferência LLM oferece suporte apenas ao LoRA em camadas de atenção, especifique apenas camadas de atenção ao criar o LoraConfig da seguinte maneira:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Para testes, há modelos LoRA ajustados e acessíveis publicamente que se encaixam na API LLM Inference disponível no HuggingFace. Por exemplo, monsterapi/gemma-2b-lora-maths-orca-200k para Gemma-2B e lole25/phi-2-sft-ultrachat-lora para Phi-2.

Depois de treinar no conjunto de dados preparado e salvar o modelo, você vai receber um arquivo adapter_model.safetensors contendo os pesos do modelo LoRA ajustados. O arquivo safetensors é o ponto de verificação da LoRA usado na conversão do modelo.

Na próxima etapa, você precisa converter os pesos do modelo em um Flatbuffer do TensorFlow Lite usando o pacote MediaPipe Python. O ConversionConfig precisa especificar as opções de modelo básico e outras opções de LoRa. Como a API só oferece suporte à inferência LoRA com GPU, o back-end precisa ser definido como 'gpu'.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

O conversor vai gerar dois arquivos flatbuffer do TFLite, um para o modelo base e outro para o modelo LoRA.

Inferência de modelo LoRA

A API de inferência de LLM da Web, do Android e do iOS foi atualizada para oferecer suporte à inferência de modelos da LoRA.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Para executar a inferência do LLM com o LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo base.