Guia de inferência de LLM para iOS

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) completamente no dispositivo para aplicativos iOS, que podem ser usados para realizar uma ampla variedade 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.

Para adicionar rapidamente a API LLM Inference ao seu aplicativo iOS, siga o guia de início rápido. Para 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 modelo 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 estas etapas para adicionar a API LLM Inference ao seu aplicativo iOS. A API LLM Inference usa a biblioteca MediaPipeTasksGenai, que precisa ser instalada com o CocoaPods. A biblioteca é compatível com apps Swift e Objective-C e não exige nenhuma configuração adicional específica da linguagem.

Para instruções de instalação do 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 Usar CocoaPods.

Adicionar dependências

Adicione o pod MediaPipeTasksGenai ao 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 seu Podfile.

Fazer o download de um modelo

Faça o download do Gemma-2 2B em um formato quantizado de 8 bits nos Modelos do 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 gera uma única resposta.

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 LLM Inference. Você pode usar o app como ponto de partida para seu próprio app iOS ou consultá-lo ao modificar um app existente. O código de exemplo está hospedado no GitHub.

Clone o repositório git usando o comando a seguir:

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

Depois de criar uma versão local do código de exemplo, importe o projeto para o iOS Studio e execute o app. Para mais informações, consulte o guia de configuração para iOS.

Opções de configuração

Use as seguintes opções de configuração 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. Use a tabela para identificar as etapas e o método necessários para seu modelo.

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

Personalização da LoRA

A API LLM Inference oferece suporte ao ajuste de LoRA (Low-Rank Adaptation) usando a biblioteca PEFT (Parameter-Efficient Fine-Tuning). O ajuste do LoRA personaliza o comportamento dos LLMs com 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 todo o modelo novamente.

A API LLM Inference permite adicionar 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 de base precisa estar no formato safetensors para criar ponderações de LoRA. Depois do treinamento do LoRA, é possível converter os modelos para o formato FlatBuffers e executá-los no MediaPipe.

Preparar ponderações da LoRA

Use o guia Métodos LoRA da PEFT para treinar um modelo LoRA refinado no seu próprio conjunto de dados.

A API LLM Inference 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 refinado estarão disponíveis em adapter_model.safetensors. O arquivo safetensors é o checkpoint do LoRA usado durante a conversão do modelo.

Conversão de modelos

Use o pacote Python do MediaPipe para converter os pesos do modelo no formato Flatbuffer. O ConversionConfig especifica as opções de modelo de base e as opções adicionais de 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 de base e outro para o modelo LoRA.

Inferência de modelo LoRA

O iOS oferece suporte a LoRA estática durante a inicialização. Para carregar um modelo LoRA, especifique o caminho do modelo LoRA e o LLM de 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 LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo de base.