Scopri di più sui nostri annunci di Google AI Edge da I/O

Questa pagina è stata tradotta dall'API Cloud Translation.

Guida all'inferenza LLM per iOS

L'API LLM Inference 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 formato linguistico e riassumere i documenti. L'attività fornisce supporto integrato per più modelli linguistici di grandi dimensioni da testo a testo, in modo da poter applicare i più recenti modelli di IA generativa on-device alle tue app per iOS.

Puoi vedere questa attività in azione con la demo di MediaPipe Studio. Per ulteriori informazioni sulle funzionalità, sui modelli e sulle opzioni di configurazione di questa attività, consulta la Panoramica.

Esempio di codice

Il codice di esempio di MediaPipe Tasks è un'implementazione di base di un'app dell'API LLM Inference per iOS. Puoi utilizzare l'app come punto di partenza per la tua app per iOS o farvi riferimento quando modifichi un'app esistente. Il codice di esempio dell'API LLM Inference è ospitato su GitHub.

Scarica il codice

Le seguenti istruzioni mostrano come creare una copia locale del codice di esempio utilizzando lo strumento a riga di comando git.

Per scaricare il codice di esempio:

Clona il repository git utilizzando il seguente comando:

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

Facoltativamente, configura l'istanza Git in modo da utilizzare il pagamento sparse, in modo da avere solo i file per l'app di esempio dell'API LLM Inference:
```
cd mediapipe
git sparse-checkout init --cone
git sparse-checkout set examples/llm_inference/ios/
```

Dopo aver creato una versione locale del codice di esempio, puoi installare la libreria di attività MediaPipe, aprire il progetto utilizzando Xcode ed eseguire l'app. Per istruzioni, consulta la Guida alla configurazione per iOS.

Imposta

Questa sezione descrive i passaggi chiave per configurare l'ambiente di sviluppo e codificare i progetti in modo da utilizzare l'API LLM Inference. Per informazioni generali sulla configurazione dell'ambiente di sviluppo per l'utilizzo delle attività MediaPipe, inclusi i requisiti di versione della piattaforma, consulta la Guida alla configurazione per iOS.

Dipendenze

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 la sezione Utilizzare CocoaPods.

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 per il test delle unità, consulta la Guida alla configurazione per iOS per ulteriori informazioni sulla configurazione di Podfile.

Modello

L'attività dell'API MediaPipe LLM Inference richiede un modello addestrato compatibile con questa attività. Per ulteriori informazioni sui modelli addestrati disponibili per l'API Inference LLM, consulta la sezione Modelli della panoramica delle attività.

Scarica un modello

Scarica un modello e aggiungilo alla directory del progetto utilizzando Xcode. Per istruzioni su come aggiungere file al progetto Xcode, consulta Gestire file e cartelle nel progetto Xcode.

Scarica Gemma 2B

Quando crei app per iOS, usa una delle seguenti varianti:

gemma-2b-it-cpu-int4: modello a 4 bit di Gemma con compatibilità CPU.
gemma-2b-it-gpu-int4: modello Gemma a 4 bit con compatibilità GPU.
Modelli mappati AI Edge Torch conformi ai requisiti di memoria per iOS.

Per saperne di più su altri modelli, consulta la sezione Modelli della panoramica dell'attività.

Creare l'attività

Puoi creare l'attività dell'API LLM Inference chiamando uno dei suoi inizializzatori. L'inizializzazione LlmInference(options:) imposta i valori per le opzioni di configurazione.

Se non hai bisogno di un'API LLM Inference inizializzata con opzioni di configurazione personalizzate, puoi utilizzare l'inizializzazione LlmInference(modelPath:) per creare un'API LLM Inference con le opzioni predefinite. Per ulteriori informazioni sulle opzioni di configurazione, consulta Panoramica della configurazione.

Il codice seguente mostra come creare e configurare questa attività.

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)

Opzioni di configurazione

Questa attività prevede le seguenti opzioni di configurazione per le app per iOS:

