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. Assim, você pode aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps e produtos.

Teste!arrow_forward

A tarefa oferece suporte integrado a vários LLMs. Os modelos hospedados na página da Comunidade do LiteRT estão disponíveis em um formato compatível com o MediaPipe e não exigem etapas adicionais de conversão ou compilação.

É possível usar o AI Edge Torch para exportar modelos do PyTorch para modelos de LiteRT (tflite) com várias assinaturas, que são empacotados com parâmetros de tokenizer para criar pacotes de tarefas. Os modelos convertidos com a AI Edge Torch são compatíveis com a API LLM Inference e podem ser executados no back-end da CPU, o que os torna adequados para aplicativos Android e iOS.

Começar

Para começar a usar essa tarefa, siga um destes guias de implementação para sua plataforma de destino. 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. Geração de texto para texto: gere 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 Generative AI Edge Torch).

Opções de configuração

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

Modelos

A API de inferência de LLM 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 do repositório LiteRT Community (link em inglês) do HuggingFace ou converter um modelo para um formato compatível com o MediaPipe com o AI Edge Torch Generative Converter (link em inglês).

Se você ainda não tem um LLM para usar com a API LLM Inference, comece com um dos modelos a seguir.

Gemma-3 1B

O Gemma-3 1B é o modelo mais recente da família Gemma de modelos abertos leves e de última geração criados com base na mesma pesquisa e tecnologia usadas para criar os modelos Gemini. O modelo contém 1 bilhão de parâmetros e pesos abertos. A variante 1B é o modelo mais leve da família Gemma, o que a torna ideal para muitos casos de uso no dispositivo.

Faça o download do Gemma-3 1B

O modelo Gemma-3 1B do HuggingFace está disponível no formato .task e pronto para uso com a API LLM Inference para aplicativos da Web e Android.

Ao executar o Gemma-3 1B com a API de inferência LLM, configure as seguintes opções:

• preferredBackend: use essa opção para escolher entre um back-end CPU ou GPU. Essa opção está disponível apenas para Android.
• supportedLoraRanks: a API de inferência de LLM não pode ser configurada para oferecer suporte à adaptação de baixa classificação (LoRA, na sigla em inglês) com o modelo Gemma-3 1B. Não use as opções supportedLoraRanks ou loraRanks.
• maxTokens: o valor de maxTokens precisa corresponder ao tamanho do contexto incorporado ao modelo. Isso também pode ser chamado de cache de chave-valor (KV, na sigla em inglês) ou comprimento de contexto.
• numResponses: precisa ser sempre 1. Essa opção está disponível apenas para a Web.

Ao executar o Gemma-3 1B em aplicativos da Web, a inicialização pode causar um longo bloqueio na linha de execução atual. Se possível, sempre execute o modelo em uma linha de execução de worker.

Gemma-2 2B

O Gemma-2 2B é uma variante de 2B do Gemma-2 e funciona em todas as plataformas.

Faça o download do Gemma-2 2B

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.

Conversão de 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 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 da AI Edge Torch (link em inglês).

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

1. Faça 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 tokenizer do modelo.

O conversor generativo Torch converte apenas para CPU e requer uma máquina Linux com pelo menos 64 GB de RAM.

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 de 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 de inferência de LLM 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 modelo 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 de LLM com o LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo base.