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. Assim, você pode aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps iOS.

Para adicionar rapidamente a API LLM Inference ao seu aplicativo iOS, siga o Início rápido. Para conferir um exemplo básico de um aplicativo iOS que executa a API LLM Inference, consulte o aplicativo de exemplo. Para entender melhor como a API LLM Inference funciona, consulte as seções opções de configuração, conversão de modelos e ajuste de LoRA.

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.

Guia de início rápido

Siga as etapas abaixo para adicionar a API LLM Inference ao seu app iOS. 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.

Adicionar dependências

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.

Fazer o download de um modelo

Faça o download do Gemma-2 2B em um formato quantizado de 8 bits em Modelos Kaggle. Para mais informações sobre os modelos disponíveis, consulte a documentação de modelos.

Adicione o modelo 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.

Inicializar a tarefa

Inicialize a tarefa com opções de configuração básicas:

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)

Executar a tarefa

Use o método generateResponse(inputText:) para gerar uma resposta de texto. Isso produz uma única resposta gerada.

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)")
}

Exemplo de aplicativo

O aplicativo de exemplo é um exemplo de app básico de geração de texto para iOS, usando a API de inferência de LLM. Você pode usar o app como ponto de partida para seu próprio app iOS ou se referir a ele ao modificar um app existente. O código de exemplo está hospedado no GitHub.

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

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

Depois de criar uma versão local do código de exemplo, você pode importar o projeto para o iOS Studio e executar o app. Para mais informações, consulte o Guia de configuração para iOS.

Opções de configuração

Use as opções de configuração a seguir para configurar um app iOS:

Conversão de modelos

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

Para saber como converter outros modelos, consulte a seção Conversão de modelos.

Personalização da LoRA

A API Inference LLM oferece suporte ao ajuste da LoRA (adaptação de classificação baixa) usando a biblioteca PEFT (ajuste fino de eficiência de parâmetros). O ajuste do LoRA personaliza o comportamento dos LLMs por meio de um processo de treinamento econômico, criando um pequeno conjunto de pesos treináveis com base em novos dados de treinamento em vez de treinar o modelo inteiro novamente.

A API de inferência LLM oferece suporte à adição de pesos de LoRA às camadas de atenção dos modelos Gemma-2 2B, Gemma 2B e Phi-2. Faça o download do modelo no formato safetensors.

O modelo base precisa estar no formato safetensors para criar pesos de LoRA. Após o treinamento do LoRA, você pode converter os modelos no formato FlatBuffers para execução no MediaPipe.

Preparar pesos da LoRA

Use o guia Métodos LoRA do PEFT para treinar um modelo LoRA ajustado no seu conjunto de dados.

A API de inferência de LLM só oferece suporte a LoRA em camadas de atenção. Portanto, especifique apenas as camadas de atenção em LoraConfig:

# 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"],
)

Depois de treinar no conjunto de dados preparado e salvar o modelo, os pesos do modelo LoRA ajustados estarão disponíveis em adapter_model.safetensors. O arquivo safetensors é o ponto de verificação do LoRA usado durante a conversão do modelo.

Conversão de modelos

Use o pacote MediaPipe Python para converter os pesos do modelo no formato Flatbuffer. O ConversionConfig especifica as opções de modelo básico e as opções adicionais do LoRA.

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_FILE,
)

converter.convert_checkpoint(config)

O conversor vai produzir dois arquivos Flatbuffer, um para o modelo base e outro para o modelo LoRA.

Inferência de modelo LoRA

O iOS oferece suporte a LoRA estático durante a inicialização. Para carregar um modelo LoRA, especifique o caminho do modelo LoRA e o LLM base.

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