Guida all'inferenza LLM per iOS

L'API LLM Inference ti consente di eseguire modelli linguistici di grandi dimensioni (LLM) completamente sul dispositivo per le applicazioni iOS, che puoi utilizzare per eseguire un'ampia gamma di attività, come generare testo, recuperare informazioni in linguaggio naturale e riassumere documenti. L'attività fornisce supporto integrato per più modelli linguistici di grandi dimensioni text-to-text, in modo da poter applicare i più recenti modelli di AI generativa on-device alle tue app per iOS.

Per aggiungere rapidamente l'API LLM Inference alla tua applicazione iOS, segui la Guida rapida. Per un esempio di base di un'applicazione iOS che esegue l'API LLM Inference, consulta l'applicazione di esempio. Per una comprensione più approfondita del funzionamento dell'API LLM Inference, consulta le sezioni Opzioni di configurazione, Conversione del modello e Ottimizzazione LoRA.

Puoi vedere questa attività in azione con la demo di MediaPipe Studio. Per saperne di più sulle funzionalità, sui modelli e sulle opzioni di configurazione di questa attività, consulta la panoramica.

Guida rapida

Segui questi passaggi per aggiungere l'API LLM Inference alla tua applicazione per iOS. L'API LLM Inference utilizza la libreria MediaPipeTasksGenai, che deve essere installata utilizzando CocoaPods. La libreria è compatibile con le app Swift e Objective-C e non richiede alcuna configurazione aggiuntiva specifica per la lingua.

Per istruzioni su come installare CocoaPods su macOS, consulta la guida all'installazione di CocoaPods. Per istruzioni su come creare un Podfile con i pod necessari per la tua app, consulta Utilizzo di CocoaPods.

Aggiungi dipendenze

Aggiungi il pod MediaPipeTasksGenai in Podfile utilizzando il seguente codice:

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

Se la tua app include target di test delle unità, consulta la guida alla configurazione per iOS per ulteriori informazioni sulla configurazione del tuo Podfile.

Scaricare un modello

Scarica Gemma-2 2B in un formato quantizzato a 8 bit da Kaggle Models. Per ulteriori informazioni sui modelli disponibili, consulta la documentazione sui modelli.

Aggiungi il modello alla directory del progetto utilizzando Xcode. Per istruzioni su come aggiungere file al progetto Xcode, consulta Gestione di file e cartelle nel progetto Xcode.

Inizializza l'attività

Inizializza l'attività con le opzioni di configurazione di base:

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)

Esegui l'attività

Utilizza il metodo generateResponse(inputText:) per generare una risposta di testo. In questo modo viene generata una sola risposta.

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

Per trasmettere in streaming la risposta, utilizza il metodo generateResponseAsync(inputText:).

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

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

Applicazione di esempio

L'applicazione di esempio è un esempio di app di generazione di testo di base per iOS, che utilizza l'API LLM Inference. Puoi utilizzare l'app come punto di partenza per la tua app iOS o farvi riferimento quando modifichi un'app esistente. Il codice di esempio è ospitato su GitHub.

Clona il repository Git utilizzando il seguente comando:

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

Dopo aver creato una versione locale del codice di esempio, puoi importare il progetto in iOS Studio ed eseguire l'app. Per maggiori informazioni, consulta la Guida alla configurazione per iOS.

Opzioni di configurazione

Utilizza le seguenti opzioni di configurazione per configurare un'app per iOS:

Conversione del modello

L'API LLM Inference è compatibile con i seguenti tipi di modelli, alcuni dei quali richiedono la conversione del modello. Utilizza la tabella per identificare il metodo dei passaggi richiesti per il tuo modello.

Per scoprire come convertire altri modelli, consulta la sezione Conversione del modello.

Personalizzazione LoRA

L'API LLM Inference supporta l'ottimizzazione LoRA (Low-Rank Adaptation) utilizzando la libreria PEFT (Parameter-Efficient Fine-Tuning). La messa a punto LoRA personalizza il comportamento degli LLM tramite un processo di addestramento conveniente, creando un piccolo insieme di pesi addestrabili basati su nuovi dati di addestramento anziché riaddestrare l'intero modello.

L'API LLM Inference supporta l'aggiunta di pesi LoRA ai livelli di attenzione dei modelli Gemma-2 2B, Gemma 2B e Phi-2. Scarica il modello in formato safetensors.

Per creare i pesi LoRA, il modello di base deve essere nel formato safetensors. Dopo l'addestramento LoRA, puoi convertire i modelli nel formato FlatBuffers per l'esecuzione su MediaPipe.

Prepara i pesi LoRA

Utilizza la guida LoRA Methods di PEFT per addestrare un modello LoRA ottimizzato sul tuo set di dati.

L'API LLM Inference supporta solo LoRA sui livelli di attenzione, quindi specifica solo i livelli di attenzione in 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"],
)

Dopo l'addestramento sul set di dati preparato e il salvataggio del modello, i pesi del modello LoRA ottimizzato sono disponibili in adapter_model.safetensors. Il file safetensors è il checkpoint LoRA utilizzato durante la conversione del modello.

Conversione del modello

Utilizza il pacchetto Python MediaPipe per convertire i pesi del modello nel formato Flatbuffer. ConversionConfig specifica le opzioni del modello di base insieme alle opzioni LoRA aggiuntive.

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)

Il convertitore produrrà due file Flatbuffer, uno per il modello di base e un altro per il modello LoRA.

Inferenza del modello LoRA

iOS supporta LoRA statica durante l'inizializzazione. Per caricare un modello LoRA, specifica il percorso del modello LoRA e l'LLM di 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)

Per eseguire l'inferenza LLM con LoRA, utilizza gli stessi metodi generateResponse() o generateResponseAsync() del modello di base.