Przedstawiamy LiteRT: wydajne środowisko wykonawcze Google do obsługi AI na urządzeniu, wcześniej znane jako TensorFlow Lite.

Ta strona została przetłumaczona przez Cloud Translation API.

Przewodnik po wnioskowaniu LLM dla witryn internetowych

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

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

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ładowa aplikacja dla interfejsu LLM Inference API zawiera podstawową implementację tego zadania w języku JavaScript. Możesz użyć tej przykładowej aplikacji, aby rozpocząć tworzenie własnej aplikacji do generowania tekstu.

Przykładową aplikację korzystającą z interfejsu LLM Inference API znajdziesz na GitHubzie.

Konfiguracja

Ta sekcja opisuje kluczowe kroki konfigurowania środowiska programistycznego i projektów kodu w celu używania interfejsu LLM Inference API. Informacje ogólne o konfigurowaniu środowiska programistycznego na potrzeby korzystania z MediaPipe Tasks, w tym wymagania dotyczące wersji platformy, znajdziesz w przewodniku konfiguracji dla przeglądarki internetowej.

Zgodność z przeglądarką

Interfejs LLM Inference API wymaga przeglądarki internetowej zgodnej z WebGPU. Pełną listę zgodnych przeglądarek znajdziesz w sekcji Zgodność przeglądarek z GPU.

Pakiety JavaScript

Kod interfejsu LLM Inference API jest dostępny w pakiecie @mediapipe/tasks-genai. Te biblioteki znajdziesz i pobierzesz, klikając linki podane w przewodniku po konfiguracji platformy.

Zainstaluj wymagane pakiety do lokalnego publikowania:

npm install @mediapipe/tasks-genai

Aby wdrożyć na serwerze, użyj usługi sieci dystrybucji treści (CDN), takiej jak jsDelivr, aby dodać kod bezpośrednio do strony HTML:

<head>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
    crossorigin="anonymous"></script>
</head>

Model

Interfejs API MediaPipe LLM Inference wymaga wytrenowanego modelu, który jest zgodny z tym zadaniem. W przypadku aplikacji internetowych model musi być zgodny z procesorem GPU.

Więcej informacji o dostępnych wytrenowanych modelach interfejsu LLM Inference API znajdziesz w sekcji Modele w omówieniu zadania.

Pobieranie modelu

Zanim zainicjujesz interfejs LLM Inference API, pobierz jeden z obsługiwanych modeli i przechowuj plik w katalogu projektu. Zalecamy użycie Gemma-2 2B, która jest dostępna na Kaggle Models.

Możesz też pobrać jedną z innych obsługiwanych wersji:

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. Dobrze nadaje się do różnych zadań związanych z generowaniem tekstu, w tym do odpowiadania na pytania, podsumowywania i rozumowania.
Gemma-31B: najnowszy model z rodziny Gemma, czyli lekka, zaawansowana, otwarta i oparta na najnowszych osiągnięciach nauka, która powstała na podstawie tych samych badań i technologii, co modele Gemini. Model zawiera 1 mld. Wersja 1B to najlżejszy model w rodzinie Gemma, dzięki czemu doskonale nadaje się do wielu zastosowań na urządzeniu. Zanim zaczniesz używać tego modelu, zapoznaj się z sekcją Omówienie modelu, aby dowiedzieć się, jakie wymagania dotyczące konfiguracji modelu musisz spełnić.
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.

Więcej informacji o dostępnych modelach znajdziesz w sekcji Modele w omówieniu zadania.

Konwertowanie modelu na format MediaPipe

Interfejs API wnioskowania 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.

Modele	Metoda konwersji	Zgodne platformy	Typ pliku
Gemma-3 1B	Konwersja nie jest wymagana	Android, internet	.task
Gemma 2B, Gemma 7B, Gemma-2 2B	Konwersja nie jest wymagana	Android, iOS, internet	.bin
Phi-2, StableLM, Falcon	Skrypt konwersji MediaPipe	Android, iOS, internet	.bin
Wszystkie modele LLM PyTorch	Biblioteka generatywnej AI Edge Torch	Android, iOS	.task

Więcej informacji o konwertowaniu innych modeli znajdziesz w sekcji Model konwersji.

