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

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

Për të parë API-të e konkluzionit LLM në veprim dhe për të eksploruar një gamë të plotë të aftësive gjeneruese të AI në pajisje, shikoni aplikacionin Google AI Edge Gallery .

Galeria e Google AI Edge është një aplikacion Android me burim të hapur që shërben si një shesh lojërash ndërvepruese për zhvilluesit. Ajo tregon:

• Shembuj praktikë të përdorimit të API-së LLM Inference për detyra të ndryshme, duke përfshirë:
  • Pyet imazhin: Ngarko një imazh dhe bëj pyetje rreth tij. Merrni përshkrime, zgjidhni problemet ose identifikoni objektet.
  • Prompt Lab: Përmblidhni, rishkruani, gjeneroni kodin ose përdorni kërkesat e formës së lirë për të eksploruar rastet e përdorimit të LLM me një kthesë.
  • Chat AI: Angazhohuni në biseda me shumë kthesa.
• Aftësia për të zbuluar, shkarkuar dhe eksperimentuar me një sërë modelesh të optimizuara nga LiteRT nga Komuniteti Hugging Face LiteRT dhe publikimet zyrtare të Google (p.sh. Gemma 3N).
• Standardet e performancës në pajisje në kohë reale për modele të ndryshme (Time To First Token, shpejtësia e deshifrimit, etj.).
• Si të importoni dhe testoni modelet tuaja të personalizuara .task .

Ky aplikacion është një burim për të kuptuar zbatimin praktik të LLM Inference API dhe potencialin e AI gjeneruese në pajisje. Eksploroni kodin burimor dhe shkarkoni aplikacionin nga depoja e Google AI Edge Gallery GitHub .

Opsionet e konfigurimit

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

Nxitja multimodale

API-të e Android LLM Inference API mbështesin nxitjen multimodale me modele që pranojnë hyrje teksti dhe imazhi. Me multimodalitetin e aktivizuar, përdoruesit mund të përfshijnë një kombinim të imazheve dhe tekstit në kërkesat e tyre dhe LLM ofron një përgjigje tekstuale.

Për të filluar, përdorni një variant të përputhshëm me MediaPipe të Gemma 3n :

• Gemma-3n E2B : një model 2B i familjes Gemma-3n.
• Gemma-3n E4B : një model 4B i familjes Gemma-3n.

Për më shumë informacion, shihni dokumentacionin Gemma-3n .

Për të ofruar imazhe brenda një prompt, konvertoni imazhet ose kornizat hyrëse në një objekt com.google.mediapipe.framework.image.MPImage përpara se ta kaloni atë në API-në e konkluzionit LLM:

import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage

// Convert the input Bitmap object to an MPImage object to run inference
val mpImage = BitmapImageBuilder(image).build()

Për të aktivizuar mbështetjen e vizionit për API-në e konkluzionit LLM, vendosni opsionin e konfigurimit EnableVisionModality në true brenda opsioneve Graph:

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    ...
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

Gemma-3n pranon një maksimum prej një imazhi për sesion, kështu që vendosni MaxNumImages në 1.

LlmInferenceOptions options = LlmInferenceOptions.builder()
  ...
  .setMaxNumImages(1)
  .build();

Më poshtë është një shembull i zbatimit të API-së LLM Inference të konfiguruar për të trajtuar hyrjet e vizionit dhe tekstit:

MPImage image = getImageFromAsset(BURGER_IMAGE);

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    .setTopK(10)
    .setTemperature(0.4f)
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

try (LlmInference llmInference =
    LlmInference.createFromOptions(ApplicationProvider.getApplicationContext(), options);
  LlmInferenceSession session =
    LlmInferenceSession.createFromOptions(llmInference, sessionOptions)) {
  session.addQueryChunk("Describe the objects in the image.");
  session.addImage(image);
  String result = session.generateResponse();
}

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