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, pobieranie informacji w formie języka naturalnego 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.

Zadanie obsługuje te warianty Gemma: Gemma-2 2B, Gemma 2B i Gemma 7B. Gemma to rodzina lekkich, najnowocześniejszych otwartych modeli opartych na tych samych badaniach i technologiach, które posłużyły do utworzenia modeli Gemini. Obsługuje też te modele zewnętrzne: Phi-2, Falcon-RW-1B i StableLM-3B.

Oprócz obsługiwanych modeli użytkownicy mogą używać AI Edge Torch Google do eksportowania modeli PyTorch do modeli LiteRT (tflite) z wieloma podpisami, które są dostarczane z parametrami tokenizera w celu utworzenia pakietów zadań zgodnych z interfejsem LLM Inference API.

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.

Przykładowy kod

Przykładowy kod MediaPipe Tasks to podstawowa implementacja aplikacji z interfejsem API LLM Inference na iOS. 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 interfejsu LLM Inference API jest hostowany na GitHub.

Pobieranie kodu

Z tych instrukcji dowiesz się, jak utworzyć lokalną kopię przykładowego kodu 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 skonfiguruj instancję git, aby używać rzadkiego sprawdzania, dzięki czemu będziesz mieć 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ć bibliotekę zadań MediaPipe, otworzyć projekt za pomocą Xcode i uruchomić aplikację. Instrukcje znajdziesz w przewodniku konfiguracji na iOS.

Konfiguracja

Ta sekcja opisuje kluczowe kroki konfigurowania środowiska programistycznego i projektów kodu, aby używać interfejsu LLM Inference API. Ogólne informacje o konfigurowaniu środowiska programistycznego do korzystania z zadań MediaPipe, w tym wymagania dotyczące wersji platformy, znajdziesz w przewodniku konfiguracji dla iOS.

Zależnoś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 aplikacji znajdziesz w artykule Korzystanie z CocoaPods.

Dodaj podelement MediaPipeTasksGenai w elementie 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.

Model

Zadanie interfejsu API MediaPipe LLM Inference wymaga wytrenowanego modelu, który jest zgodny z tym zadaniem. Więcej informacji o dostępnych wytrenowanych modelach interfejsu LLM Inference API znajdziesz w sekcji Modele w omówieniu zadania.

Pobieranie modelu

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

Przed zainicjowaniem interfejsu LLM Inference API pobierz jedną z obsługiwanych przez niego wersji modelu i zapisz plik w katalogu projektu:

• Gemma-2 2B: najnowsza wersja modeli z rodziny Gemma. Należy do rodziny lekkich, najnowocześniejszych otwartych modeli opartych na tych samych badaniach i technologiach, które posłużyły do utworzenia modeli Gemini.
• Gemma 2B: należy do rodziny lekkich, najnowocześniejszych otwartych modeli opartych na tych samych badaniach i technologiach, które posłużyły do utworzenia modeli Gemini. Model ten dobrze sprawdza się w różnych zadaniach związanych z generowaniem tekstu, takich jak odpowiadanie na pytania, podsumowywanie i rozumowanie.
• Phi-2: model Transformer z 2, 7 miliardami parametrów, najlepiej nadający się do formatu pytania i odpowiedzi, czatu i kodu.
• Falcon-RW-1B: model z 1 mld parametrów, który jest dekoderem przyczynowym wytrenowanym na 350 mld tokenów z RefinedWeb.
• StableLM-3B: model językowy z 3 mld parametrów, który jest dekoderem i został wstępnie wytrenowany na 1 trylionie tokenów z różnych zbiorów danych z tekstem i kodem w języku angielskim.

Oprócz obsługiwanych modeli możesz też używać AI Edge Torch od Google do eksportowania modeli PyTorch do modeli LiteRT (tflite) z wieloma podpisami. Więcej informacji znajdziesz w artykule Konwerter Torch Generative na potrzeby modeli PyTorch.

Zalecamy użycie Gemma-2 2B, która jest dostępna na Kaggle w sekcji Modele. Więcej informacji o dostępnych modelach znajdziesz w sekcji Modele w omówieniu zadania.

Konwertowanie modelu na format MediaPipe

Interfejs LLM Inference API jest zgodny z 2 kategoriami modeli, z których niektóre wymagają konwersji modelu. Korzystając z tabeli, określ wymagane kroki i metodę dla swojego modelu.

