Guia de inferência do LLM

⚠️ Importante: atualização da API LLM Inference

As implementações da API LLM Inference para Android e iOS foram descontinuadas. A Web NÃO foi descontinuada

---

Migre seus projetos para dispositivos móveis para o LiteRT-LM e garanta suporte e desempenho contínuos.

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) totalmente no dispositivo, que podem ser usados para realizar uma ampla variedade 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.

Faça um testearrow_forward

A tarefa oferece suporte integrado a vários LLMs. Os modelos hospedados na página da comunidade 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.

Você pode usar LiteRT Torch para exportar modelos do PyTorch para modelos LiteRT de várias assinaturas (tflite), que são agrupados com parâmetros de tokenizador para criar pacotes de tarefas. Os modelos convertidos com o LiteRT 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

Comece a usar essa tarefa seguindo um destes guias de implementação para sua plataforma segmentada. Esses guias específicos da plataforma 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, as entradas, as saídas e as opções de configuração dessa 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 a 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 generativa do LiteRT Torch).

Opções de configuração

Essa 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 totalmente 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. Você pode usar um modelo pré-convertido do repositório HuggingFace da comunidade LiteRT ou converter um modelo para um formato compatível com o MediaPipe usando o conversor generativo do AI Edge Torch.

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

Gemma-3n

O Gemma-3n E2B e o E4B são os modelos mais recentes da família Gemma de modelos abertos, leves, de última geração, criados com a mesma pesquisa e tecnologia usadas para criar os Gemini modelos. Os modelos Gemma 3n são projetados para execução eficiente em dispositivos com poucos recursos. Eles são capazes de entrada multimodal, processando texto, imagem e áudio, e gerando saídas de texto.

Os modelos Gemma 3n usam a tecnologia de ativação de parâmetros seletivos para reduzir os requisitos de recursos. Essa técnica permite que os modelos operem em um tamanho efetivo de 2B e 4B parâmetros, que é menor que o número total de parâmetros que eles contêm.

Fazer o download do Gemma-3n E2B

Fazer o download do Gemma-3n E4B

Os modelos Gemma-3n E2B e E4B do HuggingFace estão disponíveis no formato .litertlm e prontos para uso com a API LLM Inference para Android e Web.

Gemma-3 1B

O Gemma-3 1B é o modelo mais leve da família Gemma de modelos abertos, leves e de última geração, criados com a mesma pesquisa e tecnologia usadas para criar os Gemini. O modelo contém 1B parâmetros e pesos abertos.

Fazer o download do Gemma-3 1B

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

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

• 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 LLM Inference não pode ser configurada para oferecer suporte à adaptação de classificação baixa (LoRA) 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 integrado ao modelo. Isso também pode ser chamado de cache de chave-valor (KV) ou tamanho do 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 bloqueio longo 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.

Fazer o download do Gemma-2 2B

O modelo contém 2B parâmetros e pesos abertos. O Gemma-2 2B é conhecido por habilidades de raciocínio de última geração para modelos da classe dele.

Conversão de modelo do PyTorch

Os modelos generativos do PyTorch podem ser convertidos para um formato compatível com o MediaPipe usando a API generativa do LiteRT Torch. Você pode usar a API para converter modelos do PyTorch em modelos LiteRT (TensorFlow Lite) de várias assinaturas. Para mais detalhes sobre como mapear e exportar modelos, acesse a página do LiteRT Torch GitHub page.

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

1. Faça o download dos checkpoints do modelo do PyTorch.
2. Use a API generativa do LiteRT Torch para criar, converter e quantizar o modelo em um formato de arquivo compatível com o MediaPipe (.tflite).
3. Crie um pacote de tarefas (.task/.litertlm) com o arquivo tflite e o tokenizador do modelo.

O conversor generativo do Torch só converte para CPU e exige uma máquina Linux com pelo menos 64 GB de RAM.

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

O processo de pacote de modelos exige o pacote MediaPipe PyPI. 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 LoRA da API LLM Inference funciona para todas as variantes do Gemma e modelos Phi-2 para o back-end da GPU, com pesos LoRA aplicáveis apenas às camadas de atenção. Essa implementação inicial serve como uma API experimental para desenvolvimentos futuros 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 tipos de modelo compatíveis, Gemma ou Phi-2. Os modelos Gemma 2B, Phi-2 e Gemma-2 2B estão disponíveis no HuggingFace no formato safetensors. Como a API LLM Inference só oferece suporte à LoRA em camadas de atenção, especifique apenas as 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 publicamente acessíveis que se ajustam à 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 ajustado. O arquivo safetensors é o checkpoint 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 Python do MediaPipe. O ConversionConfig precisa especificar as opções do modelo base e outras opções da LoRA. Observe que como a API só oferece suporte à inferência da 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

As APIs LLM Inference para Web, Android e iOS foram atualizadas 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 LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo base.