สร้างประสบการณ์แบบไฮบริดในแอป Android ด้วยโมเดลในอุปกรณ์และโมเดลที่โฮสต์ในระบบคลาวด์


คุณสามารถสร้างแอปและฟีเจอร์ Android ที่ขับเคลื่อนด้วย AI พร้อมการอนุมานแบบไฮบริดโดยใช้ Firebase AI Logic การอนุมานแบบไฮบริดช่วยให้สามารถทำการอนุมานโดยใช้โมเดลในอุปกรณ์เมื่อพร้อมใช้งาน และเปลี่ยนไปใช้โมเดลที่โฮสต์ในระบบคลาวด์ได้อย่างราบรื่นในกรณีอื่นๆ (และในทางกลับกัน)

หน้านี้อธิบายวิธี เริ่มต้นใช้งาน Client SDK, รวมถึงแสดง ตัวเลือกการกำหนดค่าและความสามารถเพิ่มเติม, เช่น อุณหภูมิ

โปรดทราบว่าระบบรองรับการอนุมานบนอุปกรณ์ผ่าน Firebase AI Logic สำหรับแอป Android ที่ทำงานบนอุปกรณ์บางรุ่น และการอนุมานดังกล่าวอยู่ภายใต้ข้อกำหนดของ ML Kit รวมถึงข้อกำหนดที่เฉพาะเจาะจงกับส่วน Gen AI ของ ML Kit

กรณีการใช้งานที่แนะนำและความสามารถที่รองรับ

กรณีการใช้งานที่แนะนำ

  • การใช้โมเดลในอุปกรณ์เพื่อการอนุมาน มีข้อดีดังนี้

    • ความเป็นส่วนตัวที่ดียิ่งขึ้น
    • บริบทในเครื่อง
    • การอนุมานโดยไม่มีค่าใช้จ่าย
    • ฟังก์ชันการทำงานแบบออฟไลน์

  • การใช้ฟังก์ชันการทำงานแบบไฮบริด มีข้อดีดังนี้

    • เข้าถึงกลุ่มเป้าหมายได้มากขึ้นด้วยการรองรับความพร้อมใช้งานของโมเดลในอุปกรณ์และการเชื่อมต่ออินเทอร์เน็ต

ความสามารถและฟีเจอร์ที่รองรับสำหรับการอนุมานในอุปกรณ์

การอนุมานในอุปกรณ์รองรับเฉพาะการสร้างข้อความแบบครั้งเดียว (ไม่ใช่ แชท) โดยมีเอาต์พุตแบบสตรีมมิงหรือไม่สตรีมมิง และรองรับความสามารถในการสร้างข้อความต่อไปนี้

โปรดตรวจสอบรายการฟีเจอร์ที่ ยังไม่พร้อมใช้งานสำหรับการอนุมานในอุปกรณ์ ที่ด้านล่างของหน้านี้

ก่อนเริ่มต้น

โปรดทราบข้อมูลต่อไปนี้

อุปกรณ์ Android ที่รองรับและโมเดลในอุปกรณ์ของอุปกรณ์เหล่านั้น

สำหรับการอนุมานในอุปกรณ์ (ซึ่งใช้ Prompt API จาก ML Kit) คุณ สามารถดูรายการ อุปกรณ์ที่รองรับและโมเดลในอุปกรณ์ของอุปกรณ์เหล่านั้น ได้ในเอกสารประกอบของ ML Kit

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

ขั้นตอนการเริ่มต้นใช้งานเหล่านี้อธิบายการตั้งค่าทั่วไปที่จำเป็นสำหรับคำขอพรอมต์ที่รองรับซึ่งคุณต้องการส่ง

ขั้นตอนที่ 1: ตั้งค่าโปรเจ็กต์ Firebase และเชื่อมต่อแอปกับ Firebase

  1. ลงชื่อเข้าใช้คอนโซล Firebase แล้วเลือกโปรเจ็กต์ Firebase

  2. ในคอนโซล Firebase ให้ไปที่บริการ AI > AI Logic

  3. คลิก เริ่มต้นใช้งาน เพื่อเปิดเวิร์กโฟลว์แบบแนะนำที่จะช่วยคุณตั้งค่า API ที่จำเป็น และทรัพยากรสำหรับโปรเจ็กต์

  4. ตั้งค่าโปรเจ็กต์ให้ใช้ผู้ให้บริการ "Gemini API"

    เราขอแนะนำให้เริ่มต้นใช้งาน Gemini Developer API. คุณสามารถตั้งค่า Vertex AI Gemini API (และข้อกำหนดในการเรียกเก็บเงิน) ได้ทุกเมื่อ

    สำหรับ Gemini Developer API คอนโซลจะเปิดใช้ API ที่จำเป็น และสร้างคีย์ Gemini API ในโปรเจ็กต์
    อย่า เพิ่ม คีย์ Gemini API นี้ลงในฐานของโค้ดของแอป ดูข้อมูลเพิ่มเติม

  5. หากระบบแจ้งในเวิร์กโฟลว์ของคอนโซล ให้ทำตามวิธีการบนหน้าจอเพื่อลงทะเบียนแอปและเชื่อมต่อแอปกับ Firebase

  6. ทำตามขั้นตอนถัดไปในคู่มือนี้เพื่อเพิ่ม SDK ลงในแอป