Konwertowane pliki .bin dotyczące Gemma 2B, Gemma 7B i Gemma-2 2B są dostępne na Kaggle. Te modele można wdrażać bezpośrednio za pomocą naszego interfejsu LLM Inference API. Aby dowiedzieć się, jak konwertować inne modele, zapoznaj się z sekcją Konwersja modelu.

Tworzenie zadania

Zadaniem interfejsu LLM Inference API jest wywołanie jednej z jego funkcji inicjującej. Inicjalizator LlmInference(options:) ustawia wartości opcji konfiguracji.

Jeśli nie potrzebujesz interfejsu LLM Inference API zainicjowanego za pomocą opcji niestandardowej konfiguracji, możesz użyć funkcji inicjującej LlmInference(modelPath:), aby utworzyć interfejs LLM Inference API z opcjami domyślnymi. Więcej informacji o opcjach konfiguracji 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

W tym zadaniu dostępne są te opcje konfiguracji aplikacji na iOS:

Przygotuj dane

Interfejs LLM Inference API obsługuje dane tekstowe. To zadanie obsługuje wstępną obróbkę danych wejściowych, w tym tokenizację i przetwarzanie tensorów.

Cała wstępna obróbka odbywa się w ramach funkcji generateResponse(inputText:). Nie trzeba wcześniej poddawać tekstu dodatkowej wstępnej obróbce.

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:). Interfejs LLM Inference API zwraca możliwe kategorie dla tekstu wejściowego.

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)")
}

Obsługa i wyświetlanie wyników

Interfejs LLM Inference API zwraca 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]

Dostosowywanie modelu LoRA

Interfejs API Mediapipe do wnioskowania oparte na dużych modelach językowych można skonfigurować tak, aby obsługiwał adaptację niskiego rzędu (LoRA) dla dużych modeli językowych. Dzięki dostosowanym modelom LoRA deweloperzy mogą dostosowywać działanie LLM za pomocą ekonomicznego procesu trenowania.

Obsługa LoRA w LLM Inference API działa we wszystkich wariantach Gemma i modelach Phi-2 w przypadku backendu GPU. Wagi LoRA są stosowane tylko do warstw uwagi. Ta początkowa implementacja jest eksperymentalnym interfejsem API przeznaczonym do przyszłych wersji. W przyszłych aktualizacjach planujemy obsługiwać więcej modeli i różne typy warstw.

Przygotowanie modeli LoRA

Postępuj zgodnie ze wskazówkami na stronie huggingface.org, aby wytrenować dostosowany model LoRA na podstawie własnego zbioru danych za pomocą obsługiwanych typów modeli: Gemma lub Phi-2. Modele Gemma-2 2B, Gemma 2B i Phi-2 są dostępne na stronie huggingface w formacie safetensors. Ponieważ interfejs LLM Inference API obsługuje tylko LoRA na warstwach uwagi, podczas tworzenia modeluLoraConfig 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"],
)

Do testowania dostępne są publicznie dostępne modele LoRA, które pasują do interfejsu LLM Inference API dostępnego na HuggingFace. Na przykład: monsterapi/gemma-2b-lora-maths-orca-200k w przypadku Gemma-2B i lole25/phi-2-sft-ultrachat-lora w przypadku Phi-2.

Po wytrenowaniu modelu na przygotowanym zbiorze danych i zapisaniu go otrzymasz plik adapter_model.safetensors zawierający dostrojone wagi modelu LoRA. Plik safetensors to punkt kontrolny LoRA używany do konwertowania modelu.

W następnym kroku musisz przekonwertować wagi modelu na Flatbuffera TensorFlow Lite za pomocą pakietu MediaPipe w Pythonie. W polu ConversionConfig należy podać opcje modelu podstawowego oraz dodatkowe opcje LoRa. Pamiętaj, że interfejs API obsługuje wnioskowanie LoRA tylko z użyciem procesora graficznego, więc 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 flatbuffera TFLite: jeden dla modelu podstawowego, a drugi dla modelu LoRA.

Wnioskowanie modelu LoRA

Interfejsy API LLM Inference na potrzeby sieci Web, Androida i iOS zostały zaktualizowane, aby obsługiwać wnioskowanie modelu 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 w przypadku modelu podstawowego.