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, para que você possa aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps e produtos.
A tarefa é compatível com as seguintes variantes do Gemma: Gemma 2 2B, Gemma 2B e Gemma 7B. O Gemma é uma família de modelos abertos leves e de última geração criados com base na mesma pesquisa e tecnologia usadas para criar os modelos do 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 com várias assinaturas, que são agrupados com parâmetros do tokenizer para criar um pacote de tarefas.
Começar
Para começar a usar essa tarefa, siga um destes guias de implementação para sua plataforma. 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:
Android:
iOS
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:
- Text-to-text generation: gera texto com base em um comando de texto de entrada.
- 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.
- 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 (somente modelos nativos).
Entradas da tarefa | Saídas de tarefas |
---|---|
A API LLM Inference aceita as seguintes entradas:
|
A API de inferência de LLM gera os seguintes resultados:
|
Opções de configurações
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 é armazenado no diretório do projeto. | CAMINHO | N/A |
maxTokens |
O número máximo de tokens (tokens de entrada + tokens de saída) que o modelo processa. | Número inteiro | 512 |
topK |
O número de tokens que o modelo considera em cada etapa de geração. Limita as previsões aos tokens mais prováveis do Top-K. | Número inteiro | 40 |
temperature |
A quantidade de aleatoriedade introduzida 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. | Ponto flutuante | 0,8 |
randomSeed |
A sugestão aleatória usada durante a geração do 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. | CAMINHO | N/A |
resultListener |
Define o listener de resultados para receber os resultados de forma assíncrona. Aplicável apenas 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 vários modelos de linguagem grande de texto para texto 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 com suporte e armazene o arquivo no diretório do projeto.
Gemma-2 2B
O Gemma-2 2B é o modelo mais recente 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 Gemini. O modelo tem 2 bilhões de parâmetros e pesos abertos. A Gemma-2 2B é conhecida por habilidades de raciocínio de última geração para modelos da classe.
Fazer o download do Gemma-2 2B
Os modelos Gemma-2 2B estão disponíveis nas seguintes variantes:
- gemma2-2b-it-cpu-int8: modelo Gemma-2 2B de 8 bits com compatibilidade de CPU.
- gemma2-2b-it-gpu-int8: modelo Gemma-2 2B de 8 bits com compatibilidade com GPU.
Você também pode 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 o Gemma. Depois de fazer o download do Gemma no Kaggle Models, o modelo já está no formato adequado para uso com o MediaPipe Tasks.
Gemma 2B
O Gemma 2B faz parte de uma família de modelos abertos leves e de última geração, criados com a mesma pesquisa e tecnologia que foi usada 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 resposta a perguntas, resumo e raciocínio.
Os modelos Gemma 2B estão disponíveis nas seguintes 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 de 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.
Você também pode 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 o Gemma. Depois de fazer o download do Gemma nos modelos do Kaggle, o modelo já está no formato adequado para uso com as tarefas do MediaPipe.
Gemma 7B
O Gemma 7B é um modelo maior do Gemma com 7B parâmetros e pesos abertos. O modelo é mais eficiente para uma variedade de tarefas de geração de texto, incluindo resposta a perguntas, resumo e raciocínio. O Gemma 7B tem suporte apenas na 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.
Depois de fazer o download do Gemma nos modelos do Kaggle, o modelo já está no formato adequado para uso com o MediaPipe.
Falcão 1B
O Falcon-1B é um modelo de decodificador causal de 1 bilhão de parâmetros treinado em 350 bilhões de tokens do RefinedWeb.
A API de inferência de LLM exige que os seguintes arquivos sejam transferidos por download e armazenados localmente:
tokenizer.json
tokenizer_config.json
pytorch_model.bin
Depois de fazer o download dos arquivos do modelo Falcon, ele estará pronto para ser convertido para o formato MediaPipe. Siga as etapas em Converter o modelo para o formato MediaPipe.
StableLM 3B
O StableLM-3B é um modelo de linguagem somente decodificador de 3 bilhões de parâmetros pré-treinado em 1 trilhão de tokens de diversos conjuntos de dados de inglês e código por 4 épocas.
Fazer o download do StableLM 3B
A API LLM Inference exige que os arquivos abaixo sejam transferidos por download e armazenados localmente:
tokenizer.json
tokenizer_config.json
model.safetensors
Depois de fazer o download dos arquivos do modelo StableLM, ele fica pronto para ser convertido para o formato MediaPipe. Siga as etapas em Converter o modelo para o formato MediaPipe.
Phi-2
O Phi-2 é um modelo de transformador de 2,7 bilhões de parâmetros. Ele foi treinado usando vários textos sintéticos de PNL e sites filtrados. O modelo é mais adequado para comandos que usam o formato de perguntas e respostas, chat e código.
A API de inferência de LLM exige que os seguintes arquivos sejam transferidos por download e armazenados localmente:
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 do AI Edge
O 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 exportação de modelos, acesse a página do GitHub (em inglês) do AI Edge Torch.
Depois de exportar o modelo para o formato TFLite, ele fica pronto para ser convertido para o formato MediaPipe. Para mais informações, consulte Converter modelo para o formato MediaPipe.
Converter o 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 do Kaggle, use nossos scripts de conversão para formatar o modelo para que ele seja compatível com o MediaPipe.
O processo de conversão de modelos requer o pacote MediaPipe PyPI. O script
de conversão 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 as opções do modelo base e outras opções LoRA. Como a API só é compatível com 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.
Parâmetro | Descrição | Valores aceitos |
---|---|---|
input_ckpt |
O caminho para o arquivo model.safetensors ou pytorch.bin . Às vezes, o formato de safetensors do modelo é dividido em vários arquivos, por exemplo, model-00001-of-00003.safetensors , model-00001-of-00003.safetensors . É possível especificar um padrão de arquivo, como model*.safetensors . |
CAMINHO |
ckpt_format |
O formato do arquivo do modelo. | {"safetensors", "pytorch"} |
model_type |
O LLM que está sendo convertido. | {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B", "GEMMA_7B", "GEMMA-2_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. | CAMINHO |
output_tflite_file |
O caminho para o arquivo de saída. Por exemplo, "model_cpu.bin" ou "model_gpu.bin". Esse arquivo só é compatível com a API LLM Inference e não pode ser usado como um arquivo "tflite" geral. | CAMINHO |
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 . |
CAMINHO |
lora_ckpt |
O caminho para o arquivo de safetensors do LoRA ckpt que armazena o peso do adaptador LoRA. | CAMINHO |
lora_rank |
Um número inteiro que representa a classificação do ckpt do LoRA. É necessário para converter os pesos de lora. Se não forem fornecidos, o conversor vai presumir que não há pesos de LoRA. Observação: somente o back-end da GPU é compatível com o LoRA. | Número inteiro |
lora_output_tflite_file |
Nome do arquivo tflite de saída dos pesos LoRA. | CAMINHO |
Conversão de modelos de IA do Edge
Se você estiver usando um LLM mapeado para um modelo TFLite pelo AI Edge, use nosso 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)
Parâmetro | Descrição | Valores aceitos |
---|---|---|
tflite_model |
O caminho para o modelo TFLite exportado do AI Edge. | CAMINHO |
tokenizer_model |
O caminho para o modelo de tokenização do SentencePiece. | CAMINHO |
start_token |
Token de início específico do modelo. O token de início precisa estar presente no modelo de tokenizer fornecido. | STRING |
stop_tokens |
Modelo de tokens de parada específicos. Os tokens de parada precisam estar presentes no modelo de tokenizador fornecido. | LIST[STRING] |
output_filename |
O nome do arquivo de pacote de tarefas de saída. | CAMINHO |
Personalização da LoRA
A API de inferência de LLM do Mediapipe pode ser configurada para oferecer suporte à adaptação de baixa classificação (LoRA) para modelos de linguagem grandes. Usando modelos LoRA ajustados, os desenvolvedores podem personalizar o comportamento dos LLMs com um processo de treinamento econômico.O suporte da API de inferência de LLM para LoRA funciona com os 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 no HuggingFace para treinar um modelo LoRA ajustado no seu próprio conjunto de dados com os 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 de seguros. Como a API de inferência LLM só oferece suporte ao LoRA em camadas de atenção, especifique apenas camadas de atenção 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 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ê vai receber um arquivo adapter_model.safetensors
com 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 base 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 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 oferecem suporte à LoRA estática, que usa os mesmos pesos da LoRA durante a duração da tarefa.
O Android oferece suporte a LoRA estático durante a inicialização. Para carregar um modelo LoRA, os usuários especificam o caminho desse modelo, bem como o LLM básico.// 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.