Przewodnik dotyczący wnioskowania na podstawie LLM

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) w całości na urządzeniu. Możesz go używać do wykonywania różnorodnych zadań, takich jak generowanie tekstu, wyszukiwanie informacji w języku naturalnym 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 i usługach najnowsze modele generatywnej AI na urządzeniu.

Wypróbujarrow_forward

Zadanie ma wbudowaną obsługę różnych dużych modeli językowych. Modele hostowane na stronie LiteRT Community są dostępne w formacie zgodnym z MediaPipe i nie wymagają żadnych dodatkowych kroków konwersji ani kompilacji.

Za pomocą LiteRT Torch możesz eksportować modele PyTorch do modeli LiteRT z wieloma sygnaturami (tflite), które są połączone z parametrami tokenizatora, aby tworzyć pakiety zadań. Modele przekonwertowane za pomocą LiteRT Torch są zgodne z interfejsem LLM Inference API i mogą działać na backendzie CPU, dzięki czemu nadają się do aplikacji na Androida i iOS.

Rozpocznij

Aby zacząć korzystać z tego zadania, postępuj zgodnie z jednym z tych przewodników po implementacji na platformie docelowej. Te przewodniki dotyczące poszczególnych platform zawierają podstawowe informacje o wdrażaniu tego zadania oraz przykłady kodu, które korzystają z dostępnego modelu i zalecanych opcji konfiguracji:

• Sieć:

  • Przewodnik
  • Przykładowy kod

• Android:

  • Przewodnik
  • Przykładowy kod

• iOS

  • Przewodnik
  • Przykładowy kod

Szczegóły działania

W tej sekcji opisujemy możliwości, dane wejściowe, dane wyjściowe i opcje konfiguracji tego zadania.

Funkcje

Interfejs LLM Inference API ma te kluczowe funkcje:

1. Generowanie tekstu na podstawie tekstu – generowanie tekstu na podstawie prompta tekstowego.
2. Wybór LLM – zastosuj wiele modeli, aby dostosować aplikację do konkretnych przypadków użycia. Możesz też ponownie wytrenować model i zastosować do niego dostosowane wagi.
3. Obsługa LoRA – rozszerzanie i dostosowywanie możliwości LLM za pomocą modelu LoRA. Możesz trenować model na całym zbiorze danych lub korzystać z gotowych modeli LoRA z społeczności open source (nie są one zgodne z modelami przekonwertowanymi za pomocą interfejsu LiteRT Torch Generative API).

Opcje konfiguracji

To zadanie ma te opcje konfiguracji:

Modele

Interfejs LLM Inference API obsługuje wiele dużych modeli językowych typu tekst-tekst, w tym wbudowaną obsługę kilku modeli zoptymalizowanych pod kątem działania w przeglądarkach i na urządzeniach mobilnych. Te lekkie modele mogą być używane do przeprowadzania wnioskowania w całości na urządzeniu.

Przed zainicjowaniem interfejsu LLM Inference API pobierz model i zapisz plik w katalogu projektu. Możesz użyć wstępnie przekonwertowanego modelu z repozytorium LiteRT Community w HuggingFace lub przekonwertować model na format zgodny z MediaPipe za pomocą AI Edge Torch Generative Converter.

Jeśli nie masz jeszcze modelu LLM, którego możesz używać z interfejsem LLM Inference API, zacznij od jednego z tych modeli.

Gemma-3n

Gemma-3n E2B i E4B to najnowsze modele z rodziny Gemma. Są to lekkie, zaawansowane modele otwarte, które powstały na podstawie tych samych badań i technologii, które zostały wykorzystane do stworzenia modeli Gemini. Modele Gemma 3n zostały zaprojektowane z myślą o wydajnym działaniu na urządzeniach o ograniczonych zasobach. Umożliwiają one wprowadzanie danych multimodalnych, obsługując tekst, obrazy i dźwięk, oraz generowanie danych wyjściowych w postaci tekstu.

Modele Gemma 3n wykorzystują technologię selektywnej aktywacji parametrów, aby zmniejszyć wymagania dotyczące zasobów. Dzięki tej technice modele mogą działać przy efektywnym rozmiarze 2 mld i 4 mld parametrów, co jest mniejsze niż łączna liczba parametrów, które zawierają.

Pobierz Gemma-3n E2B

Pobierz Gemma-3n E4B

Modele Gemma-3n E2B i E4B z HuggingFace są dostępne w formacie .litertlm i można ich używać z interfejsem LLM Inference API na Androida i w internecie.

Gemma-3 1B

Gemma-3 1B to najlżejszy model w rodzinie lekkich, zaawansowanych modeli otwartych Gemma, które powstały w oparciu o te same badania i technologie, które zostały wykorzystane do stworzenia modeli Gemini. Model zawiera 1 miliard parametrów i otwarte wagi.

Pobierz model Gemma-3 1B

Model Gemma-3 1B od HuggingFace jest dostępny w formacie .task/.litertlm i można go używać z interfejsem LLM Inference API w aplikacjach na Androida i w internecie.

