Przewodnik po wnioskowaniu LLM dla iOS

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) całkowicie na urządzeniu w przypadku aplikacji na iOS. Można go używać do wykonywania wielu zadań, takich jak generowanie tekstu, pozyskiwanie informacji w formie naturalnego języka czy streszczanie dokumentów. Zadaniem jest wbudowane wsparcie dla wielu dużych modeli językowych do konwersji tekstu na tekst, dzięki czemu możesz stosować najnowsze modele generatywnej AI na urządzeniu w swoich aplikacjach na iOS.

Aby szybko dodać interfejs LLM Inference API do aplikacji na iOS, postępuj zgodnie z krótkim wprowadzeniem. Podstawowy przykład aplikacji na iOS, która korzysta z interfejsu LLM Inference API, znajdziesz w przykładowej aplikacji. Aby dowiedzieć się więcej o tym, jak działa interfejs LLM Inference API, zapoznaj się z sekcjami Opcje konfiguracji, Konwertowanie modelu i Ustawianie modelu LoRa.

Możesz zobaczyć to zadanie w działaniu w demonstracji MediaPipe Studio. Więcej informacji o możliwościach, modelach i opcjach konfiguracji związanych z tym zadaniem znajdziesz w sekcji Omówienie.

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 aplikacją w Swift i Objective-C i nie wymaga dodatkowej konfiguracji językowej.

Instrukcje instalacji CocoaPods na macOS znajdziesz w przewodniku instalacji CocoaPods. Instrukcje tworzenia Podfile z podstawowymi komponentami potrzebnymi do działania aplikacji znajdziesz w artykule Korzystanie z CocoaPods.

Dodawanie zależności

Dodaj podelement MediaPipeTasksGenai w elementzie Podfile za pomocą tego kodu:

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

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

Pobieranie modelu

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

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

Inicjowanie zadania

Inicjowanie zadania 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

Aby wygenerować odpowiedź tekstową, użyj metody generateResponse(inputText:). Ta opcja powoduje wygenerowanie jednej odpowiedzi.

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

Aby przesyłać strumieniowo odpowiedź, 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 przykład podstawowej aplikacji 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 na 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 konfiguracji iOS.

Opcje konfiguracji

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

Konwersja modelu

Interfejs API do wnioskowania opartego na sieciach LLM jest zgodny z tymi typami modeli, z których niektóre wymagają konwersji. Korzystając z tabeli, określ wymagane kroki i metodę dla swojego modelu.

Więcej informacji o konwertowaniu innych modeli znajdziesz w sekcji Konwertowanie 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 LLM za pomocą opłacalnego procesu trenowania, tworząc mały zestaw trenowanych wag na podstawie nowych danych treningowych, a nie trenując ponownie całego modelu.

Interfejs LLM Inference API umożliwia dodawanie wag LoRA do warstw uwagi w modelach 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ć modele do formatu FlatBuffers, aby można było je uruchomić w MediaPipe.

Przygotuj wagi LoRA

Aby wytrenować dopracowany model LoRA na podstawie własnego zbioru danych, skorzystaj z przewodnika LoRA Methods (w języku angielskim) opracowanego przez PEFT.

Interfejs LLM Inference API obsługuje tylko LoRA na warstwach uwagi, więc w pliku LoraConfig należy określić 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 go domyślnie dopasowane wagi modelu LoRA są dostępne w adapter_model.safetensors. Plik safetensors to punkt kontrolny LoRA używany podczas konwertowania modelu.

Konwersja modelu

Użyj pakietu Python MediaPipe, aby przekonwertować wagi modelu do formatu Flatbuffer. W polu ConversionConfig są określone 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 wygeneruje 2 pliki Flatbuffer: jeden dla modelu podstawowego, a drugi dla modelu LoRA.

Wnioskowanie modelu LoRA

iOS obsługuje statyczny LoRA podczas inicjalizacji. Aby załadować model LoRA, określ ścieżkę modelu LoRA oraz model LLM podstawowy.

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 wykonać wnioskowanie LLM za pomocą LoRA, użyj tych samych metod generateResponse() lub generateResponseAsync() co w przypadku modelu podstawowego.