ขั้นตอนที่ 2: เพิ่ม SDK ที่จำเป็น

Firebase AI Logic SDK สำหรับ Android (firebase-ai) พร้อมกับ Firebase AI Logic On-Device SDK (firebase-ai-ondevice) ให้สิทธิ์เข้าถึง API สำหรับการโต้ตอบกับโมเดล Generative

ในไฟล์ Gradle ของโมดูล (ระดับแอป) (เช่น <project>/<app-module>/build.gradle.kts) ให้เพิ่มทรัพยากร Dependency สำหรับ Firebase AI Logicไลบรารีสำหรับ Android ดังนี้

Kotlin 

dependencies {
  // ... other androidx dependencies

  // Add the dependencies for the Firebase AI Logic libraries
  // Note that the on-device SDK is not yet included in the Firebase Android BoM
  implementation("com.google.firebase:firebase-ai:17.12.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta02")
}

Java

สำหรับ Java คุณต้องเพิ่มไลบรารีอีก 2 รายการ

dependencies {
  // ... other androidx dependencies

  // Add the dependencies for the Firebase AI Logic libraries
  // Note that the on-device SDK is not yet included in the Firebase Android BoM
  implementation("com.google.firebase:firebase-ai:17.12.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta02")

  // Required for one-shot operations (to use `ListenableFuture` from Guava Android)
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations (to use `Publisher` from Reactive Streams)
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

ขั้นตอนที่ 3: ตรวจสอบว่าโมเดลในอุปกรณ์พร้อมใช้งานหรือไม่

ใช้ FirebaseAIOnDevice, เพื่อตรวจสอบว่าโมเดลในอุปกรณ์พร้อมใช้งานหรือไม่ และดาวน์โหลดโมเดลหากไม่ พร้อมใช้งาน

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

Kotlin 

val status = FirebaseAIOnDevice.checkStatus()
when (status) {
  OnDeviceModelStatus.UNAVAILABLE -> {
    Log.w(TAG, "On-device model is unavailable")
  }

  OnDeviceModelStatus.DOWNLOADABLE -> {
    FirebaseAIOnDevice.download().collect { status ->
      when (status) {
        is DownloadStatus.DownloadStarted ->
          Log.w(TAG, "Starting download - ${status.bytesToDownload}")

        is DownloadStatus.DownloadInProgress ->
          Log.w(TAG, "Download in progress ${status.totalBytesDownloaded} bytes downloaded")

        is DownloadStatus.DownloadCompleted ->
          Log.w(TAG, "On-device model download complete")

        is DownloadStatus.DownloadFailed ->
          Log.e(TAG, "Download failed ${status}")
      }
    }
  }
  OnDeviceModelStatus.DOWNLOADING -> {
    Log.w(TAG, "On-device model is being downloaded")
  }

  OnDeviceModelStatus.AVAILABLE -> {
    Log.w(TAG, "On-device model is available")
  }
}

Java 

Checking for and downloading the model is not yet available for Java.

However, all other APIs and interactions in this guide are available for Java.

โปรดทราบข้อมูลต่อไปนี้เกี่ยวกับการดาวน์โหลดโมเดลในอุปกรณ์

  • เวลาที่ใช้ในการดาวน์โหลดโมเดลในอุปกรณ์ขึ้นอยู่กับหลายปัจจัย รวมถึงเครือข่ายของคุณ

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

  • หากโมเดลในอุปกรณ์ ไม่พร้อมใช้งาน เมื่อมีการส่งคำขอการอนุมานในอุปกรณ์ SDK จะ ไม่ ทริกเกอร์การดาวน์โหลดโมเดลในอุปกรณ์ โดยอัตโนมัติ SDK จะเปลี่ยนไปใช้โมเดลที่โฮสต์ในระบบคลาวด์หรือ แสดงข้อยกเว้น (ดูรายละเอียดเกี่ยวกับลักษณะการทำงานของ โหมดการอนุมาน)

  • AICore (บริการของระบบ Android) จะจัดการโมเดลและเวอร์ชันที่จะ ดาวน์โหลด อัปเดตโมเดล และอื่นๆ ให้คุณ โปรดทราบว่าอุปกรณ์จะดาวน์โหลด โมเดลได้เพียงโมเดลเดียว ดังนั้นหากแอปอื่นในอุปกรณ์ได้ดาวน์โหลด โมเดลบนอุปกรณ์เรียบร้อยแล้วก่อนหน้านี้ การตรวจสอบนี้จะแสดง ว่าโมเดลพร้อมใช้งาน

การเพิ่มประสิทธิภาพเวลาในการตอบสนอง

หากต้องการเพิ่มประสิทธิภาพสำหรับการเรียกการอนุมานครั้งแรก คุณสามารถให้แอปเรียก warmup() ได้ ซึ่งจะโหลดโมเดลในอุปกรณ์ลงในหน่วยความจำและเริ่มต้นคอมโพเนนต์รันไทม์

ขั้นตอนที่ 4: เริ่มต้นบริการและสร้างอินสแตนซ์ของโมเดล

คลิกผู้ให้บริการ Gemini API เพื่อดูเนื้อหาที่เฉพาะเจาะจงของผู้ให้บริการ และโค้ดในหน้านี้

ตั้งค่าสิ่งต่อไปนี้ก่อนส่งคำขอพรอมต์ไปยังโมเดล

  1. เริ่มต้นบริการสำหรับผู้ให้บริการ API ที่คุณเลือก

  2. สร้างอินสแตนซ์ GenerativeModel และตั้งค่า mode เป็นค่าใดค่าหนึ่งต่อไปนี้ คำอธิบายที่นี่เป็นคำอธิบายระดับสูงมาก แต่คุณสามารถดู รายละเอียดเกี่ยวกับลักษณะการทำงานของโหมดเหล่านี้ได้ใน หัวข้อตั้งค่าโหมดการอนุมาน

    • PREFER_ON_DEVICE: พยายามใช้โมเดลในอุปกรณ์ หากไม่ได้ผล ให้เปลี่ยนไปใช้โมเดลที่โฮสต์ในระบบคลาวด์

    • ONLY_ON_DEVICE: พยายามใช้โมเดลในอุปกรณ์ หากไม่ได้ผล ให้แสดงข้อยกเว้น

    • PREFER_IN_CLOUD: พยายามใช้โมเดลที่โฮสต์ในระบบคลาวด์ หากไม่ได้ผล ให้เปลี่ยนไปใช้โมเดลในอุปกรณ์

    • ONLY_IN_CLOUD: พยายามใช้โมเดลที่โฮสต์ในระบบคลาวด์ หากไม่ได้ผล ให้แสดงข้อยกเว้น

Kotlin 

// Using this SDK to access on-device inference is an Experimental release and requires opt-in
@OptIn(PublicPreviewAPI::class)

// ...

// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "MODEL_NAME",
        onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE)
    )

