คู่มือการสรุป LLM สำหรับ iOS

LLM Inference API ช่วยให้คุณเรียกใช้โมเดลภาษาขนาดใหญ่ (LLM) บนอุปกรณ์ได้อย่างสมบูรณ์ สำหรับแอปพลิเคชัน iOS ซึ่งคุณสามารถใช้เพื่อทำงานได้หลากหลาย เช่น การสร้างข้อความ การดึงข้อมูลในรูปแบบภาษาธรรมชาติ และ การสรุปเอกสาร งานนี้รองรับโมเดลภาษาขนาดใหญ่แบบข้อความต่อข้อความหลายรายการในตัว คุณจึงใช้โมเดล Generative AI ล่าสุดในอุปกรณ์กับแอป iOS ได้

หากต้องการเพิ่ม LLM Inference API ลงในแอปพลิเคชัน iOS อย่างรวดเร็ว ให้ทำตามการเริ่มต้นใช้งานอย่างรวดเร็ว ดูตัวอย่างพื้นฐานของแอปพลิเคชัน iOS ที่เรียกใช้ LLM Inference API ได้ที่แอปพลิเคชันตัวอย่าง หากต้องการทําความเข้าใจวิธีการทํางานของ LLM Inference API อย่างละเอียด โปรดดูส่วนตัวเลือกการกําหนดค่า การแปลงโมเดล และการปรับแต่ง LoRA

คุณดูการทำงานของงานนี้ได้ในการสาธิต MediaPipe Studio ดูข้อมูลเพิ่มเติมเกี่ยวกับความสามารถ โมเดล และตัวเลือกการกำหนดค่า ของงานนี้ได้ที่ภาพรวม

คู่มือเริ่มใช้งานฉบับย่อ

ทำตามขั้นตอนต่อไปนี้เพื่อเพิ่ม LLM Inference API ลงในแอปพลิเคชัน iOS LLM Inference API ใช้ไลบรารี MediaPipeTasksGenai ซึ่งต้องติดตั้งโดยใช้ CocoaPods ไลบรารีนี้ใช้ได้กับทั้งแอป Swift และ Objective-C และไม่จำเป็นต้องมีการตั้งค่าเพิ่มเติมเฉพาะภาษา

ดูวิธีการติดตั้ง CocoaPods ใน macOS ได้ที่คู่มือการติดตั้ง CocoaPods ดูวิธีการสร้าง Podfile ที่มีพ็อดที่จำเป็นสำหรับแอปได้ที่การใช้ CocoaPods

เพิ่มทรัพยากร Dependency

เพิ่มพ็อด MediaPipeTasksGenai ใน Podfile โดยใช้โค้ดต่อไปนี้

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

หากแอปมีเป้าหมายการทดสอบหน่วย โปรดดูข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่า Podfile ในคู่มือการตั้งค่าสำหรับ iOS

ดาวน์โหลดโมเดล

ดาวน์โหลด Gemma-2 2B ในรูปแบบที่หาค่าปริมาณ 8 บิตจาก Kaggle Models ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลที่มีได้ที่เอกสารประกอบเกี่ยวกับโมเดล

เพิ่มโมเดลลงในไดเรกทอรีโปรเจ็กต์โดยใช้ Xcode ดูวิธีการ เพิ่มไฟล์ลงในโปรเจ็กต์ Xcode ได้ที่การจัดการไฟล์และโฟลเดอร์ในโปรเจ็กต์ Xcode

เริ่มต้นใช้งาน Task

เริ่มต้นงานด้วยตัวเลือกการกำหนดค่าพื้นฐาน

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)

เรียกใช้งาน

ใช้เมธอด generateResponse(inputText:) เพื่อสร้างคำตอบเป็นข้อความ ซึ่งจะ สร้างคำตอบที่สร้างขึ้นรายการเดียว

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

หากต้องการสตรีมคำตอบ ให้ใช้วิธี generateResponseAsync(inputText:)

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

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

แอปพลิเคชันตัวอย่าง

แอปพลิเคชันตัวอย่างเป็นตัวอย่างของแอปสร้างข้อความพื้นฐานสำหรับ iOS โดยใช้ LLM Inference API คุณสามารถใช้แอปเป็นจุดเริ่มต้นสำหรับแอป iOS ของคุณเอง หรือใช้เป็นข้อมูลอ้างอิงเมื่อแก้ไขแอปที่มีอยู่ โค้ดตัวอย่างโฮสต์อยู่ใน GitHub

