Guia de inferência do LLM

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) completamente no dispositivo, que pode ser usado para executar uma ampla gama de tarefas, gerar texto, recuperar informações na forma de linguagem natural e resumir documentos. A tarefa fornece suporte integrado para vários modelos de linguagem grandes de texto para texto, para que você possa aplicar os modelos mais recentes no dispositivo modelos de IA generativa aos seus apps e produtos.

Faça um teste!arrow_forward

A tarefa é compatível com o Gemma 2B e 7B, parte do uma família de modelos abertos, leves e de última geração, construídos a partir da mesma pesquisa e tecnologia usadas para criar o Gemini de modelos de machine learning. Ele também é compatível com os seguintes modelos externos: Phi-2, Falcon-RW-1B e StableLM-3B.

Além dos modelos com suporte nativo, os usuários podem mapear outros modelos usando a IA Edge do Google ofertas (incluindo mapear modelos PyTorch). Isso permite que os usuários exportem um modelo mapeado para várias assinaturas Modelos do TensorFlow Lite, que vêm com parâmetros de tokenizador para criar um pacote de tarefas.

Começar

Comece a usar esta tarefa seguindo um destes guias de implementação para sua plataforma de destino. Estes guias específicos da plataforma orientam você em um processo implementação dessa tarefa, com exemplos de código que usam um modelo disponível e as opções de configuração recomendadas:

• Web:

  • Guia
  • Código exemplo

• Android:

  • Guia
  • Código exemplo

• iOS

  • Guia
  • Código exemplo

Detalhes da tarefa

Esta seção descreve as capacidades, entradas, saídas e configurações 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 entrada de texto.
2. Seleção de LLM: aplicar vários modelos para personalizar o app de acordo com suas necessidades. casos de uso específicos. Também é possível treinar novamente e aplicar pesos personalizados ao um modelo de machine learning.
3. Suporte à LoRA: amplie e personalize o recurso LLM com o modelo LoRA. seja com o treinamento em todo o conjunto de dados ou com a preparação de um modelo de LoRA da comunidade de código aberto (somente modelos nativos).

Opções de configurações

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

Modelos

A API LLM Inference contém suporte integrado para texto-para-texto grande que pode ser separado de linguagem grandes que são otimizados para serem executados em navegadores e dispositivos móveis. Esses É possível fazer o download de modelos leves para executar inferências totalmente no dispositivo.

Antes de inicializar a API LLM Inference, faça o download de um dos modelos compatíveis e e armazene o arquivo no diretório do projeto.

Gemma 2B

Gemma 2B faz parte de uma família de modelos abertos, leves e de última geração, criados a partir da mesma tecnologia usada para criar os modelos do Gemini. A contém 2 bilhões de parâmetros e pesos abertos. Esse modelo é adequado para variedade de tarefas de geração de texto, incluindo resposta a perguntas, resumo, e raciocínio.

Fazer o download do Gemma 2B

Os modelos Gemma 2B vêm em quatro variantes:

• gemma-2b-it-cpu-int4: Modelo Gemma 2B de 4 bits com compatibilidade com CPU.
• gemma-2b-it-cpu-int8: Modelo Gemma 2B de 8 bits com compatibilidade com 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.

Também é possível ajustar o modelo e adicionar novos pesos antes de adicioná-lo ao app. Para Para mais informações sobre como ajustar e personalizar o Gemma, consulte Ajuste do Gemma. Depois de fazer o download do Gemma em Kaggle Models (em inglês), o modelo já está no formato apropriado para uso com o MediaPipe.

Se você fizer o download do Gemma 2B do Hugging Rosto, você precisa converter o modelo em um formato compatível com o MediaPipe. A API LLM Inference exige que os seguintes arquivos sejam baixados e convertidos:

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

Gemma 7B

O Gemma 7B é um modelo maior do Gemma, com 7B e pesos abertos. O modelo é mais poderoso para uma variedade de textos tarefas de geração de texto, incluindo respostas a perguntas, resumo e raciocínio. O Gemma 7B só é compatível com a Web.

Fazer o download do Gemma 7B

