Udhëzues LLM Inference për Android

LLM Inference API ju lejon të ekzekutoni modele të mëdha gjuhësore (LLM) plotësisht në pajisje për aplikacionet Android, të cilat mund t'i përdorni për të kryer një gamë të gjerë detyrash, të tilla si gjenerimi i tekstit, marrja e informacionit në formën e gjuhës natyrore dhe përmbledhja e dokumenteve. Detyra ofron mbështetje të integruar për modele të shumta të gjuhëve të mëdha tekst-me-tekst, kështu që ju mund të aplikoni modelet më të fundit të AI gjeneruese në pajisje në aplikacionet tuaja Android.

Detyra mbështet variantet e mëposhtme të Gemma : Gemma-2 2B, Gemma 2B dhe Gemma 7B. Gemma është një familje modelesh të hapura me peshë të lehtë dhe moderne të ndërtuara nga i njëjti kërkim dhe teknologji e përdorur për krijimin e modeleve Gemini . Ai gjithashtu mbështet modelet e jashtme të mëposhtme: Phi-2 , Falcon-RW-1B dhe StableLM-3B .

Përveç modeleve të mbështetura, përdoruesit mund të përdorin AI Edge Torch të Google për të eksportuar modelet PyTorch në modelet LiteRT ( tflite ) me shumë nënshkrime, të cilat janë të bashkuara me parametrat e tokenizuesit për të krijuar Paketat e Detyrave që janë të pajtueshme me API-në e konkluzionit LLM.

Ju mund ta shihni këtë detyrë në veprim me demonstrimin e MediaPipe Studio . Për më shumë informacion rreth aftësive, modeleve dhe opsioneve të konfigurimit të kësaj detyre, shihni Përmbledhjen .

Shembull kodi

Ky udhëzues i referohet një shembulli të një aplikacioni bazë të gjenerimit të tekstit për Android. Mund ta përdorni aplikacionin si pikënisje për aplikacionin tuaj Android ose t'i referoheni kur modifikoni një aplikacion ekzistues. Kodi i shembullit është pritur në GitHub .

Shkarkoni kodin

Udhëzimet e mëposhtme ju tregojnë se si të krijoni një kopje lokale të kodit shembull duke përdorur mjetin e linjës së komandës git .

Për të shkarkuar kodin shembull:

1. Klononi depon e git duke përdorur komandën e mëposhtme:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Opsionale, konfiguroni shembullin tuaj të git për të përdorur arkëtimin e rrallë, në mënyrë që të keni vetëm skedarët për shembullin e aplikacionit LLM Inference API:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/android
   

Pas krijimit të një versioni lokal të kodit shembull, mund ta importoni projektin në Android Studio dhe të ekzekutoni aplikacionin. Për udhëzime, shihni Udhëzuesin e konfigurimit për Android .

Konfigurimi

Ky seksion përshkruan hapat kryesorë për konfigurimin e mjedisit tuaj të zhvillimit dhe projekteve të kodit në mënyrë specifike për të përdorur API-në e konkluzionit LLM. Për informacion të përgjithshëm mbi konfigurimin e mjedisit tuaj të zhvillimit për përdorimin e detyrave të MediaPipe, duke përfshirë kërkesat e versionit të platformës, shihni udhëzuesin e konfigurimit për Android .

varësitë

LLM Inference API përdor bibliotekën com.google.mediapipe:tasks-genai . Shtoni këtë varësi në skedarin build.gradle të aplikacionit tuaj Android:

dependencies {
    implementation 'com.google.mediapipe:tasks-genai:0.10.14'
}

Për pajisjet me Android 12 (API 31) ose më të lartë, shtoni varësinë origjinale të bibliotekës OpenCL. Për më shumë informacion, shihni dokumentacionin në etiketën uses-native-library .

Shtoni etiketat e mëposhtme uses-native-library në skedarin AndroidManifest.xml :

<uses-native-library android:name="libOpenCL.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false"/>

Model

