A API LLM Inference permite executar modelos de linguagem grandes (LLMs) totalmente no dispositivo. Eles podem ser usados para realizar várias tarefas, como gerar texto, extrair informações em formato de linguagem natural e resumir documentos. A tarefa oferece suporte integrado a vários modelos de linguagem grande de texto para texto para que você possa aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps e produtos.
A tarefa oferece suporte à Gemma 2B e 7B, parte de uma família de modelos abertos leves e de última geração criados a partir da mesma pesquisa e tecnologia usada para criar os modelos Gemini. Ele também oferece suporte aos 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 as ofertas do AI Edge do Google (incluindo mapeamento de modelos PyTorch). Isso permite que os usuários exportem um modelo mapeado para modelos do TensorFlow Lite de várias assinaturas, que vêm com parâmetros do tokenizador para criar um pacote de tarefas.
Comece já
Comece a usar essa tarefa seguindo um destes guias de implementação para sua plataforma de destino. Estes 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:
Android:
iOS
Detalhes da tarefa
Nesta seção, descrevemos os recursos, as entradas, as saídas e as opções de configuração desta tarefa.
Recursos
A API LLM Inference contém os seguintes recursos principais:
- Geração de texto para texto: gera texto com base em um comando de entrada de texto.
- Seleção de LLM: aplique vários modelos para adaptar o app aos casos de uso específicos. Também é possível treinar novamente e aplicar pesos personalizados ao modelo.
- Suporte à LoRA: amplie e personalize o recurso do LLM com o modelo LoRA treinando em todo o conjunto de dados ou usando modelos pré-criados da comunidade de código aberto (somente modelos nativos).
Entradas de tarefas | Saídas de tarefas |
---|---|
A API LLM Inference aceita as seguintes entradas:
|
A API LLM Inference gera os seguintes resultados:
|
Opções de configuração
Essa tarefa tem as seguintes opções de configuração:
Nome da opção | Descrição | Intervalo de valor | Valor padrão |
---|---|---|---|
modelPath |
O caminho para onde o modelo está armazenado no diretório do projeto. | PATH | N/A |
maxTokens |
O número máximo de tokens (de entrada + saída) que o modelo gerencia. | Número inteiro | 512 |
topK |
O número de tokens que o modelo considera em cada etapa da geração.
Limita as previsões aos k principais tokens mais prováveis. Ao definir topK , você também precisa definir um valor para randomSeed . |
Número inteiro | 40 |
temperature |
A quantidade de aleatoriedade gerada durante a geração. Uma temperatura
mais alta resulta em mais criatividade no texto gerado, enquanto uma
temperatura mais baixa produz uma geração mais previsível. Ao definir temperature , você também precisa definir um valor para randomSeed . |
Ponto flutuante | 0,8 |
randomSeed |
A semente aleatória usada durante a geração de texto. | Número inteiro | 0 |
loraPath |
O caminho absoluto para o modelo LoRA localmente no dispositivo. Observação: isso só é compatível com modelos de GPU. | PATH | N/A |
resultListener |
Define o listener de resultado para receber os resultados de forma assíncrona. Aplicável somente ao usar o método de geração assíncrona. | N/A | N/A |
errorListener |
Define um listener de erro opcional. | N/A | N/A |
Modelos
A API LLM Inference contém suporte integrado para modelos de linguagem grandes de texto para texto que são otimizados para execução em navegadores e dispositivos móveis. É possível fazer o download desses 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 armazene o arquivo no diretório do projeto.
Gemma 2B
A Gemma 2B faz parte de uma família de modelos abertos leves e de última geração criados a partir da 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 respostas a perguntas, resumo e raciocínio.
Os modelos Gemma 2B têm 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 mais informações sobre como ajustar e personalizar o Gemma, consulte Ajustar Gemma. Depois de fazer o download do Gemma dos modelos Kaggle, o modelo já estará no formato apropriado para uso com o MediaPipe.
Se você fizer o download da Gemma 2B de Hugging Face, será necessário converter o modelo em um formato compatível com MediaPipe. A API LLM Inference exige o download e a conversão dos seguintes arquivos:
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors
tokenizer.json
tokenizer_config.json
Gemma 7B
O Gemma 7B é um modelo maior, com 7B parâmetros e pesos abertos. O modelo é mais eficiente para várias tarefas de geração de texto, incluindo respostas a perguntas, resumo e raciocínio. O Gemma 7B só é compatível com a Web.
O modelo Gemma 7B tem uma variante:
- gemma-1.1-7b-it-gpu-int8: modelo Gemma 7B de 8 bits com compatibilidade com GPU.
Se você fizer o download da Gemma 7B do Hugging Face, será necessário converter o modelo em um formato compatível com o MediaPipe. A API LLM Inference exige o download e a conversão dos seguintes arquivos:
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
Falcon 1B
O Falcon-1B é um modelo somente decodificador causal de 1 bilhão de parâmetros treinado em 350 bilhões de tokens do RefinedWeb (em inglês).
A API LLM Inference exige o download e o armazenamento local dos seguintes arquivos:
tokenizer.json
tokenizer_config.json
pytorch_model.bin
Depois de fazer o download dos arquivos do modelo Falcon, o modelo estará pronto para ser convertido para o formato MediaPipe. Siga as etapas em Converter modelo para o formato MediaPipe.
StableLM 3B
O StableLM-3B é um modelo de linguagem com 3 bilhões de decodificadores de parâmetros pré-treinado em 1 trilhão de tokens de diversos conjuntos de dados em inglês e de código para 4 épocas.
Faça o download do StableLM 3B
A API LLM Inference exige o download e o armazenamento local dos seguintes arquivos:
tokenizer.json
tokenizer_config.json
model.safetensors
Depois de fazer o download dos arquivos do modelo StableLM, o modelo estará pronto para ser convertido para o formato MediaPipe. Siga as etapas em Converter modelo para o formato MediaPipe.
Phi-2
A 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 com perguntas-resposta, chat e código.
A API LLM Inference exige o download e o armazenamento local dos seguintes arquivos:
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, o modelo estará pronto para ser convertido para o formato MediaPipe. Siga as etapas em Converter modelo para o formato MediaPipe.
Modelos exportados da AI Edge
O AI Edge é uma oferta do Google que permite converter modelos mapeados pelo usuário em modelos de várias assinaturas do TensorFlow Lite. Para mais detalhes sobre como mapear e exportar modelos, acesse a página do AI Edge Torch no GitHub (em inglês).
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 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 uma versão do Gemma que não seja Kaggle, utilize nossos scripts de conversão para formatar o modelo para que seja compatível com o MediaPipe.
O processo de conversão de modelo requer o pacote MediaPipe PyPI. 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 código:
$ 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,
bem como outras opções da LoRA. Como a API só
oferece suporte à inferência de 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 de flatbuffer TFLite, um para o modelo base e outro para o modelo LoRA.
Parâmetro | Descrição | Valores aceitos |
---|---|---|
input_ckpt |
O caminho para o arquivo model.safetensors ou pytorch.bin . Às vezes, o formato dos safetensor do modelo é fragmentado em vários arquivos, por exemplo, model-00001-of-00003.safetensors e model-00001-of-00003.safetensors . É possível especificar um padrão de arquivo, como model*.safetensors . |
PATH |
ckpt_format |
O formato de arquivo do modelo. | {"safetensors", "pytorch"} |
model_type |
O LLM sendo convertido. | {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"} |
backend |
O processador (delegado) usado para executar o modelo. | {"cpu", "gpu"} |
output_dir |
O caminho para o diretório de saída que hospeda os arquivos de peso por camada. | PATH |
output_tflite_file |
O caminho para o arquivo de saída. Por exemplo, "model_cpu.bin" ou "model_gpu.bin". Esse arquivo é compatível apenas com a API LLM Inference e não pode ser usado como um arquivo "tflite" geral. | PATH |
vocab_model_file |
O caminho para o diretório que armazena os arquivos tokenizer.json e
tokenizer_config.json . Para o Gemma, aponte para o único arquivo tokenizer.model . |
PATH |
lora_ckpt |
O caminho para o arquivo de safetensors da LoRA que armazena o peso do adaptador da LoRA. | PATH |
lora_rank |
Um número inteiro que representa a classificação de ckpt da LoRA. Obrigatório para converter os pesos lora. Se esse valor não for informado, o conversor vai presumir que não há pesos da LoRA. Observação: apenas o back-end da GPU é compatível com LoRA. | Número inteiro |
lora_output_tflite_file |
Nome de arquivo tflite de saída para os pesos da LoRA. | PATH |
Conversão de modelo do AI Edge
Se você estiver usando um LLM mapeado para um modelo do TFLite pelo AI Edge, use nosso script de agrupamento para criar um pacote de tarefas. O processo de agrupamento empacota o modelo mapeado com outros metadados (por exemplo, tokenizadores) necessários para executar a inferência completa.
O processo de empacotamento de modelos exige 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 código:
$ 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)
Parâmetro | Descrição | Valores aceitos |
---|---|---|
tflite_model |
O caminho para o modelo do TFLite exportado pelo AI Edge. | PATH |
tokenizer_model |
O caminho para o modelo do tokenizador do SentencePiece. | PATH |
start_token |
Token inicial específico do modelo. O token inicial precisa estar presente no modelo do tokenizador fornecido. | STRING |
stop_tokens |
Tokens de parada específicos do modelo. Os tokens de parada precisam estar presentes no modelo do tokenizador fornecido. | LISTA[STRING] |
output_filename |
O nome do arquivo do pacote de tarefas de saída. | PATH |
Personalização da LoRA
A API de inferência LLM da Mediapipe pode ser configurada para oferecer suporte à adaptação de baixa classificação (LoRA, na sigla em inglês) para modelos de linguagem grandes. Utilizando modelos LoRA ajustados, os desenvolvedores podem personalizar o comportamento dos LLMs com um processo de treinamento econômico.O suporte da LoRA à API LLM Inference funciona com modelos Gemma-2B e Phi-2 para o back-end da GPU, com pesos de LoRA aplicáveis apenas a 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 em HuggingFace para treinar um modelo LoRA ajustado no seu próprio conjunto de dados com tipos de modelo compatíveis, Gemma-2B ou Phi-2. Os modelos Gemma-2B e Phi-2 estão disponíveis no HuggingFace no formato safetensor. Como a API LLM Inference só oferece suporte a LoRA em camadas de atenção, especifique apenas elas ao criar a 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 publicamente acessíveis 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ê recebe um arquivo adapter_model.safetensors
contendo os pesos do modelo LoRA ajustado. O arquivo safetensors é o checkpoint da LoRA usado na conversão do modelo.
Na próxima etapa, você vai precisar converter os pesos do modelo em um Flatbuffer do TensorFlow Lite usando o pacote MediaPipe Python. O ConversionConfig
precisa especificar as opções do modelo base e outras opções da LoRA. Como a API só oferece suporte à inferência LoRA com a 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 de flatbuffer TFLite, 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 modelo LoRA. A Web oferece suporte à LoRA dinâmica, que pode alternar diferentes modelos 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.
O Android oferece suporte à LoRA estática durante a inicialização. Para carregar um modelo LoRA, os usuários especificam o caminho do modelo LoRA e o LLM base.// 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 LLM com o LoRA, use os mesmos métodos generateResponse()
ou generateResponseAsync()
que o modelo base.