Przewodnik dotyczący wnioskowania na podstawie LLM

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) całkowicie na urządzeniu. Można go używać do wykonywania wielu zadań, takich jak generowanie tekstu, pobieranie informacji w formie języka naturalnego czy streszczanie dokumentów. Zadanie zapewnia 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ądzeniach w swoich aplikacjach i usługach.

Wypróbuj to!arrow_forward

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 możesz 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. Modele przekonwertowane za pomocą AI Edge Torch mogą działać tylko na procesorze CPU, dlatego są ograniczone do Androida i iOS.

Rozpocznij

Aby zacząć korzystać z tego zadania, postępuj zgodnie z jednym z tych przewodników dotyczących wdrażania na platformie docelowej. Te przewodniki dotyczące poszczególnych platform zawierają podstawowe informacje o wdrażaniu tego zadania, a także 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 opisano możliwości, dane wejściowe i wyjściowe oraz opcje konfiguracji związane z tym zadaniem.

Funkcje

Interfejs LLM Inference API zawiera te najważniejsze funkcje:

1. generowanie tekstu na podstawie tekstu – generowanie tekstu na podstawie prompta tekstowego;
2. Wybór modelu LLM – użyj wielu modeli, aby dostosować aplikację do konkretnych zastosowań. Możesz też przeprowadzić ponowne uczenie i zastosować do modelu niestandardowe wagi.
3. Obsługa LoRA – rozszerzanie i dostosowywanie możliwości LLM za pomocą modelu LoRA albo przez trenowanie na całym zbiorze danych, albo przez pobranie gotowych modeli LoRA z otwartej społeczności (niezgodne 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 tekst-tekst, w tym wbudowane wsparcie dla kilku modeli zoptymalizowanych pod kątem działania w przeglądarkach i na urządzeniach mobilnych. Te lekkie modele można stosować do wykonywania wnioskowań bezpośrednio na urządzeniu.

Zanim zainicjujesz interfejs LLM Inference API, pobierz model i zapisz go w katalogu projektu. Możesz użyć wstępnie przekonwertowanego modelu lub przekonwertować model do formatu zgodnego z 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.

Gemma-2 2B

Gemma-2 2B to najnowszy model z rodziny Gemma, czyli rodziny lekkich, otwartych modeli opartych na najnowszych badaniach i technologiach, które posłużyły do stworzenia modeli Gemini. Model zawiera 2 mld parametrów i otwarte wartości wag. Gemma-2 2B to model o najnowocześniejszych umiejętnościach wnioskowania w swojej klasie.

Pobierz Gemma-2 2B

Modele Gemma-2 2B są dostępne w tych wariantach:

• gemma2-2b-it-cpu-int8: model Gemma-2 2B 8-bitowy z obsługą procesorów.
• gemma2-2b-it-gpu-int8: model Gemma-2 2B 8-bitowy z obsługą GPU.

Możesz też dostosować model i dodać nowe wagi, zanim dodasz go do aplikacji. Więcej informacji o dostosowywaniu i korzystaniu z Gemma znajdziesz w artykule Dostosowanie Gemma. Po pobraniu modelu Gemma-22B z Kaggle Models model jest już w odpowiednim formacie do użycia w MediaPipe Tasks.

Gemma 2B

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 zawiera 2 mld. parametrów i otwarte wagi. Ten model dobrze sprawdza się w różnych zadaniach związanych z generowaniem tekstu, takich jak odpowiadanie na pytania, streszczanie i wyciąganie wniosków.

Pobierz Gemma 2B

Modele Gemma 2B są dostępne w tych wariantach:

• gemma-2b-it-cpu-int4: model Gemma 2B 4-bitowy z obsługą procesorów.
• gemma-2b-it-cpu-int8: model Gemma 2B 8-bitowy z kompatybilnością z procesorem.
• gemma-2b-it-gpu-int4: model Gemma 2B 4-bitowy z obsługą GPU.
• gemma-2b-it-gpu-int8: model Gemma 2B 8-bitowy z obsługą GPU.

Możesz też dostosować model i dodać nowe wagi, zanim dodasz go do aplikacji. Więcej informacji o dostosowywaniu i korzystaniu z Gemma znajdziesz w artykule Dostosowanie Gemma. Po pobraniu modelu Gemma 2B z Kaggle Models jest on już w odpowiednim formacie do użycia w MediaPipe Tasks.

Gemma 7B

Gemma 7B to większy model Gemma z parametrami 7B i otwartymi wagami. Model jest bardziej wydajny w przypadku różnych zadań związanych z generowaniem tekstu, w tym odpowiadania na pytania, streszczania i rozumowania. Gemma 7B jest obsługiwana tylko w internecie.

Pobierz Gemma 7B

Model Gemma 7B występuje w jednym wariancie:

• gemma-1.1-7b-it-gpu-int8: model Gemma 7B 8-bitowy z obsługą GPU.

Po pobraniu modelu Gemma 7B z Kaggle Models jest on już w odpowiednim formacie do użycia z MediaPipe.

Falcon 1B

Falcon-1B to model z 1 miliardem parametrów i z samym dekoderem, wytrenowany na 350 mld tokenów RefinedWeb.

Pobierz Falcon 1B

Interfejs API LLM Inference wymaga pobrania i zapisania lokalnie tych plików:

• tokenizer.json
• tokenizer_config.json
• pytorch_model.bin

Po pobraniu plików modelu Falcon można przekonwertować model do formatu MediaPipe za pomocą skryptu konwersji. Wykonaj czynności opisane w sekcji Skrypt konwersji dla obsługiwanych modeli.

StableLM 3B

StableLM-3B to model językowy z 3 mld parametrów, który jest dekoderem i został wstępnie wytrenowany na podstawie 1 biliona tokenów z różnorodnych zbiorów danych z różnymi językami i kodem na przestrzeni 4 epoch.

Pobierz StableLM 3B

Interfejs API LLM Inference wymaga pobrania i zapisania lokalnie tych plików:

• tokenizer.json
• tokenizer_config.json
• model.safetensors

Po pobraniu plików modelu StableLM możesz przekonwertować go do formatu MediaPipe za pomocą skryptu konwersji. Wykonaj czynności opisane w sekcji Skrypt konwersji dla obsługiwanych modeli.

Phi-2

Phi-2 to model transformera z 2,7 mld parametrów. Został on wytrenowany na podstawie różnych syntetycznych tekstów NLP i odfiltrowanych stron internetowych. Model najlepiej nadaje się do promptów korzystających z formatu pytania i odpowiedzi, czatu i kodu.

Pobierz Phi-2

Interfejs API LLM Inference wymaga pobrania i zapisania lokalnie tych plików:

• tokenizer.json
• tokenizer_config.json
• model-00001-of-00002.safetensors
• model-00002-of-00002.safetensors

Po pobraniu plików modelu Phi-2 możesz przekonwertować model do formatu MediaPipe za pomocą skryptu konwersji. Wykonaj czynności opisane w sekcji Skrypt konwersji dla obsługiwanych modeli.

Generatywne modele PyTorch

Modele generatywne PyTorch można przekonwertować do formatu zgodnego z MediaPipe za pomocą interfejsu AI Edge Torch Generative API. Za pomocą interfejsu API możesz konwertować modele PyTorch na modele LiteRT (TensorFlow Lite) z wieloma podpisami. Więcej informacji o mapowaniu i eksportowaniu modeli znajdziesz na stronie AI Edge Torch na GitHub.

Jeśli chcesz użyć interfejsu AI Edge Torch Generative API do konwertowania modelu PyTorch, wykonaj czynności opisane w sekcji Konwerter Torch Generative na potrzeby modeli PyTorch.

Konwersja modelu

Interfejs MediaPipe LLM Inference API umożliwia uruchamianie na urządzeniu wielu różnych dużych modeli językowych. Obejmuje to modele, które zostały wstępnie przekonwertowane do formatu zgodnego z MediaPipe, a także inne modele, które można przekonwertować za pomocą skryptu konwersji lub biblioteki AI Edge Torch.

Interfejs API wnioskowania opartego na LLM akceptuje modele w formatach plików .bin i .task. Modele przekonwertowane wcześniej i modele przekonwertowane za pomocą skryptu do konwertowania będą plikami .bin, a modele przekonwertowane za pomocą biblioteki AI Edge Torch będą plikami .task. Nie zmieniaj ręcznie formatów plików przekonwertowanych modeli.

Interfejs LLM Inference API zawiera 3 ścieżki konwersji modelu:

• Modele wstępnie przekonwertowane (Gemma 2B, Gemma 7B, Gemma-2 2B): konwersja nie jest wymagana.
• Obsługiwane modele (Phi-2, StableLM, Falcon): skrypt konwersji MediaPipe.
• Inne modele PyTorch (wszystkie modele LLM PyTorch): interfejs Torch Generative API.

Wstępnie przekonwertowane modele

Modele Gemma-2 2B, Gemma 2B i Gemma 7B są dostępne jako wstępnie przekonwertowane modele w formacie MediaPipe. Modele te nie wymagają od użytkownika żadnych dodatkowych czynności konwertowania i można je uruchamiać w postaci niezmienionej za pomocą interfejsu LLM Inference API.

Model Gemma-2 2B możesz pobrać z Kaggle Models:

• gemma2-2b-it-cpu-int8: model Gemma-2 2B 8-bitowy z obsługą procesorów.
• gemma2-2b-it-gpu-int8: model Gemma-2 2B 8-bitowy z obsługą GPU.

Warianty Gemma 2B możesz pobrać z Kaggle Models:

• gemma-2b-it-cpu-int4: model Gemma 2B 4-bitowy z obsługą procesorów.
• gemma-2b-it-cpu-int8: model Gemma 2B 8-bitowy z kompatybilnością z procesorem.
• gemma-2b-it-gpu-int4: model Gemma 2B 4-bitowy z obsługą GPU.
• gemma-2b-it-gpu-int8: model Gemma 2B 8-bitowy z obsługą GPU.

Model Gemma 7B możesz pobrać z Kaggle Models:

• gemma-1.1-7b-it-gpu-int8: model Gemma 7B 8-bitowy z obsługą GPU.

Więcej informacji o modelach Gemma znajdziesz w dokumentacji dotyczącej Gemma-2 2B, Gemma 2B i Gemma 7B.

Skrypt konwersji dla obsługiwanych modeli

Pakiet MediaPipe zawiera skrypt konwersji, który umożliwia konwertowanie tych zewnętrznych modeli na format zgodny z MediaPipe:

• Falcon 1B
• StableLM 3B
• Phi-2

Więcej informacji o obsługiwanych modelach zewnętrznych znajdziesz w dokumentacji dotyczącej Falcon 1B, StableLM 3B i Phi-2.

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

Zainstaluj i zaimportuj zależności za pomocą:

$ 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, w elementach ConversionConfig należy określić opcje modelu podstawowego oraz dodatkowe opcje LoRA. Pamiętaj, że interfejs API obsługuje wnioskowanie LoRA tylko z procesorem graficznym, 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.

Konwerter Torch Generative do modeli PyTorch

Modele generatywne PyTorch można przekonwertować do formatu zgodnego z MediaPipe za pomocą interfejsu AI Edge Torch Generative API. Za pomocą interfejsu API możesz tworzyć, konwertować i kwantować modele LLM PyTorch, aby używać ich z interfejsem LLM Inference API. Konwerter Torch Generative konwertuje tylko na procesor i wymaga maszyny z systemem Linux z co najmniej 64 GB pamięci RAM.

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

1. Pobieranie punktów kontrolnych modelu PyTorch
2. Użyj interfejsu AI Edge Torch Generative API, aby utworzyć, przekonwertować i zquantized model do formatu zgodnego z MediaPipe (.tflite).
3. Utwórz pakiet zadań (.task) z pliku tflite i tokenizera modelu.

Aby utworzyć pakiet zadań, użyj skryptu pakowania, aby utworzyć pakiet zadań. Proces grupowania łączy zmapowany model z dodatkowymi metadanymi (np. Parametry analizatora potrzebne do przeprowadzenia pełnego wnioskowania.

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

Zainstaluj i zaimportuj zależności za pomocą:

$ python3 -m pip install mediapipe

Aby połączyć model z biblioteką genai.bundler:

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 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.

// 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 z LoRA, użyj tych samych metod generateResponse() lub generateResponseAsync() co w przypadku modelu podstawowego.