Interfejs LLM Inference API pozwala uruchamiać duże modele językowe (LLM) całkowicie na urządzeniu. Można ich używać do wykonywania różnorodnych zadań, takich jak generowanie tekstu, pobieranie informacji w formie języka naturalnego i podsumowywanie dokumentów. To zadanie ma wbudowaną obsługę wielu dużych modeli językowych obsługujących tekst na tekst, dzięki czemu możesz stosować w swoich aplikacjach i usługach najnowsze modele generatywnej AI działające na urządzeniu.
Zadanie obsługuje modele Gemma 2B i 7B, które wchodzą w skład rodziny lekkich, najnowocześniejszych otwartych modeli stworzonych na podstawie tych samych badań i technologii, które służyły do tworzenia modeli Gemini. Obsługuje też te modele zewnętrzne: Phi-2, Falcon-RW-1B i StableLM-3B.
Oprócz modeli obsługiwanych natywnie użytkownicy mogą też mapować inne modele za pomocą naszej oferty AI Edge (w tym mapowania modeli PyTorch). Dzięki temu użytkownicy mogą eksportować zmapowany model do modeli TensorFlow Lite z wieloma podpisami, które są połączone z parametrami tokenizowania w celu utworzenia pakietu zadań.
Rozpocznij
Zacznij od wykonania tego zadania, postępując zgodnie z instrukcjami podanymi w jednym z przewodników po implementacji dla platformy docelowej. Te przewodniki dotyczące poszczególnych platform przeprowadzą Cię przez podstawową implementację tego zadania wraz z przykładami kodu, w których wykorzystuje się dostępny model, i zalecanymi opcjami konfiguracji:
Sieć:
Android:
iOS
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 zawiera te najważniejsze funkcje:
- Generowanie tekstu na tekst – generowanie tekstu na podstawie promptu z wpisanym tekstem.
- Wybór modelu LLM – możesz stosować wiele modeli, aby dostosować aplikację do konkretnych przypadków użycia. Możesz też ponownie wytrenować model i zastosować do niego niestandardowe wagi.
- Obsługa LoRA – rozszerzaj i dostosowuj możliwości LLM za pomocą modelu LoRA przez trenowanie na całym zbiorze danych lub przy użyciu gotowych modeli LoRA pochodzących ze społeczności open source (tylko modele natywne).
Dane wejściowe zadań | Wyniki działania |
---|---|
Interfejs LLM Inference API akceptuje te dane wejściowe:
|
Interfejs LLM Inference API zwraca te wyniki:
|
Opcje konfiguracji
To zadanie ma te opcje konfiguracji:
Nazwa opcji | Opis | Zakres wartości | Wartość domyślna |
---|---|---|---|
modelPath |
Ścieżka do miejsca, w którym model jest przechowywany w katalogu projektu. | PATH | Nie dotyczy |
maxTokens |
Maksymalna liczba tokenów (tokeny wejściowe + tokeny wyjściowe) 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. Przy ustawieniu topK musisz też ustawić wartość randomSeed . |
Liczba całkowita | 40 |
temperature |
Ilość losowości wprowadzonej podczas generowania. Wyższa temperatura zwiększa kreatywność w generowaniu tekstu, a niższa – bardziej przewidywalny generowanie tekstu. Przy ustawieniu temperature musisz też ustawić wartość randomSeed . |
Liczba zmiennoprzecinkowa | 0,8 |
randomSeed |
Losowy materiał wyjściowy używany podczas generowania tekstu. | Liczba całkowita | 0 |
loraPath |
Ścieżka bezwzględna do modelu LoRA lokalnie na urządzeniu. Uwaga: ta funkcja jest zgodna tylko z modelami GPU. | PATH | Nie dotyczy |
resultListener |
Konfiguruje detektor wyników, aby asynchronicznie otrzymywać wyniki. Ma zastosowanie tylko w przypadku korzystania z metody generowania asynchronicznego. | Nie dotyczy | Nie dotyczy |
errorListener |
Ustawia opcjonalny detektor błędów. | Nie dotyczy | Nie dotyczy |
Modele
Interfejs LLM Inference API ma wbudowaną obsługę dużych modeli językowych (LLM) zoptymalizowanych pod kątem przeglądarek i urządzeń mobilnych. Te lekkie modele można pobrać, aby całkowicie wnioskować na urządzeniu.
Zanim zainicjujesz interfejs LLM Inference API, pobierz jeden z obsługiwanych modeli i zapisz plik w katalogu projektu.
Gemma 2B
Gemma 2B to część rodziny lekkich, najnowocześniejszych otwartych modeli stworzonych na podstawie tych samych badań i technologii, które są wykorzystywane do tworzenia 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 rozumowanie.
Modele Gemma 2B są dostępne w 4 wersjach:
- gemma-2b-it-cpu-int4: 4-bitowy model Gemma 2B ze zgodnym procesorem.
- gemma-2b-it-cpu-int8: 8-bitowy model Gemma 2B ze zgodnym procesorem.
- gemma-2b-it-gpu-int4: 4-bitowy model Gemma 2B zgodny z GPU.
- gemma-2b-it-gpu-int8: 8-bitowy model Gemma 2B zgodny z GPU.
Możesz też dostroić model i dodać nowe wagi przed dodaniem go do aplikacji. Więcej informacji o dostrajaniu i dostosowywaniu Gemma znajdziesz w artykule Dostrajanie Gemma. Po pobraniu Gemma z Kaggle Models model jest już w odpowiednim formacie do użycia z MediaPipe.
Jeśli pobierzesz Gemma 2B z usługi Hugging Face, musisz przekonwertować model na format zgodny z MediaPipe. Pobranie i skonwertowanie interfejsu LLM Inference API wymaga następujących plików:
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors
tokenizer.json
tokenizer_config.json
Gemma 7B
Gemma 7B to większy model Gemma z 7 mld parametrów i otwartych wag. Model jest wydajniejszy w przypadku różnych zadań generowania tekstu, takich jak odpowiadanie na pytania, streszczanie i rozumowanie. Aplikacja Gemma 7B jest obsługiwana tylko w przeglądarce.
Model Gemma 7B jest dostępny w jednym wariancie:
- gemma-1.1-7b-it-gpu-int8: 8-bitowy model Gemma 7B zgodny z GPU.
Jeśli pobierzesz Gemma 7B od Hugging Face, musisz przekonwertować model na format zgodny z MediaPipe. Interfejs LLM Inference API wymaga pobrania i przekonwertowania tych plików:
model-00001-of-00004.safetensors
model-00002-of-00004.safetensors
model-00003-of-00004.safetensors
model-00004-of-00004.safetensors
tokenizer.json
tokenizer_config.json
Falcon 1B
Falcon-1B to model z samym dekoderem przyczynowo-skutkowym zawierający 1 miliard parametrów wytrenowany na 350 mld tokenów RefinedWeb.
Interfejs LLM Inference API wymaga lokalnego pobrania i przechowywania tych plików:
tokenizer.json
tokenizer_config.json
pytorch_model.bin
Po pobraniu plików modelu Falcona model jest gotowy do przekonwertowania na format MediaPipe. Wykonaj czynności opisane w sekcji Konwertowanie modelu na format MediaPipe.
StableLM 3B
StableLM-3B to 3-miliardowy model językowy wykorzystujący tylko dekoder parametrów wytrenowany na 1 biliona tokenów różnorodnych zbiorów danych w języku angielskim i zbiorach danych kodu dla 4 etapów.
Interfejs LLM Inference API wymaga lokalnego pobrania i przechowywania tych plików:
tokenizer.json
tokenizer_config.json
model.safetensors
Po pobraniu plików modelu StableLM model jest gotowy do przekonwertowania na format MediaPipe. Wykonaj czynności opisane w sekcji Konwertowanie modelu na format MediaPipe.
Phi-2
Phi-2 to model transformera składający się z 2,7 miliarda parametrów. Zostało ono trenowane z wykorzystaniem różnych tekstów syntetycznych NLP i filtrowanych witryn. Model najlepiej sprawdza się w przypadku promptów w formacie Question-Answer, czatu i kodu.
Interfejs LLM Inference API wymaga lokalnego pobrania i przechowywania 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 model jest gotowy do przekonwertowania na format MediaPipe. Wykonaj czynności opisane w sekcji Konwertowanie modelu na format MediaPipe.
Modele wyeksportowane do AI Edge
AI Edge to oferta Google, która umożliwia konwertowanie modeli zmapowanych przez użytkownika na modele TensorFlow Lite z wieloma podpisami. Więcej informacji o mapowaniu i eksportowaniu modeli znajdziesz na stronie w GitHubie AI Edge Torch.
Po wyeksportowaniu modelu do formatu TFLite można go przekonwertować na format MediaPipe. Więcej informacji znajdziesz w sekcji Konwertowanie modelu na format MediaPipe.
Konwertuj model na format MediaPipe
Konwersja modelu natywnego
Jeśli korzystasz z zewnętrznego modelu LLM (Phi-2, Falcon lub StableLM) albo wersji Gemma innej niż Kaggle, użyj naszych skryptów konwersji, aby sformatować model tak, aby był zgodny z MediaPipe.
Proces konwersji modelu wymaga pakietu MediaPipe PyPI. Skrypt konwersji jest dostępny we wszystkich pakietach MediaPipe po 0.10.11
.
Zainstaluj i zaimportuj zależności:
$ python3 -m pip install mediapipe
Użyj biblioteki genai.converter
, aby przekonwertować model:
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, obiekt ConversionConfig
powinien określać opcje modelu podstawowego oraz dodatkowe opcje LoRA. Zwróć uwagę, że interfejs API obsługuje wnioskowanie LoRA tylko z 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 płaskie TFLite, jeden dla modelu podstawowego, a drugi dla modelu LoRA.
Parametr | Opis | Akceptowane wartości |
---|---|---|
input_ckpt |
Ścieżka do pliku model.safetensors lub pytorch.bin . Pamiętaj, że czasami format zabezpieczeń modelu jest podzielony na kilka plików, np. model-00001-of-00003.safetensors i model-00001-of-00003.safetensors . Możesz określić wzorzec pliku, np. model*.safetensors . |
PATH |
ckpt_format |
Format pliku modelu. | {"safetensors", "pytorch"} |
model_type |
Przekonwertowany LLM. | {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"} |
backend |
Procesor (przedstawiciel) używany do uruchomienia modelu. | {"cpu", "gpu"} |
output_dir |
Ścieżka do katalogu wyjściowego, w którym są hostowane pliki wag w poszczególnych warstwach. | PATH |
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że być używany jako ogólny plik „tflite”. | PATH |
vocab_model_file |
Ścieżka do katalogu, w którym są zapisane pliki tokenizer.json i tokenizer_config.json . W przypadku aplikacji Gemma wskaż pojedynczy plik tokenizer.model . |
PATH |
lora_ckpt |
Ścieżka do pliku klpt sejfów LoRA, w którym jest przechowywana waga adaptera LoRA. | PATH |
lora_rank |
Liczba całkowita określająca pozycję ckpt LoRA. Wymagane do przekonwertowania wag lora. Jeśli ich nie podasz, konwerter zakłada, że nie ma wag LoRA. Uwaga: tylko backend GPU obsługuje LoRA. | Liczba całkowita |
lora_output_tflite_file |
Wyjściowa nazwa pliku tflite wag LoRA. | PATH |
Konwersja modelu AI Edge
Jeśli używasz LLM zmapowanego na model TFLite za pomocą AI Edge, utwórz pakiet zadań za pomocą naszego skryptu tworzenia pakietów. Proces grupowania obejmuje zmapowany model dodatkowymi metadanymi (np. parametry tokenizatora) potrzebne do pełnego wnioskowania.
Proces grupowania modeli wymaga pakietu MediaPipe PyPI. Skrypt konwersji jest dostępny we wszystkich pakietach MediaPipe po 0.10.14
.
Zainstaluj i zaimportuj zależności:
$ 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 AI Edge wyeksportowanego z modelu TFLite. | PATH |
tokenizer_model |
Ścieżka do modelu tokenizatora SentencePiece. | PATH |
start_token |
Token początkowy konkretnego modelu. Token początkowy musi być obecny w podanym modelu tokenizatora. | CIĄG ZNAKÓW |
stop_tokens |
Tokeny zatrzymania dla konkretnego modelu. Tokeny zatrzymania muszą być obecne w podanym modelu tokenizatora. | LISTA[STRING] |
output_filename |
Nazwa wyjściowego pliku pakietu zadań. | PATH |
Dostosowanie LoRA
Interfejs Mediapipe LLM inference API można skonfigurować tak, aby obsługiwał adaptację niskiego rankingu (LoRA) w przypadku dużych modeli językowych. Dzięki dostrojonym modelom LoRA deweloperzy mogą dostosowywać działanie modeli LLM przy użyciu ekonomicznego procesu trenowania.Obsługa LoRA interfejsu LLM Inference API działa w przypadku modeli Gemma-2B oraz Phi-2 w backendzie GPU, przy czym wagi LoRA mają zastosowanie tylko do warstw uwagi. Ta wstępna implementacja służy jako eksperymentalny interfejs API na potrzeby przyszłych prac, a w kolejnych aktualizacjach planujemy obsługiwać więcej modeli i różne typy warstw.
Przygotuj modele LoRA
Wykonaj instrukcje w HugingFace, aby wytrenować dostrojony model LoRA na własnym zbiorze danych z obsługiwanymi typami modeli: Gemma-2B lub Phi-2. Modele Gemma-2B i Phi-2 są dostępne w HuggingFace w formacie Safetensors. Interfejs LLM Inference API obsługuje tylko LoRA w warstwach uwagi, dlatego podczas tworzenia obiektu LoraConfig
określ tylko warstwy uwagi:
# 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 testowania dostępne są publicznie dostępne dostrojone modele LoRA pasujące do interfejsu LLM Inference API w usłudze HuggingFace. Na przykład monsterapi/gemma-2b-lora-maths-orca-200k dla Gemma-2B i lole25/phi-2-sft-ultrachat-lora dla Phi-2.
Po wytrenowaniu na przygotowanym zbiorze danych i zapisaniu modelu otrzymasz plik adapter_model.safetensors
zawierający dostrojone wagi modelu LoRA. Plik Safetensors to punkt kontrolny LoRA używany w konwersji modelu.
W kolejnym kroku musisz przekonwertować wagi modelu na TensorFlow Lite Flatbuffer przy użyciu pakietu MediaPipe Python. Element ConversionConfig
powinien określać opcje modelu podstawowego oraz dodatkowe opcje LoRA. Zwróć uwagę, że interfejs API obsługuje wnioskowanie LoRA tylko z 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 płaskie TFLite, jeden dla modelu podstawowego, a drugi dla modelu LoRA.
wnioskowanie z modelu LoRA,
Interfejs Web, Android i iOS LLM Inference API został zaktualizowany, aby obsługiwać wnioskowanie na podstawie modelu LoRA. Internet obsługuje dynamiczne modele LoRA, które mogą przełączać różne modele LoRA w czasie działania. Android i iOS obsługują statyczną wartość LoRA, która korzysta z tych samych wag przez cały okres wykonywania zadania.
Android obsługuje statyczną lokację LoRA podczas inicjowania. Aby wczytać model LoRA, użytkownicy muszą podać ścieżkę modelu LoRA oraz podstawowy model LLM.// 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 z LLM z użyciem LoRA, użyj tych samych metod generateResponse()
lub generateResponseAsync()
co w modelu podstawowym.