Nome opzione	Descrizione	Intervallo di valori	Valore predefinito
`modelPath`	Il percorso in cui è archiviato il modello all'interno della directory del progetto.	PATH	N/A
`maxTokens`	Il numero massimo di token (token di input + token di output) gestiti dal modello.	Integer	512
`topk`	Il numero di token che il modello prende in considerazione in ogni passaggio della generazione. Limita le previsioni ai token più probabili con il valore top-k. Quando imposti `topk`, devi anche impostare un valore per `randomSeed`.	Integer	40
`temperature`	La quantità di casualità introdotta durante la generazione. Una temperatura più alta favorisce la creatività nel testo generato, mentre una temperatura più bassa produce una generazione più prevedibile. Quando imposti `temperature`, devi anche impostare un valore per `randomSeed`.	In virgola mobile	0,8
`randomSeed`	Il seed casuale utilizzato durante la generazione del testo.	Integer	0
`loraPath`	Il percorso assoluto al modello LoRA a livello locale sul dispositivo. Nota: è compatibile solo con i modelli GPU.	PATH	N/A

preparazione dei dati

L'API LLM Inference funziona con dati di testo. L'attività gestisce la pre-elaborazione dell'input dei dati, tra cui la tokenizzazione e la pre-elaborazione tensor.

L'intera pre-elaborazione viene gestita all'interno della funzione generateResponse(inputText:). Non è necessaria alcuna pre-elaborazione aggiuntiva del testo di input.

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

Esegui l'attività

Per eseguire l'API LLM Inference, utilizza il metodo generateResponse(inputText:). L'API LLM Inference restituisce le categorie possibili per il testo di input.

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

Per trasmettere la risposta in streaming, usa 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)")
}

Gestire e visualizzare i risultati

L'API LLM Inference restituisce un codice LlmInferenceResult, che include il testo della risposta generato.

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]

Personalizzazione del modello LoRA

L'API di inferenza LLM Mediapipe può essere configurata per supportare lo standard LLM (Low-Rank adeguamento) per i modelli linguistici di grandi dimensioni (LLM). Con modelli LoRA perfezionati, gli sviluppatori possono personalizzare il comportamento degli LLM tramite un processo di addestramento conveniente.

Il supporto LoRA dell'API LLM Inference funziona per i modelli Gemma-2B e Phi-2 per il backend GPU, con ponderazioni LoRA applicabili solo ai livelli di attenzione. Questa implementazione iniziale funge da API sperimentale per gli sviluppi futuri, con l'obiettivo di supportare altri modelli e vari tipi di livelli nei prossimi aggiornamenti.

prepara i modelli LoRA

Segui le istruzioni su HuggingFace per addestrare un modello LoRA ottimizzato sul tuo set di dati con tipi di modelli supportati, Gemma-2B o Phi-2. I modelli Gemma-2B e Phi-2 sono entrambi disponibili su HuggingFace nel formato Safetensors. Poiché l'API LLM Inference supporta solo LoRA sui livelli di attenzione, specifica solo i livelli di attenzione durante la creazione di LoraConfig come segue:

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

Per i test, sono disponibili su HuggingFace modelli LoRA perfezionati e accessibili pubblicamente, che si adattano all'API LLM Inference. Ad esempio, monsterapi/gemma-2b-lora-maths-orca-200k per Gemma-2B e lole25/phi-2-sft-ultrachat-lora per Phi-2.

Dopo l'addestramento sul set di dati preparato e aver salvato il modello, ottieni un file adapter_model.safetensors contenente le ponderazioni del modello LoRA ottimizzate. Il file Safetensors è il checkpoint LoRA utilizzato nella conversione del modello.

Nel passaggio successivo, devi convertire le ponderazioni del modello in un Flatbuffer di TensorFlow Lite utilizzando il pacchetto Python MediaPipe. L'ConversionConfig deve specificare le opzioni del modello di base e altre opzioni LoRA. Tieni presente che, poiché l'API supporta solo l'inferenza LoRA con GPU, il backend deve essere impostato su '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)

Il convertitore restituirà come output due file flatbuffer TFLite, uno per il modello di base e l'altro per il modello LoRA.

Inferenza del modello LoRA

Le API Web, Android e iOS Inference LLM sono aggiornate per supportare l'inferenza del modello LoRA. Il web supporta LoRA dinamico, che può cambiare modelli LoRA diversi durante il runtime. Android e iOS supportano LoRA statico, che utilizza le stesse ponderazioni LoRA per tutta la durata dell'attività.

iOS supporta la funzione LoRA statica durante l'inizializzazione. Per caricare un modello LoRA, gli utenti specificano il percorso del modello LoRA e il modello 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.