Java 

// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .generativeModel(
        "MODEL_NAME",
        new OnDeviceConfig(InferenceMode.PREFER_ON_DEVICE)
    );

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

ขั้นตอนที่ 5: ส่งคำขอพรอมต์ไปยังโมเดล

ส่วนนี้แสดงวิธีส่งอินพุตประเภทต่างๆ เพื่อสร้างเอาต์พุตประเภทต่างๆ ซึ่งรวมถึง

สร้างข้อความจากอินพุตข้อความเท่านั้น

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

คุณสามารถใช้ generateContent() เพื่อสร้างข้อความจากพรอมต์ที่มีข้อความได้ดังนี้

Kotlin 

// Imports + initialization of Gemini API backend service + creation of model instance

// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
val response = model.generateContent(prompt)
print(response.text)

Java 

// Imports + initialization of Gemini API backend service + creation of model instance

// Provide a prompt that contains text
Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

// To generate text output, call generateContent with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

โปรดทราบว่า Firebase AI Logic ยังรองรับการสตรีมมิงการตอบกลับข้อความโดยใช้ generateContentStream (แทน generateContent)

สร้างข้อความจากอินพุตข้อความและรูปภาพ (มัลติโมดัล)

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

คุณสามารถใช้ generateContent() เพื่อสร้างข้อความจากพรอมต์ที่มีข้อความและไฟล์รูปภาพสูงสุด 1 ไฟล์ (Bitmap เท่านั้น) โดยระบุmimeType และไฟล์ของอินพุตแต่ละไฟล์

Kotlin 

// Imports + initialization of Gemini API backend service + creation of model instance

// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)

Java 

// Imports + initialization of Gemini API backend service + creation of model instance

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

โปรดทราบว่า Firebase AI Logic ยังรองรับการสตรีมมิงการตอบกลับข้อความโดยใช้ generateContentStream (แทน generateContent)