MediaPipe LLM Inference API kërkon një model të trajnuar të gjuhës tekst-me-tekst që është në përputhje me këtë detyrë. Pasi të keni shkarkuar një model, instaloni varësitë e kërkuara dhe shtyjeni modelin në pajisjen Android. Nëse jeni duke përdorur një model tjetër përveç Gemma, do t'ju duhet ta konvertoni modelin në një format të pajtueshëm me MediaPipe.

Për më shumë informacion mbi modelet e trajnuara të disponueshme për LLM Inference API, shihni seksionin Modelet e përmbledhjes së detyrave.

Shkarkoni një model

Përpara se të inicializoni API-në e konkluzionit LLM, shkarkoni një nga modelet e mbështetura dhe ruajeni skedarin brenda drejtorisë së projektit tuaj:

• Gemma-2 2B : Versioni më i fundit i modeleve të familjes Gemma. Pjesë e një familjeje modelesh të hapura të lehta dhe moderne të ndërtuara nga i njëjti kërkim dhe teknologji e përdorur për krijimin e modeleve Gemini .
• Gemma 2B : Pjesë e një familjeje modelesh të hapura të lehta dhe moderne të ndërtuara nga i njëjti kërkim dhe teknologji e përdorur për krijimin e modeleve Gemini . I përshtatshëm për një sërë detyrash të gjenerimit të tekstit, duke përfshirë përgjigjen e pyetjeve, përmbledhjen dhe arsyetimin.
• Phi-2 : Modeli Transformer me parametra 2.7 miliardë, më i përshtatshmi për formatin Pyetje-Përgjigje, bisedë dhe kod.
• Falcon-RW-1B : Model 1 miliard parametrash shkakësor vetëm për dekoderin e trajnuar në 350B shenja të RefinedWeb .
• StableLM-3B : Modeli gjuhësor me 3 miliardë parametra vetëm për dekoderin e para-trajnuar në 1 trilion shenja të grupeve të të dhënave të ndryshme të anglishtes dhe kodeve.

Përveç modeleve të mbështetura, mund të përdorni AI Edge Torch të Google për të eksportuar modelet PyTorch në modelet LiteRT ( tflite ) me shumë nënshkrime. Për më shumë informacion, shihni konvertuesin gjenerues të pishtarëve për modelet PyTorch .

Ne rekomandojmë përdorimin e Gemma-2 2B, i cili është i disponueshëm në Kaggle Models . Për më shumë informacion mbi modelet e tjera të disponueshme, shihni seksionin Modelet e përmbledhjes së detyrave.

Konvertoni modelin në formatin MediaPipe

LLM Inference API është i pajtueshëm me dy kategori llojesh modelesh, disa prej të cilave kërkojnë konvertim modeli. Përdorni tabelën për të identifikuar metodën e hapave të kërkuar për modelin tuaj.

Ne po presim skedarët .bin të konvertuar për Gemma 2B, Gemma 7B dhe Gemma-2 2B në Kaggle. Këto modele mund të vendosen drejtpërdrejt duke përdorur API-në tonë të konkluzionit LLM. Për të mësuar se si mund të konvertoni modele të tjera, shihni seksionin "Konvertimi i modelit" .

Shtyjeni modelin në pajisje

Shtyni përmbajtjen e dosjes output_path në pajisjen Android.

$ adb shell rm -r /data/local/tmp/llm/ # Remove any previously loaded models
$ adb shell mkdir -p /data/local/tmp/llm/
$ adb push output_path /data/local/tmp/llm/model_version.bin

Krijo detyrën

MediaPipe LLM Inference API përdor funksionin createFromOptions() për të vendosur detyrën. Funksioni createFromOptions() pranon vlerat për opsionet e konfigurimit. Për më shumë informacion mbi opsionet e konfigurimit, shihni Opsionet e konfigurimit .

Kodi i mëposhtëm inicializon detyrën duke përdorur opsionet bazë të konfigurimit:

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('/data/local/.../')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Opsionet e konfigurimit

Përdorni opsionet e mëposhtme të konfigurimit për të konfiguruar një aplikacion Android:

