Udhëzues LLM Inference për iOS

LLM Inference API ju lejon të ekzekutoni modele të mëdha gjuhësore (LLM) plotësisht në pajisje për aplikacionet iOS, 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 shumë modele 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 iOS.

Për të shtuar shpejt API-në e konkluzionit LLM në aplikacionin tuaj iOS, ndiqni " Fillimi i shpejtë" . Për një shembull bazë të një aplikacioni iOS 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 iOS. LLM Inference API përdor bibliotekën MediaPipeTasksGenai , e cila duhet të instalohet duke përdorur CocoaPods. Biblioteka është e pajtueshme me të dy aplikacionet Swift dhe Objective-C dhe nuk kërkon ndonjë konfigurim shtesë specifik për gjuhën.

Për udhëzime për instalimin e CocoaPods në macOS, referojuni udhëzuesit të instalimit të CocoaPods . Për udhëzime se si të krijoni një Podfile me pods-et e nevojshme për aplikacionin tuaj, referojuni Përdorimit të CocoaPods .

Shto varësi

Shtoni podin MediaPipeTasksGenai në Podfile duke përdorur kodin e mëposhtëm:

target 'MyLlmInferenceApp' do
  use_frameworks!
  pod 'MediaPipeTasksGenAI'
  pod 'MediaPipeTasksGenAIC'
end

Nëse aplikacioni juaj përfshin objektiva testimi të njësisë, referojuni Udhëzuesit të konfigurimit për iOS për informacion shtesë mbi konfigurimin e skedarit tuaj Podfile .

Shkarkoni një model

Shkarkoni Gemma-2 2B në një format të kuantizuar 8-bit nga Kaggle Models . Për më shumë informacion mbi modelet e disponueshme, shihni dokumentacionin e Modeleve .

Shtoni modelin në drejtorinë e projektit tuaj duke përdorur Xcode. Për udhëzime se si të shtoni skedarë në projektin tuaj Xcode, referojuni Menaxhimi i skedarëve dhe dosjeve në projektin tuaj Xcode .

Inicializoni Detyrën

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

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")

let options = LlmInferenceOptions()
options.baseOptions.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101

let llmInference = try LlmInference(options: options)

Ekzekutoni detyrën

Përdorni metodën generateResponse(inputText:) për të gjeneruar një përgjigje tekstuale. Kjo prodhon një përgjigje të vetme të gjeneruar.

let result = try LlmInference.generateResponse(inputText: inputPrompt)

Për të transmetuar përgjigjen, përdorni metodëngeneResponseAsync generateResponseAsync(inputText:) .

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

do {
  for try await partialResult in resultStream {
    print("\(partialResult)")
  }
  print("Done")
}
catch {
  print("Response error: '\(error)")
}

Shembull aplikimi

Aplikacioni mostër është një shembull i një aplikacioni bazë të gjenerimit të tekstit për iOS, duke përdorur API-në LLM Inference. Mund ta përdorni aplikacionin si pikënisje për aplikacionin tuaj iOS 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ë iOS Studio dhe të ekzekutoni aplikacionin. Për më shumë informacion, shihni Udhëzuesin e konfigurimit për iOS .

Opsionet e konfigurimit

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

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

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

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")
let loraPath= Bundle.main.path(forResource: "lora_model",
                                      ofType: "bin")
let options = LlmInferenceOptions()
options.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101
options.loraPath = loraPath

let llmInference = try LlmInference(options: options)

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