Przewodnik po wnioskowaniu LLM dla iOS

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) całkowicie na urządzeniu dla aplikacji na iOS, za pomocą których można wykonywać różnorodne zadania, takie jak generowanie tekstu, pobieranie informacji w języku naturalnym, podsumowywanie dokumentów. Zadanie ma wbudowaną obsługę wielu dużych modeli językowych (tekst na tekst) i zastosować modeli generatywnej AI w Twoich aplikacjach na iOS.

Możesz zobaczyć, jak to zadanie działa w aplikacji MediaPipe Studio wersji demonstracyjnej. Więcej informacji o funkcjach, modelach i opcjach konfiguracji zapoznaj się z Przeglądem.

Przykładowy kod

Przykładowy kod MediaPipe Tasks to podstawowa implementacja interfejsu LLM Inference API na iOS. Możesz używać aplikacji jako punktu wyjścia dla własnej aplikacji na iOS lub i odwołania do niego podczas modyfikowania istniejącej aplikacji. Przykładowy kod interfejsu LLM Inference API to hostowana GitHub

Pobieranie kodu

Poniżej znajdziesz instrukcje tworzenia lokalnej kopii przykładu. za pomocą narzędzia wiersza poleceń git.

Aby pobrać przykładowy kod:

1. Sklonuj repozytorium git za pomocą tego polecenia:

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

2. Opcjonalnie możesz skonfigurować instancję git tak, aby wykorzystywała rozproszony proces płatności, aby tylko pliki przykładowej aplikacji LLM Inference API:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/ios/
   

Po utworzeniu lokalnej wersji przykładowego kodu możesz zainstalować w bibliotece zadań MediaPipe, otwórz projekt za pomocą Xcode i uruchom aplikację. Dla: instrukcje znajdziesz w Przewodniku po konfiguracji na iOS.

Konfiguracja

W tej sekcji opisujemy najważniejsze czynności związane z konfigurowaniem środowiska programistycznego oraz w projektach kodu, które wykorzystują LLM Inference API. Ogólne informacje o konfigurowaniu środowisko programistyczne do używania zadań MediaPipe, w tym wersja platformy wymagania znajdziesz w przewodniku konfiguracji dla iOS.

Zależności

LLM Inference API korzysta z biblioteki MediaPipeTasksGenai, którą należy zainstalować za pomocą CocoaPods. Biblioteka jest zgodna z aplikacjami Swift i Objective-C. i nie wymaga żadnej dodatkowej konfiguracji.

Instrukcje instalowania CocoaPods w macOS znajdziesz w CocoaPods przewodnik instalacji. Aby dowiedzieć się, jak utworzyć Podfile z podami niezbędnymi dla Twojego aplikacji można znaleźć w sekcji Korzystanie CocoaPods.

Dodaj blok MediaPipeTasksGenai w Podfile za pomocą tego kodu:

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

Jeśli Twoja aplikacja zawiera cele testów jednostkowych, zapoznaj się z przewodnikiem po konfiguracji iOS, gdzie znajdziesz dodatkowe informacje o konfigurowaniu Podfile.

Model

Zadanie MediaPipe LLM Inference API wymaga wytrenowanego modelu, który jest zgodny w tym zadaniu. Więcej informacji o dostępnych wytrenowanych modelach dla LLM Inference API: zobacz sekcję modeli w omówieniu zadania.

Pobierz model

Pobierz model i dodaj go do katalogu projektu za pomocą Xcode. Dla: instrukcje dodawania plików do projektu Xcode znajdziesz w sekcji Zarządzanie plikami i folderów w Xcode projekt.

Pobierz Gemma 2B .

Tworząc aplikacje na iOS, użyj jednego z tych wariantów:

• gemma-2b-it-cpu-int4: 4-bitowy model Gemma zgodny z procesorem.
• gemma-2b-it-gpu-int4: 4-bitowy model Gemma zgodny z GPU.
• Zmapowane modele AI Edge Torch zgodne z wymaganiami dotyczącymi pamięci iOS.

Więcej informacji o innych modelach znajdziesz w omówieniu zadania: Modele .

Tworzenie zadania

Możesz utworzyć zadanie LLM Inference API, wywołując jeden z jego inicjatorów. Inicjator LlmInference(options:) ustawia wartości opcji konfiguracyjnych.

