Przedstawiamy Google AI Edge Portal: benchmark Edge AI na dużą skalę. Zarejestruj się, aby poprosić o dostęp podczas wersji prywatnej.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Konwertowanie modeli generatywnej AI PyTorch na potrzeby wnioskowania na urządzeniu

LiteRT Torch Generative API to biblioteka o wysokiej wydajności przeznaczona do tworzenia i konwertowania modeli PyTorch opartych na architekturze Transformer do formatu LiteRT/LiteRT-LM. Dzięki temu deweloperzy mogą łatwo wdrażać modele generatywnej AI, w szczególności duże modele językowe (LLM), do generowania tekstu i obrazów na urządzeniu.

Interfejs Torch Generative API obsługuje konwersję modeli na potrzeby procesorów CPU, GPU i NPU. Łącząc interfejs Torch Generative API z LiteRT-LM, możesz tworzyć responsywne aplikacje zapewniające ochronę prywatności, które w całości działają na urządzeniu.

Konwertowanie z biblioteki Hugging Face Transformer

Rozszerzenie LiteRT Torch Hugging Face Export zapewnia uproszczoną ścieżkę konwersji modeli generatywnej AI bezpośrednio z biblioteki Hugging Face Transformers do formatu LiteRT-LM. W porównaniu z interfejsami LiteRT Torch Generative API, które udostępniają bloki konstrukcyjne PyTorch do tworzenia i optymalizowania modeli niestandardowych, to narzędzie upraszcza pobieranie wag, tłumaczenie architektur modeli PyTorch i stosowanie technik optymalizacji, takich jak optymalizacja grafu i kwantyzacja, w ramach jednego przepływu pracy. W wyniku tego procesu powstaje plik .litertlm, który jest zoptymalizowany pod kątem wnioskowania na urządzeniu na procesorze, GPU i NPU przy użyciu środowiska wykonawczego LiteRT-LM.

Wymagania wstępne

Zanim użyjesz rozszerzenia eksportu, upewnij się, że masz skonfigurowane te elementy:

Zainstaluj pakiet Pythona LiteRT Torch. Rozszerzenie Hugging Face Export jest wbudowane bezpośrednio w pakiet litert-torch.
(Opcjonalnie) Aby skompilować NPU, zainstaluj rozszerzenia pakietu LiteRT NPU SDK, używając polecenia pip install ai-edge-litert[npu-sdk]. Więcej informacji znajdziesz w tym artykule.
Środowisko Hugging Face jest konfigurowane, jeśli zamierzasz wczytywać dane bezpośrednio z Hugging Face Hub. Narzędzie export_hf korzysta ze standardowych mechanizmów uwierzytelniania biblioteki transformers, takich jak HF_TOKEN lub interfejs wiersza poleceń. Zobacz przykład:

Aby pobrać modele z ograniczonym dostępem (takie jak Gemma czy Llama), musisz uwierzytelnić się w Hugging Face za pomocą interfejsu wiersza poleceń lub zmiennej środowiskowej:

# Set your Hugging Face token as an environment variable
export HF_TOKEN="your_hugging_face_token"

# Or use the Hugging Face CLI login
hf auth login

Podstawowe użycie

export_hf możesz używać w wierszu poleceń lub za pomocą interfejsu Python API. Narzędzie automatycznie pobierze model z Hugging Face lub wczyta go z podanej lokalnej ścieżki, prześledzi go, zastosuje domyślne optymalizacje i przekonwertuje go na plik .litertlm zgodny z wnioskowaniem na procesorze i GPU.

Interfejs wiersza poleceń (CLI)

Użyj polecenia litert-torch export_hf. Musisz podać identyfikator modelu Hugging Face i wybrany katalog wyjściowy.

litert-torch export_hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-it-litertlm

W przypadku eksportowania modelu lokalnego lub niestandardowego możesz też przekazać ścieżkę do punktu kontrolnego safetensor:

litert-torch export_hf \
  --model=/path/to/safetensor/dir \
  --output_dir=/my_custom_litertlm

Python API

Aby zintegrować go ze skryptami lub notatnikami Pythona, zaimportuj moduł export z litert_torch.generative.export_hf.

from litert_torch.generative.export_hf import export

export.export(
    model='google/gemma-3-270m-it',
    output_dir='/tmp/gemma3-270m-it-litertlm',
)

Wdrażanie na urządzeniu za pomocą LiteRT-LM

Po wyeksportowaniu modelu do pliku .litertlm możesz wdrożyć go bezpośrednio na urządzeniu za pomocą LiteRT-LM, aby uzyskać wysoką wydajność zarówno na procesorze, jak i na GPU. Szczegółowe informacje o korzystaniu z interfejsu LiteRT-LM API. Informacje o akceleracji NPU znajdziesz w przewodniku po kompilacji AOT na potrzeby NPU.

Obsługiwane architektury

Narzędzie export_hf weryfikuje te architektury modeli Transformer: Możesz to sprawdzić, otwierając pole model_type w config.json.

