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 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-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ą AI Edge Torch możesz eksportować modele PyTorch do modeli LiteRT z wieloma sygnaturami (tflite), które są dołączane do parametrów tokenizatora w celu tworzenia pakietów zadań. Modele przekonwertowane za pomocą AI Edge 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ą podstawową implementację tego zadania wraz z przykładami 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 przez trenowanie na całym zbiorze danych lub korzystanie z gotowych modeli LoRA z społeczności open source (nie jest zgodne z modelami przekonwertowanymi za pomocą interfejsu AI Edge 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 na 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ą służyć 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 społeczności LiteRT w Hugging Face lub przekonwertować model na format zgodny z MediaPipe za pomocą konwertera generatywnego AI Edge Torch.

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 lekkich, zaawansowanych modeli otwartych Gemma, 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 efektywnej liczbie parametrów wynoszącej 2 mld i 4 mld, 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 otwartych modeli Gemma, które powstały na podstawie tych samych badań i technologii, co modele 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ę o niskim stopniu (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 AI Edge Torch Generative API. Za pomocą interfejsu API możesz przekonwertować modele PyTorch na modele LiteRT z wieloma sygnaturami (TensorFlow Lite). Więcej informacji o mapowaniu i eksportowaniu modeli znajdziesz na stronie AI Edge Torch na GitHubie.

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

1. Pobierz punkty kontrolne modelu PyTorch.
2. Użyj interfejsu AI Edge 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 wnioskowania od początku do końca.

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 LoraConfig określaj 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 dostosowane modele LoRA, które pasują do interfejsu LLM Inference API dostępnego 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 na 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 flatbuffer TFLite: jeden dla modelu podstawowego, a drugi dla modelu LoRA.

Wnioskowanie modelu LoRA

Interfejsy API do wnioskowania na podstawie dużych modeli językowych w internecie, na Androidzie i iOS zostały zaktualizowane, aby obsługiwać wnioskowanie na podstawie modeli 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.