Jeśli nie potrzebujesz interfejsu LLM Inference API zainicjowanego z użyciem niestandardowej konfiguracji możesz użyć inicjatora LlmInference(modelPath:) do utworzenia LLM Inference API z opcjami domyślnymi. Więcej informacji o konfiguracji Więcej informacji znajdziesz w artykule Omówienie konfiguracji.

Poniższy kod pokazuje, jak skompilować i skonfigurować to zadanie.

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)

Opcje konfiguracji

To zadanie zawiera te opcje konfiguracji aplikacji na iOS:

Przygotuj dane

LLM Inference API obsługuje dane tekstowe. Zadanie obsługuje wprowadzanie danych w tym wstępnego przetwarzania danych, w tym tokenizacji i tensorów.

Całe wstępne przetwarzanie odbywa się w ramach funkcji generateResponse(inputText:). Nie ma potrzeby wcześniejszego wstępnego przetwarzania tekstu wejściowego.

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

Uruchamianie zadania

Aby uruchomić interfejs LLM Inference API, użyj metody generateResponse(inputText:). LLM Inference API zwraca możliwe kategorie tekstu wejściowego.

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

Aby przesł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)")
}

Obsługa i wyświetlanie wyników

LLM Inference API zwraca wartość LlmInferenceResult, która zawiera wygenerowany tekst odpowiedzi.

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]

Dostosowanie modelu LoRA

Interfejs Mediapipe LLM API wnioskowania można skonfigurować pod kątem obsługi adaptacji niskiego rankingu (LoRA) dla dużych modeli językowych. Dzięki dostrojonym modelom LoRA deweloperzy mogą dostosowywać zachowanie LLM przez ekonomiczny proces trenowania.

Obsługa LoRA interfejsu LLM Inference API działa w przypadku modeli Gemma-2B i Phi-2 dla: backendu GPU, a wagi LoRA mają zastosowanie tylko do warstw uwagi. Ten wstępna implementacja służy jako eksperymentalny interfejs API do wykorzystania w przyszłości z planami dodania obsługi kolejnych modeli i różnych typów warstw aktualizacje.

Przygotuj modele LoRA

Postępuj zgodnie z instrukcjami w HuggingFace, aby wytrenować dostrojony model LoRA na własnym zbiorze danych z użyciem obsługiwanych typów modeli – Gemma-2B lub Phi-2. Modele Gemma-2B i Phi-2 są dostępne w HuggingFace w formacie Safetensors. Ponieważ LLM Inference API obsługuje LoRA tylko w warstach uwagi, podczas tworzenia obiektu LoraConfig określ tylko warstwy uwagi w ten sposób:

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

Do testów dostępne są publicznie dostępne, dostrojone modele LoRA pasujące do interfejsu LLM Inference API. np. monsterapi/gemma-2b-lora-maths-orca-200k w przypadku Gemma-2B i lole25/phi-2-sft-ultrachat-lora w przypadku Phi-2.

Po wytrenowaniu na przygotowanym zbiorze danych i zapisaniu modelu uzyskujesz plik adapter_model.safetensors zawierający dostrojone wagi modelu LoRA. Plik Safetensors to punkt kontrolny LoRA używany w konwersji modelu.

W następnym kroku musisz przekonwertować wagi modelu na płaski bufor TensorFlow Lite za pomocą pakietu MediaPipe w Pythonie. ConversionConfig powinien określać opcje modelu podstawowego i dodatkowe opcje LoRA. Zwróć uwagę, że interfejs API obsługuje tylko wnioskowanie o LORA z użyciem GPU, dlatego backend musi być ustawiony na '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)

Konwerter wygeneruje 2 pliki płaskiego bufora TFLite, jeden dla modelu podstawowego a drugą w modelu LoRA.

Wnioskowanie modelu LoRA

Internet, Android i iOS LLM Inference API zostały zaktualizowane, aby obsługiwać wnioskowanie z modelu LoRA. Internet obsługuje dynamiczną architekturę LoRA, która może przełączać różne modele LoRA w czasie działania. Android i iOS obsługują statyczną algorytm LoRA, który przez cały czas trwania zadania wykorzystuje te same wagi LoRA.

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 z LoRA, użyj tych samych metod generateResponse() lub generateResponseAsync() co model podstawowy.