Gemma 3 (Gemma3ForCausalLM)
Gemma 3n (Gemma3nForCausalLM)
Gemma 4 (Gemma4ForCausalLM)
Llama (LlamaForCausalLM)
Mistral (MistralForCausalLM)
Qwen 2/2.5 (Qwen2ForCausalLM)
Qwen 3 (Qwen3ForCausalLM)
SmolLM 3 (SmolLM3ForCausalLM)

Ustawienia zaawansowane

W ustawieniach flag rozszerzeń możesz sprawdzić dostępne opcje zaawansowane. Poniżej znajdziesz kilka popularnych ustawień, których możesz spróbować.

Modele językowe Vision

W przypadku obsługiwanych modeli możesz ustawić --task=image_text_to_text i --export_vision_encoder, aby załadować i wyeksportować model kodera wizyjnego.

Obsługiwane architektury:

Gemma 3 (Gemma3ForConditionalGeneration)
Gemma 4 (Gemma4ForConditionalGeneration)

Konfiguracja kwantyzacji

Modele generatywnej AI są często zbyt duże, aby można je było wydajnie uruchamiać na urządzeniach brzegowych bez optymalizacji. Domyślnie export_hf stosuje przepis kwantyzacji dynamic_wi8_afp32 za pomocą AI Edge Quantizer, który kwantyzuje wagi do INT8 na kanał, zachowując aktywacje w FP32.

Możesz zmienić to domyślne zachowanie za pomocą flagi --quantization_recipe (lub parametru quantization_recipe w Pythonie). Możesz podać nazwę wbudowanego przepisu z AI Edge Quantizer lub określić ścieżkę do niestandardowego przepisu w formacie JSON.

Przykład:

litert-torch export_hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-it-litertlm \
  --quantization_recipe=/path/to/my/quantization_recipe.json

Zastąpienie szablonu Jinja

Szablon Jinja dołączony do modelu Transformers może nie być zgodny z LiteRT-LM (np.modelami Gemma4). Możesz ustawić flagę use_jinja_template na False lub użyć opcji jinja_chat_template_override, aby zastąpić szablon.

Przykład:

 litert-torch export_hf \
   --model=google/gemma-4-E2B-it \
  --output_dir=/tmp/gemma4_2b_litertlm \
  --externalize_embedder \
  --jinja_chat_template_override=litert-community/gemma-4-E2B-it-litert-lm

Kompilacja NPU AOT

Oprócz procesora i GPU możesz też kierować reklamy na obsługiwane akceleratory NPU podczas eksportowania modeli, podając opcje specyficzne dla NPU.

Google Tensor

Wymagania wstępne: aby skonfigurować środowisko programistyczne, postępuj zgodnie z instrukcjami na stronie pakietu Google Tensor SDK.

Aby wyeksportować modele LLM przeznaczone dla procesorów TPU Google Tensor, postępuj zgodnie z przykładem dotyczącym dodatkowych flag wymaganych do kompilacji TPU.

Przykład:

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --prefill_lengths=128, \
  --cache_length=1280 \
  --quantization_recipe="weight_only_wi8_afp32"
  --aot_backend=GOOGLE \
  --aot_soc_model=Tensor_G5 \
  --aot_compilation_config_dict='{"google_tensor_enable_large_model_support": True}'

Więcej informacji znajdziesz w artykule Kompilowanie modeli za pomocą pakietu Google Tensor SDK.

Qualcomm AI Runtime:

Wymagania wstępne: postępuj zgodnie z instrukcjami konfiguracji pakietu SDK i listą obsługiwanych urządzeń podanymi w artykule Integracja LiteRT z Qualcommem.

Przykład:

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --quantization_recipe='' \
  --aot_backend=qualcomm \
  --aot_soc_model=SM8750

MediaTek NeuroPilot:

Wymagania wstępne: postępuj zgodnie z instrukcjami konfiguracji pakietu SDK i listą obsługiwanych urządzeń podanymi w artykule Integracja LiteRT z MediaTekiem.

Przykład:

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --aot_backend=mediatek \
  --aot_soc_model=MT8189

Intel OpenVINO

Wymagania wstępne: postępuj zgodnie z instrukcjami konfiguracji pakietu SDK i listą obsługiwanych urządzeń podanymi w artykule Integracja LiteRT Intel OpenVINO.

Przykład:

litert-torch export-hf \
  --model=google/gemma-3-270m-it \
  --output_dir=/tmp/gemma3-270m-google-tensor-g5 \
  --split_cache \
  --externalize_embedder \
  --aot_backend=intel_openvino \
  --aot_soc_model=PTL

Ponowne tworzenie i konwertowanie za pomocą interfejsu LiteRT Torch Generative API

Interfejs LiteRT Torch Generative API udostępnia też komponenty do tworzenia i optymalizowania niestandardowych modeli PyTorch, w tym między innymi warstwy normalizujące, mechanizmy uwagi i inne podstawowe moduły. Jeśli Twój model nie jest objęty rozszerzeniem LiteRT Torch Hugging Face Export, możesz utworzyć własne modele, które będą zgodne z LiteRT i LiteRT-LM.

Istnieją przykłady modeli, w tym duże modele językowe, modele dyfuzyjne i modele ASR. Możesz je sprawdzić i wdrożyć własny model.

Więcej informacji znajdziesz w repozytorium GitHub interfejsu Generative Torch API.