Przewodnik po wnioskowaniu LLM dla witryn internetowych

.

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) całkowicie w do obsługi aplikacji internetowych. Dzięki niej możesz wykonywać takich jak generowanie tekstu, pobieranie informacji w języku naturalnym, i 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 internetowych.

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ładowa aplikacja LLM Inference API zapewnia podstawową implementację w JavaScript. Za pomocą tej przykładowej aplikacji możesz uzyskać tworzysz własną aplikację do generowania tekstu.

Dostęp do interfejsu LLM Inference API możesz uzyskać pod adresem GitHub.

Konfiguracja

W tej sekcji opisujemy najważniejsze czynności związane z konfigurowaniem środowiska programistycznego oraz w projektach kodu wyłącznie wykorzystujących LLM Inference API. Ogólne informacje na temat: skonfigurować środowisko programistyczne do korzystania z zadań MediaPipe, w tym: wymagań wersji platformy znajdziesz w przewodniku konfiguracji dla Sieć.

Zgodność z przeglądarką

Interfejs LLM Inference API wymaga przeglądarki internetowej zgodnej z WebGPU. Aby uzyskać pełną lista zgodnych przeglądarek – patrz przeglądarka GPU .

Pakiety JavaScript

Kod interfejsu LLM Inference API jest dostępny w @mediapipe/tasks-genai pakietu SDK. Biblioteki te możesz znaleźć i pobrać za pomocą linków podanych w Przewodnik po konfiguracji na platformie.

Zainstaluj wymagane pakiety na potrzeby lokalnego środowiska testowego:

npm install @mediapipe/tasks-genai

Aby wdrożyć to na serwerze, użyj usługi sieci dostarczania 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 MediaPipe LLM Inference API wymaga wytrenowanego modelu, który jest z nim zgodny. zadanie. W przypadku aplikacji internetowych model musi być zgodny z GPU.

Więcej informacji o dostępnych wytrenowanych modelach dla LLM Inference API znajdziesz w zadaniu zapoznaj się z sekcją Modele.

Pobierz model

Zanim zainicjujesz interfejs LLM Inference API, pobierz 1 z obsługiwanych modeli i zapisz plik w katalogu projektu:

  • Gemma Należąca do rodziny lekkich, nowoczesnych modeli otwartych stworzonych tych samych badań i technologii, których użyto do stworzenia Modele Gemini. Odpowiednie dla różnych zadania związane z generowaniem tekstu, w tym odpowiadanie na pytania, streszczenie, wyciągania wniosków. Pobierz wersję modelu Gemma 2B lub Gemma 7B.
  • Phi-2 2,7 mld parametrów. Transformer, najlepiej dopasowany do funkcji Question-Answer, czatu i kodu .
  • Falcon-RW-1B: 1 miliard modelowy model wyłącznie oparty na dekoderze parametrów, wytrenowany na 350 mld tokenów RefinedWeb.
  • StableLM-3B: 3 Model językowy oparty tylko na dekoderze parametrów został wstępnie wytrenowany na 1 bilionie parametrów tokenów różnorodnych zbiorów danych w języku angielskim i kodu.

Zalecamy używanie modelu Gemma 2B lub Gemma 7B, które są dostępne w Kaggle Modele i dostępne, w formacie, który jest już zgodny z interfejsem LLM Inference API. Jeśli używasz innego LLM, musisz przekonwertować go na Format dostosowany do MediaPipe. Więcej informacji o Gemmie: Strona Gemma Więcej informacji na temat innych dostępnych modeli znajdziesz w sekcji modeli z omówieniem zadania.

Konwertuj model na format MediaPipe

Konwersja modelu natywnego

Jeśli używasz zewnętrznego modelu LLM (Phi-2, Falcon lub StableLM) albo urządzenia innego niż Kaggle Gemma, użyj naszych skryptów konwersji, aby sformatować model zgodne z MediaPipe.

Proces konwersji modelu wymaga pakietu MediaPipe PyPI. Konwersja skrypt jest dostępny we wszystkich pakietach MediaPipe od 0.10.11.

Zainstaluj i zaimportuj zależności, korzystając z tych elementów:

$ python3 -m pip install mediapipe

Aby przekonwertować model, użyj biblioteki genai.converter:

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

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Aby przekonwertować model LoRA, element ConversionConfig powinien określać model podstawowy oraz dodatkowe opcje LoRA. Zwróć uwagę, że skoro tylko interfejs API obsługuje wnioskowanie o LoRA z użyciem GPU, 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.