สิ่งอื่นๆ ที่ทำได้

คุณสามารถใช้ตัวเลือกการกำหนดค่าและความสามารถเพิ่มเติมต่างๆ สำหรับประสบการณ์ใช้งานแบบไฮบริดได้ดังนี้

ฟีเจอร์ที่ยังไม่พร้อมใช้งานสำหรับการอนุมานในอุปกรณ์

เนื่องจากเป็นเวอร์ชันทดลอง จึงยังไม่มีความสามารถบางอย่างของโมเดลในระบบคลาวด์สำหรับการอนุมาน ในอุปกรณ์

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

  • การสร้างเอาต์พุตที่มีโครงสร้าง (เช่น JSON หรือ Enum)

  • การสร้างข้อความจากประเภทอินพุตไฟล์รูปภาพที่ไม่ใช่ Bitmap (รูปภาพที่โหลดลงในหน่วยความจำ)

  • การสร้างข้อความจากไฟล์รูปภาพมากกว่า 1 ไฟล์

  • การสร้างข้อความจากอินพุตเสียง วิดีโอ และเอกสาร (เช่น PDF)

  • การสร้างรูปภาพโดยใช้โมเดล Gemini หรือ Imagen

  • การระบุไฟล์โดยใช้ URL ในคำขอมัลติโมดัล คุณต้องระบุไฟล์เป็นข้อมูลแบบอินไลน์ให้กับโมเดลในอุปกรณ์

  • การส่งคำขอที่มีโทเค็นเกิน 4,000 รายการ (หรือประมาณ 3,000 คำในภาษาอังกฤษ)

  • แชทหลายรอบ

  • การระบุ เครื่องมือ ให้โมเดลเพื่อช่วยสร้างการตอบกลับ (เช่น การเรียกใช้ฟังก์ชัน การดำเนินการโค้ด บริบท URL และ Grounding ด้วย Google Search)

การตรวจสอบ AI ในคอนโซล Firebase ไม่ แสดงข้อมูลสำหรับการอนุมานในอุปกรณ์ (รวมถึงบันทึกในอุปกรณ์) อย่างไรก็ตาม คุณสามารถตรวจสอบการอนุมานที่ใช้ โมเดลที่โฮสต์ในระบบคลาวด์ได้เช่นเดียวกับการอนุมานอื่นๆ ผ่าน Firebase AI Logic

ข้อจำกัดเพิ่มเติม

นอกเหนือจากข้อจำกัดข้างต้น การอนุมาน ในอุปกรณ์ ยังมีข้อจำกัดต่อไปนี้ด้วย (ดูข้อมูลเพิ่มเติมใน เอกสารประกอบของ ML Kit):

  • ผู้ใช้ปลายทางของแอปต้องใช้อุปกรณ์ที่ รองรับ สำหรับการอนุมานในอุปกรณ์

  • แอปจะทำการอนุมานในอุปกรณ์ได้ก็ต่อเมื่อแอปทำงานอยู่เบื้องหน้าเท่านั้น

  • ระบบได้ตรวจสอบแล้วว่าการอนุมานในอุปกรณ์รองรับภาษาอังกฤษและภาษาเกาหลี

  • ขีดจำกัดโทเค็นสูงสุดสำหรับคำขอการอนุมานในอุปกรณ์ทั้งหมดคือ 4,000 โทเค็น หากคำขอของคุณอาจเกินขีดจำกัดนี้ โปรดตรวจสอบว่าได้กำหนดค่าโหมดการอนุมานที่ใช้โมเดลที่โฮสต์ในระบบคลาวด์ได้

  • เราขอแนะนำให้หลีกเลี่ยงกรณีการใช้งานการอนุมานในอุปกรณ์ที่ต้องใช้เอาต์พุตยาว (มากกว่า 256 โทเค็น)

  • AICore (บริการของระบบ Android ที่จัดการโมเดลในอุปกรณ์) บังคับใช้ โควต้าการอนุมาน ต่อแอป การส่งคำขอ API มากเกินไปในช่วงเวลาสั้นๆ จะส่งผลให้เกิดการตอบกลับ ErrorCode.BUSY หากคุณได้รับข้อผิดพลาดนี้ ให้ลองใช้ Exponential Backoff เพื่อลองส่งคำขออีกครั้ง นอกจากนี้ ระบบยังอาจแสดง ErrorCode.PER_APP_BATTERY_USE_QUOTA_EXCEEDED หากแอปใช้โควต้าเกินระยะเวลานาน (เช่น โควต้าประจำวัน)


แสดงความคิดเห็น เกี่ยวกับประสบการณ์ใช้งานFirebase AI Logic