Guia de inferência do LLM

Com a API LLM Inference, é possível executar modelos de linguagem grandes (LLMs) completamente no dispositivo. Isso permite 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. Assim, você pode aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps e produtos.

Faça um teste!arrow_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.

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

Comece a usar essa tarefa seguindo um destes guias de implementação para sua plataforma de destino. Esses guias específicos da plataforma mostram 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 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 de acordo com seus casos de uso específicos. Também é possível treinar novamente e aplicar ponderações personalizadas ao modelo.
3. Suporte ao LoRA: estenda e personalize a capacidade do LLM com o modelo LoRA treinando em todo o conjunto de dados ou usando modelos LoRA pré-criados preparados da comunidade de código aberto (não compatível com modelos convertidos com a API Generativa do AI Edge Torch).

Opções de configuração

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

Modelos

A API LLM Inference é compatível com muitos modelos de linguagem grandes de texto para texto, incluindo suporte integrado para 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 do HuggingFace ou converter um modelo para um formato compatível com o MediaPipe usando o AI Edge Torch Generative Converter.

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

Gemma-3n

O Gemma-3n E2B e E4B são os modelos mais recentes 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 do Gemini. Os modelos Gemma 3n foram projetados para execução eficiente em dispositivos com poucos recursos. Eles são capazes de entrada multimodal, processando entradas de texto, imagem e áudio e gerando saídas de texto.

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

Baixar o Gemma-3n E2B

Fazer o download do Gemma-3n E4B

Os modelos Gemma-3n E2B e E4B da 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 modelos do Gemini. O modelo contém 1 bilhão de parâmetros e pesos abertos.

Fazer o download do Gemma-3 1B

O modelo Gemma-3 1B da 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:

• 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 baixa classificação (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 comprimento 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 trabalho.

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 tem 2 bilhões de 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 modelos do PyTorch

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

Converter um modelo do PyTorch com a API AI Edge Torch Generative 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 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ó faz conversões 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 pacotes para criar um pacote de tarefas. O processo de agrupamento 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 agrupamento de modelos requer 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 API LLM Inference para LoRA funciona com todas as variantes do Gemma e modelos Phi-2 para o back-end de GPU, com pesos de 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 refinado no seu próprio conjunto de dados com tipos de modelos compatíveis, como Gemma ou Phi-2. Os modelos Gemma-2 2B, Gemma 2B e Phi-2 estão disponíveis no Hugging Face no formato safetensors. Como a API LLM Inference só aceita LoRA em camadas de atenção, especifique apenas essas camadas 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 acessíveis publicamente que se encaixam na API LLM Inference disponível no HuggingFace. Por exemplo, monsterapi/gemma-2b-lora-maths-orca-200k para o Gemma-2B e lole25/phi-2-sft-ultrachat-lora para o Phi-2.

Depois de treinar com o conjunto de dados preparado e salvar o modelo, você vai receber um arquivo adapter_model.safetensors com os pesos do modelo LoRA refinado. 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 de modelo de base e outras opções de LoRA. Como a API só é compatível com a 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 de base e outro para o modelo LoRA.

Inferência de modelo LoRA

As APIs Web, Android e iOS LLM Inference foram atualizadas para oferecer suporte à inferência do 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 de base.