Podczas uruchamiania modelu Gemma-3 1B za pomocą interfejsu LLM Inference API skonfiguruj odpowiednio te opcje:

• preferredBackend: ta opcja pozwala wybrać backend CPU lub GPU. Ta opcja jest dostępna tylko na Androidzie.
• supportedLoraRanks: interfejsu LLM Inference API nie można skonfigurować tak, aby obsługiwał adaptację niskiego rzędu (LoRA) w przypadku modelu Gemma-3 1B. Nie używaj opcji supportedLoraRanks ani loraRanks.
• maxTokens: wartość maxTokens musi być zgodna z rozmiarem kontekstu wbudowanym w model. Może być też nazywana pamięcią podręczną par klucz-wartość lub długością kontekstu.
• numResponses: musi zawsze wynosić 1. Ta opcja jest dostępna tylko w przypadku internetu.

Podczas uruchamiania modelu Gemma-3 1B w aplikacjach internetowych inicjowanie może powodować długotrwałe blokowanie bieżącego wątku. Jeśli to możliwe, zawsze uruchamiaj model w wątku roboczym.

Gemma-2 2B

Gemma-2 2B to wersja modelu Gemma-2 o 2 miliardach parametrów, która działa na wszystkich platformach.

Pobierz Gemma-2 2B

Model zawiera 2 miliardy parametrów i otwarte wagi. Model Gemma-2 2B słynie z najnowocześniejszych w swojej klasie umiejętności rozumowania.

Konwersja modelu PyTorch

Modele generatywne PyTorch można przekonwertować na format zgodny z MediaPipe za pomocą interfejsu LiteRT Torch Generative API. Za pomocą interfejsu API możesz przekonwertować modele PyTorch na modele LiteRT (TensorFlow Lite) z wieloma sygnaturami. Więcej informacji o mapowaniu i eksportowaniu modeli znajdziesz na stronie LiteRT Torch na GitHubie.

Konwertowanie modelu PyTorch za pomocą interfejsu LiteRT Torch Generative API obejmuje te kroki:

1. Pobierz punkty kontrolne modelu PyTorch.
2. Użyj interfejsu LiteRT Torch Generative API, aby utworzyć, przekonwertować i skwantyzować model do formatu pliku zgodnego z MediaPipe (.tflite).
3. Utwórz pakiet zadań (.task/.litertlm) z pliku tflite i tokenizera modelu.

Konwerter generatywny Torch konwertuje tylko na potrzeby procesora i wymaga komputera z systemem Linux i co najmniej 64 GB pamięci RAM.

Aby utworzyć pakiet zadań, użyj skryptu pakietu, aby utworzyć pakiet zadań. Proces pakowania łączy zamapowany model z dodatkowymi metadanymi (np. Parametry tokenizera) potrzebne do przeprowadzenia kompleksowego wnioskowania.

Proces pakowania modelu wymaga pakietu MediaPipe PyPI. Skrypt konwersji jest dostępny we wszystkich pakietach MediaPipe po 0.10.14.

Zainstaluj i zaimportuj zależności, wykonując te czynności:

$ python3 -m pip install mediapipe

Użyj biblioteki genai.bundler, aby spakować model:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Dostosowywanie LoRA

Obsługa LoRA w interfejsie LLM Inference API działa w przypadku wszystkich wariantów modeli Gemma i Phi-2 na backendzie GPU, a wagi LoRA mają zastosowanie tylko do warstw uwagi. Ta wstępna implementacja służy jako eksperymentalny interfejs API do przyszłych prac rozwojowych. W kolejnych aktualizacjach planujemy dodać obsługę większej liczby modeli i różnych typów warstw.

Przygotowywanie modeli LoRA

Postępuj zgodnie z instrukcjami na platformie HuggingFace, aby wytrenować dostrojony model LoRA na własnym zbiorze danych z obsługiwanymi typami modeli: Gemma lub Phi-2. Modele Gemma-2 2B, Gemma 2B i Phi-2 są dostępne w HuggingFace w formacie safetensors. Interfejs LLM Inference API obsługuje tylko LoRA w przypadku warstw uwagi, więc podczas tworzenia elementu LoraConfig należy określić tylko warstwy uwagi w ten sposób:

# 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 dostrojone modele LoRA, które pasują do interfejsu LLM Inference API na platformie HuggingFace. Na przykład monsterapi/gemma-2b-lora-maths-orca-200k w przypadku modelu Gemma-2B i lole25/phi-2-sft-ultrachat-lora w przypadku modelu Phi-2.

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

Następnie musisz przekonwertować wagi modelu na format TensorFlow Lite Flatbuffer za pomocą pakietu MediaPipe Python. W ConversionConfig należy podać opcje modelu podstawowego oraz dodatkowe opcje LoRA. Pamiętaj, że interfejs API obsługuje wnioskowanie LoRA tylko w przypadku GPU, 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 TFLite flatbuffer: jeden dla modelu podstawowego, a drugi dla modelu LoRA.

Wnioskowanie na podstawie modelu LoRA

Interfejsy Web, Android i iOS LLM Inference API zostały zaktualizowane, aby obsługiwać wnioskowanie na podstawie modelu LoRA.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

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