โคลนที่เก็บ Git โดยใช้คำสั่งต่อไปนี้

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

หลังจากสร้างโค้ดตัวอย่างเวอร์ชันในเครื่องแล้ว คุณจะนำเข้าโปรเจ็กต์ ไปยัง iOS Studio และเรียกใช้แอปได้ ดูข้อมูลเพิ่มเติมได้ในคู่มือการตั้งค่าสำหรับ iOS

ตัวเลือกการกำหนดค่า

ใช้ตัวเลือกการกำหนดค่าต่อไปนี้เพื่อตั้งค่าแอป iOS

การแปลงโมเดล

LLM Inference API ใช้ได้กับโมเดลประเภทต่อไปนี้ ซึ่งบางโมเดลต้องมีการแปลง ใช้ตารางเพื่อระบุขั้นตอนที่จำเป็น วิธีสำหรับโมเดลของคุณ

ดูวิธีแปลงโมเดลอื่นๆ ได้ที่ส่วนการแปลงโมเดล

การปรับแต่ง LoRA

LLM Inference API รองรับการปรับแต่ง LoRA (Low-Rank Adaptation) โดยใช้ไลบรารี PEFT (Parameter-Efficient Fine-Tuning) การปรับแต่ง LoRA จะปรับแต่งลักษณะการทำงานของ LLM ผ่านกระบวนการฝึกที่มีต้นทุนต่ำ โดยสร้างชุดน้ำหนักที่ฝึกได้ขนาดเล็กตามข้อมูลการฝึกใหม่แทนที่จะฝึกโมเดลทั้งหมดอีกครั้ง

LLM Inference API รองรับการเพิ่มน้ำหนัก LoRA ลงในเลเยอร์ความสนใจของโมเดล Gemma-2 2B, Gemma 2B และ Phi-2 ดาวน์โหลดโมเดลในรูปแบบ safetensors

โมเดลพื้นฐานต้องอยู่ในรูปแบบ safetensors จึงจะสร้างน้ำหนัก LoRA ได้ หลังจากการฝึก LoRA คุณจะแปลงโมเดลเป็นรูปแบบ FlatBuffers เพื่อเรียกใช้ใน MediaPipe ได้

เตรียมน้ำหนัก LoRA

ใช้คำแนะนำวิธีการ LoRA จาก PEFT เพื่อฝึกโมเดล LoRA ที่ปรับแต่งแล้วในชุดข้อมูลของคุณเอง

LLM Inference API รองรับเฉพาะ LoRA ในเลเยอร์ความสนใจ ดังนั้นให้ระบุเฉพาะ เลเยอร์ความสนใจใน 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"],
)

หลังจากฝึกโมเดลในชุดข้อมูลที่เตรียมไว้และบันทึกโมเดลแล้ว น้ำหนักของโมเดล LoRA ที่ปรับแต่งแล้วจะพร้อมใช้งานใน adapter_model.safetensors safetensors คือจุดตรวจสอบ LoRA ที่ใช้ในระหว่างการแปลงโมเดล

การแปลงโมเดล

ใช้แพ็กเกจ Python ของ MediaPipe เพื่อแปลงน้ำหนักของโมเดลเป็นรูปแบบ Flatbuffer ConversionConfig ระบุตัวเลือกโมเดลพื้นฐานพร้อมกับตัวเลือก 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)

ตัวแปลงจะสร้างไฟล์ Flatbuffer 2 ไฟล์ ไฟล์หนึ่งสำหรับโมเดลพื้นฐานและ อีกไฟล์หนึ่งสำหรับโมเดล LoRA

การอนุมานโมเดล LoRA

iOS รองรับ LoRA แบบคงที่ในระหว่างการเริ่มต้น หากต้องการโหลดโมเดล LoRA ให้ระบุเส้นทางโมเดล LoRA รวมถึง 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)

หากต้องการเรียกใช้การอนุมาน LLM ด้วย LoRA ให้ใช้วิธีการ generateResponse() หรือ generateResponseAsync() เดียวกันกับโมเดลพื้นฐาน