O modelo Gemma 7B vem em uma variante:

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

Se você fizer o download de Gemma 7B do Hugging Face, é preciso converter o modelo para um formato compatível com o MediaPipe. A A API LLM Inference exige que o download e a conversão dos seguintes arquivos sejam feitos:

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

Falcão 1B

O Falcon-1B é um modelo somente decodificador causal com 1 bilhão de parâmetros treinado em 350B tokens de RefinedWeb (link em inglês).

Baixar o Falcon 1B

A API LLM Inference exige que os seguintes arquivos sejam baixados e armazenados localmente:

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

Depois de fazer o download dos arquivos do modelo Falcon, o modelo está pronto para ser convertido em o formato MediaPipe. Siga as etapas em Converter modelo em MediaPipe formato.

StableLM 3B

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

Baixar o StableLM 3B

A API LLM Inference exige que os seguintes arquivos sejam baixados e armazenados localmente:

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

Depois de fazer o download dos arquivos do modelo StableLM, o modelo está pronto para ser convertido para o formato MediaPipe. Siga as etapas em Converter modelo em MediaPipe formato.

Phi-2

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

Faça o download da Phi-2

A API LLM Inference exige que os seguintes arquivos sejam baixados e armazenados localmente:

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

Após o download dos arquivos do modelo Phi-2, o modelo está pronto para ser convertido o formato MediaPipe. Siga as etapas em Converter modelo em MediaPipe formato.

Modelos exportados do AI Edge

AI Edge é uma oferta do Google que permite converter modelos mapeados pelo usuário em modelos do TensorFlow Lite com várias assinaturas. Para mais detalhes sobre mapeamento e para exportar modelos, acesse o AI Edge Torch Página do GitHub.

Depois de exportar o modelo para o formato TFLite, ele estará pronto para ser convertido para o formato MediaPipe. Para mais informações, consulte Converter o modelo para o formato MediaPipe.

Converter modelo para o formato MediaPipe

Conversão de modelo nativo

Se você estiver usando um LLM externo (Phi-2, Falcon ou StableLM) ou um que não seja Kaggle versão do Gemma, use nossos scripts de conversão para formatar o modelo para ser compatível com MediaPipe.

O processo de conversão de modelos requer o pacote MediaPipe PyPI. A conversão o script está disponível em todos os pacotes 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 o modelo base bem como opções adicionais de LoRA. Como a API só tem um 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 gerará dois arquivos TFLite flatbuffer, um para o modelo base e outro para o modelo LoRA.

Conversão de modelo do AI Edge

Se você estiver usando um LLM mapeado para um modelo TFLite pela AI Edge, use nossa de agrupamento para criar um pacote de tarefas. Esse processo empacota os modelo mapeado com outros metadados (por exemplo, parâmetros do tokenizador) necessários para executar inferência completa.

O processo de empacotamento de modelos requer o pacote MediaPipe PyPI. A conversão o script está disponível em todos os pacotes 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 do LoRA

O suporte do LoRA à API LLM Inference funciona com os modelos Gemma-2B e Phi-2 para back-end da GPU, com pesos LoRA aplicáveis apenas às camadas de atenção. Isso implementação inicial serve como uma API experimental para desenvolvimentos futuros e planejamos oferecer suporte a mais modelos e vários tipos de camadas nos próximos atualizações.

Preparar modelos LoRA

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

# For Gemma-2B
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 combinam com a 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ê recebe 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 TensorFlow Lite Flatbuffer usando o pacote MediaPipe Python. O ConversionConfig precisa especificar as opções do modelo base, bem como 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 gerará dois arquivos TFLite flatbuffer, um para o modelo base e outro para o modelo LoRA.

Inferência de modelo LoRA

A API LLM Inference para Web, Android e iOS foi atualizada para oferecer suporte à inferência de modelos LoRA. A Web oferece suporte à LoRA dinâmica, que pode alternar diferentes modelos de LoRA durante o tempo de execução. O Android e o iOS são compatíveis com a LoRA estática, que usa os mesmos pesos da LoRA durante o ciclo de vida da tarefa.

// 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 a LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo base.