Przewodnik po wnioskowaniu LLM dla iOS

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) w całości na urządzeniu w przypadku aplikacji na iOS. Możesz go używać do wykonywania wielu różnych zadań, takich jak generowanie tekstu, wyszukiwanie informacji w formie języka naturalnego i podsumowywanie dokumentów. Zadanie ma wbudowaną obsługę wielu dużych modeli językowych typu tekst na tekst, dzięki czemu możesz stosować w aplikacjach na iOS najnowsze modele generatywnej AI na urządzeniu.

Aby szybko dodać interfejs LLM Inference API do aplikacji na iOS, przeczytaj Krótkie wprowadzenie. Podstawowy przykład aplikacji na iOS korzystającej z interfejsu LLM Inference API znajdziesz w przykładowej aplikacji. Aby lepiej zrozumieć, jak działa interfejs LLM Inference API, zapoznaj się z sekcjami opcje konfiguracji, konwersja modelu i dostrajanie LoRA.

Możesz zobaczyć to zadanie w akcji w demonstracji MediaPipe Studio. Więcej informacji o możliwościach, modelach i opcjach konfiguracji tego zadania znajdziesz w tym artykule.

Krótkie wprowadzenie

Aby dodać interfejs LLM Inference API do aplikacji na iOS, wykonaj te czynności. Interfejs LLM Inference API korzysta z biblioteki MediaPipeTasksGenai, którą należy zainstalować za pomocą CocoaPods. Biblioteka jest zgodna z aplikacjami w językach Swift i Objective-C i nie wymaga dodatkowej konfiguracji specyficznej dla danego języka.

Instrukcje instalowania CocoaPods na macOS znajdziesz w przewodniku instalacji CocoaPods. Instrukcje tworzenia pliku Podfile z niezbędnymi podami dla aplikacji znajdziesz w artykule Korzystanie z CocoaPods.

Dodawanie zależności

Dodaj komponent MediaPipeTasksGenai do komponentu Podfile za pomocą tego kodu:

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

Jeśli Twoja aplikacja zawiera cele testów jednostkowych, w przewodniku po konfiguracji na iOS znajdziesz dodatkowe informacje o konfigurowaniu Podfile.

Pobieranie modelu

Pobierz model Gemma-2 2B w 8-bitowym formacie skwantyzowanym z Kaggle Models. Więcej informacji o dostępnych modelach znajdziesz w dokumentacji dotyczącej modeli.

Dodaj model do katalogu projektu za pomocą Xcode. Instrukcje dodawania plików do projektu Xcode znajdziesz w artykule Zarządzanie plikami i folderami w projekcie Xcode.

Inicjowanie zadania

Zainicjuj zadanie za pomocą podstawowych opcji konfiguracji:

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)

Uruchamianie zadania

Użyj metody generateResponse(inputText:), aby wygenerować odpowiedź tekstową. W ten sposób powstaje jedna wygenerowana odpowiedź.

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

Aby przesyłać odpowiedź strumieniowo, użyj metody generateResponseAsync(inputText:).

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

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

Przykładowa aplikacja

Przykładowa aplikacja to podstawowa aplikacja do generowania tekstu na iOS, która korzysta z interfejsu LLM Inference API. Możesz użyć tej aplikacji jako punktu wyjścia do utworzenia własnej aplikacji na iOS lub skorzystać z niej podczas modyfikowania istniejącej aplikacji. Przykładowy kod jest hostowany w GitHub.

Sklonuj repozytorium Git za pomocą tego polecenia:

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

Po utworzeniu lokalnej wersji przykładowego kodu możesz zaimportować projekt do iOS Studio i uruchomić aplikację. Więcej informacji znajdziesz w przewodniku po konfiguracji na iOS.

Opcje konfiguracji

Aby skonfigurować aplikację na iOS, użyj tych opcji:

Konwersja modelu

Interfejs LLM Inference API jest zgodny z tymi typami modeli, z których niektóre wymagają konwersji. W tabeli znajdziesz wymagane kroki i metody dla swojego modelu.

Więcej informacji o tym, jak przekonwertować inne modele, znajdziesz w sekcji Konwersja modelu.

Dostosowywanie LoRA

Interfejs LLM Inference API obsługuje dostrajanie LoRA (Low-Rank Adaptation) za pomocą biblioteki PEFT (Parameter-Efficient Fine-Tuning). Dostrajanie LoRA dostosowuje zachowanie dużych modeli językowych za pomocą ekonomicznego procesu trenowania, który tworzy mały zestaw wag podlegających trenowaniu na podstawie nowych danych treningowych, zamiast ponownie trenować cały model.

Interfejs LLM Inference API obsługuje dodawanie wag LoRA do warstw uwagi modeli Gemma-2 2B, Gemma 2B i Phi-2. Pobierz model w formacie safetensors.

Aby utworzyć wagi LoRA, model podstawowy musi być w formacie safetensors. Po wytrenowaniu modelu LoRA możesz przekonwertować go do formatu FlatBuffers, aby uruchomić go w MediaPipe.

Przygotowywanie wag LoRA

Skorzystaj z przewodnika LoRA Methods z biblioteki PEFT, aby wytrenować dostrojony model LoRA na własnym zbiorze danych.

Interfejs LLM Inference API obsługuje LoRA tylko w przypadku warstw uwagi, więc w parametrze LoraConfig podaj tylko warstwy uwagi:

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

Po wytrenowaniu modelu na przygotowanym zbiorze danych i zapisaniu modelu dostrojone wagi modelu LoRA są dostępne w adapter_model.safetensors. Plik safetensors to punkt kontrolny LoRA używany podczas konwersji modelu.

Konwersja modelu

Użyj pakietu MediaPipe Python, aby przekonwertować wagi modelu na format Flatbuffer. Symbol ConversionConfig określa opcje modelu podstawowego wraz z dodatkowymi opcjami 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)

Konwerter utworzy 2 pliki Flatbuffer: jeden dla modelu podstawowego, a drugi dla modelu LoRA.

Wnioskowanie na podstawie modelu LoRA

iOS obsługuje statyczne LoRA podczas inicjowania. Aby wczytać model LoRA, podaj ścieżkę do modelu LoRA oraz podstawowy LLM.

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)

Aby uruchomić wnioskowanie LLM za pomocą LoRA, użyj tych samych metod generateResponse() lub generateResponseAsync() co w przypadku modelu podstawowego.