Parametr Opis Akceptowane wartości
input_ckpt Ścieżka do pliku model.safetensors lub pytorch.bin. Pamiętaj, że czasami format Safetensors modelu jest czasami dzielony na wiele plików, np. model-00001-of-00003.safetensors, model-00001-of-00003.safetensors. Możesz podać wzorzec pliku, na przykład model*.safetensors. ŚCIEŻKA
ckpt_format Format pliku modelu. {"safetensors", "pytorch"}
model_type Konwertowany LLM. {&quot;PHI_2&quot;, &quot;FALCON_RW_1B&quot;, &quot;STABLELM_4E1T_3B&quot;, &quot;GEMMA_2B&quot;}
backend Procesor (przekazany) używany do uruchomienia modelu. {&quot;cpu&quot;, &quot;gpu&quot;}
output_dir Ścieżka do katalogu wyjściowego, który hostuje pliki wagi poszczególnych warstw. ŚCIEŻKA
output_tflite_file Ścieżka do pliku wyjściowego. Na przykład „model_cpu.bin” lub „model_gpu.bin”. Ten plik jest zgodny tylko z interfejsem LLM Inference API i nie można go używać jako ogólnego pliku tflite. ŚCIEŻKA
vocab_model_file Ścieżka do katalogu, w którym są przechowywane: tokenizer.json oraz Pliki: tokenizer_config.json. W przypadku Gemma wskaż pojedynczy plik tokenizer.model. ŚCIEŻKA
lora_ckpt Ścieżka do pliku ckpt zabezpieczeń LoRA zawierającego wagę adaptera LoRA. ŚCIEŻKA
lora_rank Liczba całkowita określająca rangę ckpt LoRA. Wymagane do przeliczania wag lora. Jeśli nie zostanie podany, konwerter zakłada, że nie ma wag LoRA. Uwaga: tylko backend z GPU obsługuje LoRA. Liczba całkowita
lora_output_tflite_file Nazwa wyjściowego pliku tflite dla wagi LoRA. ŚCIEŻKA

Konwersja modelu AI Edge

Jeśli używasz LLM zmapowanego na model TFLite za pomocą AI Edge, użyj naszego skrypt łączenia, aby utworzyć pakiet zadań. Proces grupowania obejmuje zmapowany model z dodatkowymi metadanymi (np. (parametry tokenizera) potrzebne aby przeprowadzić pełne wnioskowanie.

Proces grupowania modeli wymaga pakietu MediaPipe PyPI. Konwersja skrypt jest dostępny we wszystkich pakietach MediaPipe od 0.10.14.

Zainstaluj i zaimportuj zależności, korzystając z tych elementów:

$ python3 -m pip install mediapipe

Użyj biblioteki genai.bundler, aby połączyć 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)
Parametr Opis Akceptowane wartości
tflite_model Ścieżka do modelu TFLite wyeksportowanego z AI Edge. ŚCIEŻKA
tokenizer_model Ścieżka do modelu tokenizacji SentencePiece. ŚCIEŻKA
start_token Token początkowy konkretnego modelu. Token początkowy musi znajdować się w udostępniony model tokenizacji. CIĄG ZNAKÓW
stop_tokens Tokeny zatrzymania dotyczące konkretnego modelu. Tokeny zatrzymania muszą znajdować się w udostępniony model tokenizacji. LISTA[STRING]
output_filename Nazwa wyjściowego pliku pakietu zadań. ŚCIEŻKA

Dodaj model 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ą obiektu baseOptions modelAssetPath :

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

Tworzenie zadania

Użyj jednej z funkcji createFrom...() interfejsu LLM Inference API, aby przygotować zadanie prowadzone zależności. Funkcji createFromModelPath() możesz używać z parametrem ścieżkę względną lub bezwzględną do pliku wytrenowanego modelu. W przykładowym kodzie użyto funkcji createFromOptions(). Więcej informacji na temat dostępnych zapoznaj się z sekcją Opcje konfiguracji.

Poniższy kod ilustruje, 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

To zadanie zawiera te opcje konfiguracji aplikacji internetowych i JavaScript:

Nazwa opcji Opis Zakres wartości Wartość domyślna
modelPath Ścieżka do miejsca, w którym model jest przechowywany w katalogu projektu. ŚCIEŻKA Nie dotyczy
maxTokens Maksymalna liczba tokenów (tokenów wejściowych + tokenów wyjściowych) obsługiwanych przez model. Liczba całkowita 512
topK Liczba tokenów uwzględnianych przez model na każdym etapie generowania. Ogranicza prognozy do k najbardziej prawdopodobnych tokenów. Liczba całkowita 40
temperature Wielkość losowości wprowadzonej podczas generowania. Wyższa wartość poprawia kreatywność generowanego tekstu, a niższa temperatura zapewnia bardziej przewidywalne generowanie. Liczba zmiennoprzecinkowa 0,8
randomSeed Losowy wynik wyjściowy używany podczas generowania tekstu. Liczba całkowita 0
loraRanks Poziomy LoRA używane przez modele LoRA w czasie działania. Uwaga: ta funkcja jest zgodna tylko z modelami GPU. Tablica całkowita Nie dotyczy

Przygotuj dane

Interfejs LLM Inference API akceptuje dane tekstowe (string). 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(). Jest nie ma potrzeby dodatkowego wstępnego przetwarzania 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 aktywowania wnioskowania. W przypadku klasyfikacji tekstu oznacza to zwrócenie możliwych kategorii dla atrybutu tekst do wprowadzania danych.

Ten kod pokazuje, jak wykonać przetwarzanie za pomocą zadania model atrybucji.

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

Aby to zrobić strumieniowo, użyj tych opcji:

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 zawierający 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.

Internet obsługuje dynamiczne LoRA w czasie działania. Oznacza to, że użytkownicy deklarują rankingi LoRA, które będą używane podczas inicjowania, i będą mogli zmieniać 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 działania po zainicjowaniu modelu podstawowego wczytuj modele LoRA, które mają być używane. Dodatkowo aktywuj model LoRA, przekazując odwołanie do modelu LoRA podczas generowania odpowiedzi LLM.

// 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;
});