Guia de inferência de LLM para iOS

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) totalmente no dispositivo para aplicativos iOS, 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 iOS.

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 compatíveis, os usuários podem usar o AI Edge Torch do Google para exportar modelos PyTorch para modelos LiteRT (tflite) com várias assinaturas, que são agrupados com parâmetros de tokenizer para criar pacotes de tarefas compatíveis com a API Inference LLM.

Confira essa tarefa em ação com a demonstração do MediaPipe Studio. Para mais informações sobre os recursos, modelos e opções de configuração dessa tarefa, consulte a Visão geral.

Exemplo de código

O código de exemplo do MediaPipe Tasks é uma implementação básica de um app da API LLM Inference para iOS. Você pode usar o app como ponto de partida para seu próprio app iOS ou referir-se a ele ao modificar um app existente. O código de exemplo da API LLM Inference está hospedado no GitHub.

Fazer o download do código

As instruções a seguir mostram como criar uma cópia local do código de exemplo usando a ferramenta de linha de comando git.

Para fazer o download do código de exemplo:

1. Clone o repositório do Git usando o seguinte comando:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Opcionalmente, configure sua instância do Git para usar o checkout esparso, para que você tenha apenas os arquivos do app de exemplo da API LLM Inference:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/ios/
   

Depois de criar uma versão local do código de exemplo, é possível instalar a biblioteca de tarefas do MediaPipe, abrir o projeto usando o Xcode e executar o app. Para instruções, consulte o Guia de configuração para iOS.

Configuração

Esta seção descreve as principais etapas para configurar seu ambiente de desenvolvimento e projetos de código para usar a API de inferência de LLM. Para informações gerais sobre como configurar seu ambiente de desenvolvimento para usar tarefas do MediaPipe, incluindo os requisitos de versão da plataforma, consulte o Guia de configuração para iOS.

Dependências

A API de inferência de LLM usa a biblioteca MediaPipeTasksGenai, que precisa ser instalada usando o CocoaPods. A biblioteca é compatível com apps Swift e Objective-C e não requer nenhuma configuração específica da linguagem.

Para instruções sobre como instalar o CocoaPods no macOS, consulte o Guia de instalação do CocoaPods. Para instruções sobre como criar um Podfile com os pods necessários para seu app, consulte Como usar CocoaPods.

Adicione o pod MediaPipeTasksGenai no Podfile usando o seguinte código:

target 'MyLlmInferenceApp' do
  use_frameworks!
  pod 'MediaPipeTasksGenAI'
  pod 'MediaPipeTasksGenAIC'
end

Se o app incluir destinos de teste de unidade, consulte o guia de configuração para iOS para mais informações sobre como configurar o Podfile.

Modelo

A tarefa da API MediaPipe LLM Inference requer um modelo treinado compatível com essa tarefa. Para mais informações sobre os modelos treinados disponíveis para a API LLM Inference, consulte a seção "Modelos" da visão geral da tarefa.

Fazer o download de um modelo

Faça o download de um modelo e adicione-o ao diretório do projeto usando o Xcode. Para instruções sobre como adicionar arquivos ao projeto do Xcode, consulte Gerenciar arquivos e pastas no projeto do Xcode.

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

• Gemma-2 2B: a versão mais recente da família de modelos Gemma. Faz parte de uma família de modelos abertos leves e de última geração criados com a mesma pesquisa e tecnologia usadas para criar os modelos do Gemini.
• Gemma 2B: faz parte de 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. É adequado para várias tarefas de geração de texto, incluindo respostas a perguntas, resumo e raciocínio.
• Phi-2: modelo Transformer de 2, 7 bilhões de parâmetros, mais adequado para o formato de perguntas e respostas, chat e código.
• Falcon-RW-1B: modelo de 1 bilhão de parâmetros somente para decodificador treinado com 350 bilhões de tokens do RefinedWeb.
• StableLM-3B: modelo de linguagem de apenas decodificador de parâmetros de 3 bilhões pré-treinado em 1 trilhão de tokens de diversos conjuntos de dados de inglês e código.

Além dos modelos compatíveis, você pode usar o AI Edge Torch do Google para exportar modelos do PyTorch para modelos LiteRT (tflite) com várias assinaturas. Para mais informações, consulte Conversor generativo do Torch para modelos PyTorch.

Recomendamos usar o Gemma-2 2B, que está disponível nos modelos do Kaggle. Para mais informações sobre os outros modelos disponíveis, consulte a seção "Modelos" da visão geral da tarefa.

Converter o modelo para o formato MediaPipe

A API de inferência de LLM é compatível com dois tipos de modelos de categorias, alguns dos quais exigem conversão de modelos. Use a tabela para identificar o método de etapas necessário para seu modelo.

Os arquivos .bin convertidos para Gemma 2B, Gemma 7B e Gemma-2 2B estão hospedados no Kaggle. Esses modelos podem ser implantados diretamente usando nossa API de inferência de LLM. Para aprender a converter outros modelos, consulte a seção Conversão de modelos.

Criar a tarefa

É possível criar a tarefa da API de inferência de LLM chamando um dos inicializadores dela. O inicializador LlmInference(options:) define valores para as opções de configuração.

Se você não precisar de uma API de inferência de LLM inicializada com opções de configuração personalizadas, use o inicializador LlmInference(modelPath:) para criar uma API de inferência de LLM com as opções padrão. Para mais informações sobre as opções de configuração, consulte Visão geral da configuração.

O código a seguir demonstra como criar e configurar essa tarefa.

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")

let options = LlmInferenceOptions()
options.baseOptions.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101

let llmInference = try LlmInference(options: options)

Opções de configuração

Esta tarefa tem as seguintes opções de configuração para apps iOS:

Preparar dados

A API LLM Inference funciona com dados de texto. A tarefa processa a entrada de dados, incluindo a tokenização e o pré-processamento de tensores.

Todo o pré-processamento é processado na função generateResponse(inputText:). Não é necessário fazer o pré-processamento adicional do texto de entrada.

let inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

Executar a tarefa

Para executar a API de inferência de LLM, use o método generateResponse(inputText:). A API LLM Inference retorna as categorias possíveis para o texto de entrada.

let result = try LlmInference.generateResponse(inputText: inputPrompt)

Para fazer streaming da resposta, use o método generateResponseAsync(inputText:).

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

do {
  for try await partialResult in resultStream {
    print("\(partialResult)")
  }
  print("Done")
}
catch {
  print("Response error: '\(error)")
}

Processar e mostrar resultados

A API de inferência do LLM retorna o texto de resposta gerado.

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

Personalização de modelo 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 de LLMs com um processo de treinamento econômico.

O suporte da API de inferência de LLM à LoRA funciona para todas as variantes do Gemma e modelos Phi-2 para o back-end da GPU, com pesos da LoRA aplicáveis apenas a camadas de atenção. Essa implementação inicial serve como uma API experimental para futuros desenvolvimentos 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 ou Phi-2. Os modelos Gemma-2 2B, Gemma 2B e Phi-2 estão disponíveis no HuggingFace no formato safetensors. Como a API de inferência LLM oferece suporte apenas ao LoRA em camadas de atenção, especifique apenas 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 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 contendo 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 básico 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 da Web, do Android e do iOS foi atualizada para oferecer suporte à inferência de modelos da LoRA.

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")
let loraPath= Bundle.main.path(forResource: "lora_model",
                                      ofType: "bin")
let options = LlmInferenceOptions()
options.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101
options.loraPath = loraPath

let llmInference = try LlmInference(options: options)

Para executar a inferência do LLM com o LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo base.