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.

Për të shtuar shpejt LLM Inference API në aplikacionin tuaj Android, ndiqni Quickstart . Për një shembull bazë të një aplikacioni Android që ekzekuton API-në e konkluzionit LLM, shihni shembullin e aplikacionit . Për një kuptim më të thellë se si funksionon API-ja e konkluzionit LLM, referojuni opsioneve të konfigurimit , konvertimit të modelit dhe seksioneve të akordimit LoRA .

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 .

Fillimi i shpejtë

Përdorni hapat e mëposhtëm për të shtuar API-në e konkluzionit LLM në aplikacionin tuaj Android. LLM Inference API është optimizuar për pajisjet Android të nivelit të lartë, si Pixel 8 dhe Samsung S23 ose më të reja, dhe nuk mbështet me besueshmëri emuluesit e pajisjeve.

Shto varësi

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.22'
}

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"/>

Shkarkoni një model

Shkarkoni Gemma-3 1B në një format të kuantizuar 4-bit nga Hugging Face . Për më shumë informacion mbi modelet e disponueshme, shihni dokumentacionin e Modeleve .

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

Inicializoni Detyrën

Inicializoni detyrën me opsionet bazë të konfigurimit:

// Set the configuration options for the LLM Inference task
val taskOptions = LlmInferenceOptions.builder()
        .setModelPath('/data/local/tmp/llm/model_version.task')
        .setMaxTopK(64)
        .build()

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

Ekzekutoni detyrën

Përdorni generateResponse() për të gjeneruar një përgjigje tekstuale. 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)

Shembull aplikimi

Aplikacioni mostër është një shembull i një aplikacioni bazë të gjenerimit të tekstit për Android, duke përdorur API-në LLM Inference. 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 .

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

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

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

Opsionet e konfigurimit

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

Konvertimi i modelit

LLM Inference API është në përputhje me llojet e mëposhtme të modeleve, 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.

Për të mësuar se si mund të konvertoni modele të tjera, shihni seksionin "Konvertimi i modelit" .

Përshtatje LoRA

API-ja e konkluzionit LLM mbështet akordimin LoRA (Përshtatje me gradë të ulët) duke përdorur bibliotekën PEFT (Parameter-Efficient Fine-Tuning). Akordimi LoRA personalizon sjelljen e LLM-ve përmes një procesi trajnimi me kosto efektive, duke krijuar një grup të vogël peshash të trajnueshme bazuar në të dhënat e reja të trajnimit në vend që të ritrajnojë të gjithë modelin.

LLM Inference API mbështet shtimin e peshave LoRA në shtresat e vëmendjes të modeleve Gemma-2 2B , Gemma 2B dhe Phi-2 . Shkarkoni modelin në formatin safetensors .

Modeli bazë duhet të jetë në formatin e safetensors për të krijuar pesha LoRA. Pas trajnimit LoRA, mund t'i konvertoni modelet në formatin FlatBuffers për t'u ekzekutuar në MediaPipe.

Përgatitni peshat LoRA

Përdorni udhëzuesin LoRA Methods nga PEFT për të trajnuar një model LoRA të rregulluar mirë në grupin tuaj të të dhënave.

API-ja e konkluzionit LLM mbështet LoRA vetëm në shtresat e vëmendjes, kështu që specifikoni vetëm shtresat e vëmendjes në LoraConfig :

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

Pas trajnimit mbi grupin e të dhënave të përgatitur dhe ruajtjes së modelit, peshat e modelit LoRA të rregulluara mirë janë të disponueshme në adapter_model.safetensors . Skedari safetensors është pika e kontrollit LoRA e përdorur gjatë konvertimit të modelit.

Konvertimi i modelit

Përdorni Paketën MediaPipe Python për të kthyer peshat e modelit në formatin Flatbuffer. ConversionConfig specifikon opsionet e modelit bazë së bashku me opsionet shtesë LoRA.

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_FILE,
)

converter.convert_checkpoint(config)

Konvertuesi do të prodhojë dy skedarë Flatbuffer, një për modelin bazë dhe një tjetër për modelin LoRA.

Konkluzioni i modelit LoRA

Android mbështet LoRA statike gjatë inicializimit. Për të ngarkuar një model LoRA, specifikoni shtegun e modelit LoRA si dhe bazën LLM.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath(BASE_MODEL_PATH)
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath(LORA_MODEL_PATH)
        .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ë.