Përgatitni të dhënat

LLM Inference API pranon hyrjet e mëposhtme:

• prompt (string): Një pyetje ose kërkesë.

val inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

Drejtoni detyrën

Përdorni generateResponse() për të gjeneruar një përgjigje teksti në tekstin hyrës të dhënë në seksionin e mëparshëm ( inputPrompt ). Kjo prodhon një përgjigje të vetme të gjeneruar.

val result = llmInference.generateResponse(inputPrompt)
logger.atInfo().log("result: $result")

Për të transmetuar përgjigjen, përdorni generateResponseAsync() .

val options = LlmInference.LlmInferenceOptions.builder()
  ...
  .setResultListener { partialResult, done ->
    logger.atInfo().log("partial result: $partialResult")
  }
  .build()

llmInference.generateResponseAsync(inputPrompt)

Trajtoni dhe shfaqni rezultatet

API-ja e konkluzionit LLM kthen një LlmInferenceResult , i cili përfshin tekstin e gjeneruar të përgjigjes.

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]

Personalizimi i modelit LoRA

API-ja e konkluzionit të Mediapipe LLM mund të konfigurohet për të mbështetur Përshtatjen e Rangut të Ulët (LoRA) për modelet e gjuhëve të mëdha. Duke përdorur modele LoRA të rregulluara mirë, zhvilluesit mund të personalizojnë sjelljen e LLM-ve përmes një procesi trajnimi me kosto efektive.

Mbështetja LoRA e API-së LLM Inference funksionon për të gjitha variantet Gemma dhe modelet Phi-2 për prapavijën e GPU-së, me peshat LoRA të zbatueshme vetëm për shtresat e vëmendjes. Ky zbatim fillestar shërben si një API eksperimentale për zhvillimet e ardhshme me plane për të mbështetur më shumë modele dhe lloje të ndryshme shtresash në përditësimet e ardhshme.

Përgatitni modelet LoRA

Ndiqni udhëzimet në HuggingFace për të trajnuar një model LoRA të akorduar mirë në grupin tuaj të të dhënave me llojet e modeleve të mbështetura, Gemma ose Phi-2. Modelet Gemma-2 2B , Gemma 2B dhe Phi-2 janë të dy të disponueshme në HuggingFace në formatin e siguresave. Meqenëse LLM Inference API mbështet LoRA vetëm në shtresat e vëmendjes, specifikoni vetëm shtresat e vëmendjes gjatë krijimit të LoraConfig si më poshtë:

# 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"],
)

Për testim, ekzistojnë modele LoRA të akorduara mirë të aksesueshme nga publiku që përshtaten me API-në e konkluzionit LLM të disponueshme në HuggingFace. Për shembull, monsterapi/gemma-2b-lora-maths-orca-200k për Gemma-2B dhe lole25/phi-2-sft-ultrachat-lora për Phi-2.

Pas trajnimit për grupin e të dhënave të përgatitur dhe ruajtjes së modelit, ju merrni një skedar adapter_model.safetensors që përmban peshat e modelit LoRA të rregulluara mirë. Skedari i siguruesve është pika e kontrollit LoRA e përdorur në konvertimin e modelit.

Si hap tjetër, ju duhet të konvertoni peshat e modelit në një TensorFlow Lite Flatbuffer duke përdorur Paketën MediaPipe Python. ConversionConfig duhet të specifikojë opsionet e modelit bazë, si dhe opsionet shtesë të LoRA. Vini re se meqenëse API mbështet vetëm konkluzionet LoRA me GPU, pjesa e pasme duhet të vendoset në '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)

Konvertuesi do të nxjerrë dy skedarë TFLite flatbuffer, një për modelin bazë dhe tjetri për modelin LoRA.

Konkluzioni i modelit LoRA

Web, Android dhe iOS LLM Inference API janë përditësuar për të mbështetur konkluzionet e modelit 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)

Për të ekzekutuar konkluzionet LLM me LoRA, përdorni të njëjtat generateResponse() generateResponseAsync() si modeli bazë.