Dodawanie modelu do katalogu projektu

Zapisz model w katalogu projektu:

<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin

Określ ścieżkę modelu za pomocą parametru baseOptions obiektu modelAssetPath:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}

Tworzenie zadania

Aby przygotować zadanie do wykonywania wnioskowań, użyj jednej z funkcji interfejsu LLM Inference API createFrom...(). Funkcję createFromModelPath() możesz użyć z względną lub bezwzględną ścieżką do wytrenowanego pliku modelu. Przykładowy kod używa funkcji createFromOptions(). Więcej informacji o dostępnych opcjach konfiguracji znajdziesz w artykule Opcje konfiguracji.

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

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
    baseOptions: {
        modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

Opcje konfiguracji

W tym zadaniu dostępne są te opcje konfiguracji aplikacji internetowych i aplikacji w języku JavaScript:

Nazwa opcji	Opis	Zakres wartości	Wartość domyślna
`modelPath`	Ścieżka do miejsca przechowywania modelu w katalogu projektu.	ŚCIEŻKA	Nie dotyczy
`maxTokens`	Maksymalna liczba tokenów (tokenów wejściowych + tokenów wyjściowych), którą obsługuje model.	Liczba całkowita	512
`topK`	Liczba tokenów, które model bierze pod uwagę na każdym etapie generowania. Ogranicza prognozy do k najbardziej prawdopodobnych tokenów.	Liczba całkowita	40
`temperature`	Ilość losowości wprowadzonej podczas generowania. Wyższa temperatura powoduje większą kreatywność wygenerowanego tekstu, a niższa – bardziej przewidywalne generowanie.	Liczba zmiennoprzecinkowa	0,8
`randomSeed`	Losowe nasiono użyte podczas generowania tekstu.	Liczba całkowita	0
`loraRanks`	Rankingi LoRA używane przez modele LoRA podczas wykonywania. Uwaga: ta funkcja jest zgodna tylko z modelami GPU.	Tablica liczb całkowitych	Nie dotyczy

Przygotuj dane

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

Cała wstępna obróbka danych jest wykonywana w ramach funkcji generateResponse(). Nie musisz dodatkowo przetwarzać tekstu wejściowego.

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

Uruchamianie zadania

Interfejs LLM Inference API używa funkcji generateResponse() do wywoływania wnioskowań. W przypadku klasyfikacji tekstu oznacza to zwrócenie możliwych kategorii dla tekstu wejściowego.

Poniższy kod pokazuje, jak wykonać przetwarzanie za pomocą modelu zadania.

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

Aby przesyłać strumieniowo odpowiedź, użyj:

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

Obsługa i wyświetlanie wyników

Interfejs LLM Inference API zwraca ciąg znaków, który 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]

Dostosowywanie modelu LoRA

Interfejs API Mediapipe do wnioskowania na podstawie LLM można skonfigurować tak, aby obsługiwał adaptację niskiego rzędu (LoRA) w przypadku 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 ramach interfejsu API LLM Inference działa w przypadku wszystkich wariantów Gemma i modeli Phi-2 na backendzie GPU, przy czym wagi LoRA są stosowane tylko do warstw uwagi. Ta początkowa implementacja jest eksperymentalnym interfejsem API, który posłuży do przyszłych prac nad obsługą większej liczby modeli i różnych typów warstw w przyszłych aktualizacjach.

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 TensorFlow Lite Flatbuffer 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.

W czasie działania usługa internetowa obsługuje dynamiczne LoRA. Oznacza to, że użytkownicy deklarują hierarchie LoRA, które mają być używane podczas inicjalizacji, oraz mogą przełączać różne modele LoRA w czasie działania.

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
    // options for the base model
    ...
    // LoRA ranks to be used by the LoRA models during runtime
    loraRanks: [4, 8, 16]
});

W czasie wykonywania, po zainicjowaniu modelu podstawowego, wczytaj modele LoRA, których chcesz użyć. Podczas generowania odpowiedzi LLM wywołaj model LoRA, przekazując odwołanie do tego modelu.

// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);

// Specify LoRA model to be used during inference
llmInference.generateResponse(
  inputPrompt,
  loraModelRank4,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});