Przewodnik dotyczący wnioskowania na podstawie LLM

Interfejs LLM Inference API umożliwia całkowite uruchamianie dużych modeli językowych (LLM) na urządzeniu, za pomocą którego można wykonywać wiele różnych zadań, takich jak generowanie tekstu, pobieranie informacji w języku naturalnym, 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 i usługach.

Wypróbuj!arrow_forward

Zadanie obsługuje Gemma 2B i 7B, To rodzina lekkich, najnowocześniejszych modeli otwartych opartych na tych samych konstrukcjach badania i technologie wykorzystywane do stworzenia Gemini modeli ML. Obsługuje również te modele zewnętrzne: Phi-2 Falcon-RW-1B StableLM-3B

Oprócz modeli obsługiwanych natywnie użytkownicy mogą mapować inne modele korzystające z technologii AI Edge od Google (w tym mapowania modeli PyTorch). Dzięki temu użytkownicy będą mogli wyeksportować zmapowany model do modelu z wieloma podpisami. modele TensorFlow Lite, które są połączone z parametrami tokenizera, utworzyć pakiet zadań.

Rozpocznij

Aby zacząć z niego korzystać, postępuj zgodnie z jednym z tych przewodników po implementacji platformy docelowej. Te przewodniki dotyczące konkretnych platform przeprowadzą Cię przez wraz z przykładami kodu z wykorzystaniem dostępnego modelu zalecane opcje konfiguracji:

• Internet:

  • Przewodnik
  • Kod przykład

• Android:

  • Przewodnik
  • Kod przykład

• iOS

  • Przewodnik
  • Kod przykład

Szczegóły zadania

W tej sekcji opisujemy możliwości, dane wejściowe, wyjściowe i konfigurację. aby wykonać tę czynność.

Funkcje

Interfejs LLM Inference API zawiera te kluczowe funkcje:

1. Generowanie tekstu na tekst – generuje tekst na podstawie promptu z tekstem wejściowym.
2. Wybór LLM – zastosuj kilka modeli, aby dostosować aplikację do swoich potrzeb dla konkretnych przypadków użycia. Możesz również ponownie wytrenować model, a następnie zastosować niestandardowe ciężary. model atrybucji.
3. Obsługa LoRA – rozszerzaj i dostosowuj możliwości LLM za pomocą modelu LoRA. przez trenowanie na całym zbiorze danych lub przez zastosowanie przygotowanej gotowej architektury LoRA modeli pochodzących ze społeczności open source (tylko modele natywne).

Opcje konfiguracji

To zadanie zawiera te opcje konfiguracji:

Modele

Interfejs LLM Inference API ma wbudowaną obsługę dużych podziałów tekstu na tekst modele językowe zoptymalizowane pod kątem działania w przeglądarkach i na urządzeniach mobilnych. Te można pobrać lekkie modele, aby przeprowadzać wnioskowanie całkowicie na urządzeniu.

Zanim zainicjujesz interfejs LLM Inference API, pobierz 1 z obsługiwanych modeli i zapisać plik w katalogu projektu.

Gemma 2B

Gemma 2B należy do rodziny lekkich, najnowocześniejszych modeli otwartych opartych na tych samych badaniach technologiczną wykorzystywaną do tworzenia modeli Gemini. model zawiera 2B parametrów i otwarte wagi. Ten model jest odpowiedni dla osób, różnego rodzaju zadania związane z generowaniem tekstu, w tym odpowiadanie na pytania, streszczenie, i rozumowania.

Pobierz Gemma 2B .

Modele Gemma 2B są dostępne w czterech wersjach:

• gemma-2b-it-cpu-int4: 4-bitowy model Gemma 2B z procesorem.
• gemma-2b-it-cpu-int8: 8-bitowy model Gemma 2B z 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.

Przed dodaniem modelu do aplikacji możesz go dostroić i dodać nowe wagi. Dla: Więcej informacji o dostrajaniu i dostosowywaniu Gemma znajdziesz w artykule Dostrajanie Gemma. Po pobraniu Gemma z Kaggle Models model ma już odpowiedni format do użycia z MediaPipe.

Jeśli pobierzesz Gemma 2B z usługi Hugging Face, musisz przejść na konwersję na format zgodny z MediaPipe. LLM Inference API wymaga pobrania i przekonwertowania 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 7B i otwarte wagi. Model jest zaawansowany w przypadku zróżnicowania tekstu zadań związanych z generowaniem treści, w tym odpowiadania na pytania, streszczania i rozumowania. Aplikacja Gemma 7B jest obsługiwana tylko w przeglądarce.

Pobierz Gemma 7B .

Model Gemma 7B jest dostępny w jednej wersji:

• gemma-1.1-7b-it-gpu-int8: 8-bitowy model Gemma 7B zgodny z GPU.

Jeśli pobierzesz Gemma 7B z aplikacji Hugging Face, musisz przekonwertować model na format obsługiwany przez 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 modelowy model oparty tylko na dekoderze 350B, który składa się z miliarda parametrów. tokeny RefinedWeb.

Pobierz Falcon 1B .

Interfejs LLM Inference API wymaga pobrania i przechowywania następujących plików lokalnie:

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

Po pobraniu plików modelu Falcon model jest gotowy do przekonwertowania na w formacie MediaPipe. Wykonaj czynności opisane w artykule Konwertowanie modelu do MediaPipe .

StableLM 3B

StableLM-3B to model językowy z 3 miliardami parametrów, wytrenowany na 1 bilion tokenów różnorodnych zbiorów danych w języku angielskim i kodu w 4 epokach.

Pobierz StableLM 3B .

Interfejs LLM Inference API wymaga pobrania i przechowywania następujących plików lokalnie:

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

Po pobraniu plików modelu StableLM model jest gotowy do skonwertowania na format MediaPipe. Wykonaj czynności opisane w artykule Konwertowanie modelu do MediaPipe .

Phi-2

Phi-2 to model transformera składający się z 2,7 miliarda parametrów. Zostały wytrenowane z wykorzystaniem różnych teksty syntetyczne NLP i filtrowane witryny; Model najlepiej nadaje się do promptów w formacie Question-Answer, czatu i kodu.

Pobierz Phi-2 .

Interfejs LLM Inference API wymaga pobrania i przechowywania następujących plików lokalnie:

• 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 w formacie MediaPipe. Wykonaj czynności opisane w artykule Konwertowanie modelu do MediaPipe .

Modele wyeksportowane z AI Edge

AI Edge to oferta Google, która umożliwia konwertowanie modeli mapowanych przez użytkowników w modele TensorFlow Lite z wieloma podpisami. Więcej informacji o mapowaniu eksportując modele, otwórz stronę AI Edge Torch Strona GitHub.

Po wyeksportowaniu modelu do formatu TFLite jest on gotowy do użycia do formatu MediaPipe. Więcej informacji: Przekonwertuj model na format MediaPipe.

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.

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)

Dostosowanie LoRA

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.

// 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 model podstawowy.