สร้างผู้ช่วย Smart Shopping ด้วย AlloyDB และ Vertex AI Agent Builder - ส่วนที่ 1

1. ภาพรวม

ในสภาพแวดล้อมการค้าปลีกที่รวดเร็วในปัจจุบัน การให้บริการลูกค้าที่ยอดเยี่ยมพร้อมทั้งมอบประสบการณ์การช็อปปิ้งที่ปรับเปลี่ยนในแบบของผู้ใช้จึงเป็นสิ่งสำคัญอย่างยิ่ง เราจะพาคุณไปพบกับการเดินทางด้านเทคนิคผ่านการสร้างแอปพลิเคชันแชทที่ขับเคลื่อนด้วยความรู้ ซึ่งออกแบบมาเพื่อตอบคำถามของลูกค้า แนะนำการค้นพบผลิตภัณฑ์ และปรับแต่งผลการค้นหา โซลูชันนวัตกรรมนี้รวมความสามารถของ AlloyDB สำหรับการจัดเก็บข้อมูล เครื่องมือวิเคราะห์ภายในสำหรับการทำความเข้าใจตามบริบท Gemini (โมเดลภาษาขนาดใหญ่) สำหรับการตรวจสอบความเกี่ยวข้อง และ Agent Builder ของ Google สำหรับการเริ่มต้นใช้งานผู้ช่วยสนทนาอัจฉริยะอย่างรวดเร็ว

ความท้าทาย: ลูกค้าค้าปลีกในปัจจุบันคาดหวังว่าจะได้รับคำตอบทันทีและคำแนะนำผลิตภัณฑ์ที่สอดคล้องกับความต้องการเฉพาะของตน วิธีการค้นหาแบบเดิมๆ มักไม่สามารถให้การปรับเปลี่ยนในแบบของคุณในระดับนี้ได้

โซลูชัน: แอปพลิเคชันแชทที่ขับเคลื่อนด้วยความรู้ของเราจะรับมือกับความท้าทายนี้โดยตรง โดยใช้ประโยชน์จากฐานความรู้ที่ได้จากข้อมูลการค้าปลีกเพื่อทำความเข้าใจความตั้งใจของลูกค้า ตอบสนองอย่างชาญฉลาด และแสดงผลลัพธ์ที่เกี่ยวข้องอย่างยิ่ง

สิ่งที่คุณจะสร้าง

ในแล็บนี้ (ส่วนที่ 1) คุณจะได้ทำสิ่งต่อไปนี้

  1. สร้างอินสแตนซ์ AlloyDB และโหลดชุดข้อมูลอีคอมเมิร์ซ
  2. เปิดใช้ส่วนขยายโมเดล pgvector และ Generative AI ใน AlloyDB
  3. สร้างการฝังจากรายละเอียดผลิตภัณฑ์
  4. ทำการค้นหาความคล้ายคลึงกันของโคไซน์แบบเรียลไทม์สำหรับข้อความค้นหาของผู้ใช้
  5. ติดตั้งใช้งานโซลูชันในฟังก์ชัน Cloud Run แบบ Serverless

ส่วนที่ 2 ของแล็บจะครอบคลุมขั้นตอนการสร้าง Agent

ข้อกำหนด

  • เบราว์เซอร์ เช่น Chrome หรือ Firefox
  • โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน

2. สถาปัตยกรรม

การไหลเวียนของข้อมูล: มาดูรายละเอียดวิธีที่ข้อมูลไหลเวียนผ่านระบบของเรากัน

การส่งผ่านข้อมูล

ขั้นตอนแรกของเราคือการนำเข้าข้อมูลค้าปลีก (สินค้าคงคลัง คำอธิบายผลิตภัณฑ์ การโต้ตอบของลูกค้า) ไปยัง AlloyDB

เครื่องมือวิเคราะห์:

เราจะใช้ AlloyDB เป็นเครื่องมือวิเคราะห์เพื่อดำเนินการต่อไปนี้

  1. การแยกบริบท: เครื่องมือจะวิเคราะห์ข้อมูลที่จัดเก็บไว้ใน AlloyDB เพื่อทำความเข้าใจความสัมพันธ์ระหว่างผลิตภัณฑ์ หมวดหมู่ พฤติกรรมของลูกค้า ฯลฯ ตามความเหมาะสม
  2. การฝังการสร้าง: ระบบจะสร้างการฝัง (การแสดงข้อความในรูปแบบคณิตศาสตร์) สำหรับทั้งคำค้นหาของผู้ใช้และข้อมูลที่จัดเก็บไว้ใน AlloyDB
  3. การค้นหาเวกเตอร์: เครื่องมือจะทำการค้นหาความคล้ายคลึงโดยเปรียบเทียบการฝังคำค้นหากับการฝังของรายละเอียดผลิตภัณฑ์ รีวิว และข้อมูลอื่นๆ ที่เกี่ยวข้อง ซึ่งจะระบุ "เพื่อนบ้านที่ใกล้ที่สุด" 25 รายการที่เกี่ยวข้องมากที่สุด

การตรวจสอบ Gemini:

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

การสร้างคำตอบ:

การตอบกลับที่ตรวจสอบแล้วจะจัดโครงสร้างเป็นอาร์เรย์ JSON และระบบทั้งหมดจะรวมอยู่ในฟังก์ชัน Cloud Run แบบไร้เซิร์ฟเวอร์ที่เรียกใช้จาก Agent Builder

การโต้ตอบแบบสนทนา:

Agent Builder จะแสดงคำตอบต่อผู้ใช้ในรูปแบบภาษาที่เป็นธรรมชาติ ซึ่งช่วยให้เกิดการสนทนาไปมา ส่วนนี้จะกล่าวถึงในแล็บติดตามผล

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

สร้างโปรเจ็กต์

  1. ในคอนโซล Google Cloud ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud ในหน้าตัวเลือกโปรเจ็กต์
  2. ตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ Cloud แล้ว ดูวิธีตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินในโปรเจ็กต์แล้วหรือไม่
  3. คุณจะใช้ Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานใน Google Cloud และโหลด bq ไว้ล่วงหน้า คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของคอนโซล Google Cloud

รูปภาพปุ่มเปิดใช้งาน Cloud Shell

  1. เมื่อเชื่อมต่อกับ Cloud Shell แล้ว ให้ตรวจสอบว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและตั้งค่าโปรเจ็กต์เป็นรหัสโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้
gcloud auth list
  1. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ
gcloud config list project
  1. หากไม่ได้ตั้งค่าโปรเจ็กต์ ให้ใช้คำสั่งต่อไปนี้เพื่อตั้งค่า
gcloud config set project <YOUR_PROJECT_ID>
  1. เปิดใช้ API ที่จำเป็น
gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com \
                       aiplatform.googleapis.com

คุณสามารถใช้คอนโซลแทนคำสั่ง gcloud ได้โดยค้นหาแต่ละผลิตภัณฑ์หรือใช้ลิงก์นี้

หากพลาด API ใดไป คุณก็เปิดใช้ได้เสมอในระหว่างการติดตั้งใช้งาน

โปรดดูคำสั่งและการใช้งาน gcloud ในเอกสารประกอบ

4. การตั้งค่าฐานข้อมูล

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

มาสร้างคลัสเตอร์ อินสแตนซ์ และตาราง AlloyDB ที่จะโหลดชุดข้อมูลอีคอมเมิร์ซกัน

สร้างคลัสเตอร์และอินสแตนซ์

  1. ไปที่หน้า AlloyDB ใน Cloud Console วิธีง่ายๆ ในการค้นหาหน้าส่วนใหญ่ใน Cloud Console คือการค้นหาโดยใช้แถบค้นหาของคอนโซล
  2. เลือกสร้างคลัสเตอร์จากหน้านั้น

f76ff480c8c889aa.png

  1. คุณจะเห็นหน้าจอคล้ายกับหน้าจอด้านล่าง สร้างคลัสเตอร์และอินสแตนซ์ด้วยค่าต่อไปนี้
  • รหัสคลัสเตอร์: "shopping-cluster"
  • รหัสผ่าน: "alloydb"
  • รองรับ PostgreSQL 15
  • ภูมิภาค: "us-central1"
  • การสร้างเครือข่าย: "default"

538dba58908162fb.png

  1. เมื่อเลือกเครือข่ายเริ่มต้น คุณจะเห็นหน้าจอคล้ายกับหน้าจอด้านล่าง เลือกตั้งค่าการเชื่อมต่อ
    7939bbb6802a91bf.png
  2. จากนั้นเลือก "ใช้ช่วง IP ที่มีการจัดสรรโดยอัตโนมัติ" แล้วคลิก "ต่อไป" หลังจากตรวจสอบข้อมูลแล้ว ให้เลือกสร้างการเชื่อมต่อ 768ff5210e79676f.png
  3. เมื่อตั้งค่าเครือข่ายแล้ว คุณจะสร้างคลัสเตอร์ต่อไปได้ คลิกสร้างคลัสเตอร์เพื่อตั้งค่าคลัสเตอร์ให้เสร็จสมบูรณ์ตามที่แสดงด้านล่าง

e06623e55195e16e.png

อย่าลืมเปลี่ยนรหัสอินสแตนซ์เป็น "shopping-instance"

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

24eec29fa5cfdb3e.png

5. การนำเข้าข้อมูล

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

847e35f1bf8a8bd8.png

คุณอาจต้องรอให้อินสแตนซ์สร้างเสร็จเรียบร้อย เมื่อพร้อมแล้ว ให้ลงชื่อเข้าใช้ AlloyDB โดยใช้ข้อมูลเข้าสู่ระบบที่คุณสร้างขึ้นเมื่อสร้างคลัสเตอร์ ใช้ข้อมูลต่อไปนี้เพื่อตรวจสอบสิทธิ์ใน PostgreSQL

  • ชื่อผู้ใช้ : "postgres"
  • ฐานข้อมูล : "postgres"
  • รหัสผ่าน : "alloydb"

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

91a86d9469d499c4.png

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

เปิดใช้ส่วนขยาย

ในการสร้างแอปนี้ เราจะใช้ส่วนขยาย pgvector และ google_ml_integration ส่วนขยาย pgvector ช่วยให้คุณจัดเก็บและค้นหาการฝังเวกเตอร์ได้ ส่วนขยาย google_ml_integration มีฟังก์ชันที่คุณใช้เพื่อเข้าถึงปลายทางการคาดการณ์ของ Vertex AI เพื่อรับการคาดการณ์ใน SQL เปิดใช้ส่วนขยายเหล่านี้โดยเรียกใช้ DDL ต่อไปนี้

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

หากต้องการตรวจสอบส่วนขยายที่เปิดใช้ในฐานข้อมูล ให้เรียกใช้คำสั่ง SQL นี้

select extname, extversion from pg_extension;

สร้างตาราง

สร้างตารางโดยใช้คำสั่ง DDL ด้านล่าง

CREATE TABLE
 apparels ( id BIGINT,
   category VARCHAR(100),
   sub_category VARCHAR(50),
   uri VARCHAR(200),
   image VARCHAR(100),
   content VARCHAR(2000),
   pdt_desc VARCHAR(5000),
   embedding vector(768) );

เมื่อดำเนินการคำสั่งข้างต้นสำเร็จ คุณควรจะดูตารางในฐานข้อมูลได้ ตัวอย่างภาพหน้าจอแสดงอยู่ด้านล่าง

908e33bbff58a6d.png

ส่งผ่านข้อมูล

สำหรับแล็บนี้ เรามีข้อมูลทดสอบประมาณ 200 รายการในไฟล์ SQL นี้ มี id, category, sub_category, uri, image และ content ส่วนช่องอื่นๆ จะกรอกในภายหลังในห้องทดลอง

คัดลอกบรรทัด/คำสั่งแทรก 20 บรรทัดจากที่นั่น จากนั้นวางบรรทัดเหล่านั้นในแท็บเครื่องมือแก้ไขที่ว่างเปล่า แล้วเลือกเรียกใช้

หากต้องการดูเนื้อหาของตาราง ให้ขยายส่วน Explorer จนกว่าจะเห็นตารางชื่อ apparels เลือกปุ่มสามจุด (⋮) เพื่อดูตัวเลือกในการค้นหาตาราง คำสั่ง SELECT จะเปิดขึ้นในแท็บเครื่องมือแก้ไขใหม่

b31ece70e670ab89.png

ให้สิทธิ์

เรียกใช้คำสั่งด้านล่างเพื่อมอบสิทธิ์ในการเรียกใช้ฟังก์ชัน embedding ให้กับผู้ใช้ postgres

GRANT EXECUTE ON FUNCTION embedding TO postgres;

มอบบทบาทผู้ใช้ Vertex AI ให้กับบัญชีบริการ AlloyDB

ไปที่เทอร์มินัล Cloud Shell แล้วป้อนคำสั่งต่อไปนี้

PROJECT_ID=$(gcloud config get-value project)

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

6. บริบท

กลับไปที่หน้าอินสแตนซ์ AlloyDB

หากต้องการสร้างการฝัง เราจะต้องมี context กล่าวคือข้อมูลทั้งหมดที่เราต้องการรวมไว้ในช่องเดียว เราจะทำเช่นนี้โดยการสร้างคำอธิบายผลิตภัณฑ์ (ซึ่งเราจะเรียกว่า pdt_desc) ในกรณีของเรา เราจะใช้ข้อมูลทั้งหมดเกี่ยวกับผลิตภัณฑ์แต่ละรายการ แต่เมื่อคุณทำเช่นนี้กับข้อมูลของคุณเอง คุณสามารถปรับแต่งข้อมูลในลักษณะใดก็ได้ที่เห็นว่ามีความหมายต่อธุรกิจของคุณ

เรียกใช้คำสั่งต่อไปนี้จาก AlloyDB Studio ของอินสแตนซ์ที่สร้างขึ้นใหม่ การดำเนินการนี้จะอัปเดตฟิลด์ pdt_desc ด้วยข้อมูลบริบท

UPDATE
 apparels
SET
 pdt_desc = CONCAT('This product category is: ', category, ' and sub_category is: ', sub_category, '. The description of the product is as follows: ', content, '. The product image is stored at: ', uri)
WHERE
 id IS NOT NULL;

DML นี้จะสร้างสรุปบริบทอย่างง่ายโดยใช้ข้อมูลจากฟิลด์ทั้งหมดที่มีในตารางและการอ้างอิงอื่นๆ (หากมีใน Use Case ของคุณ) หากต้องการจัดเรียงข้อมูลและสร้างบริบทให้แม่นยำยิ่งขึ้น คุณสามารถออกแบบข้อมูลในรูปแบบใดก็ได้ที่เห็นว่ามีประโยชน์ต่อธุรกิจ

7. สร้างการฝังสำหรับบริบท

คอมพิวเตอร์ประมวลผลตัวเลขได้ง่ายกว่าประมวลผลข้อความมาก ระบบการฝังจะแปลงข้อความเป็นชุดของตัวเลขทศนิยมที่ควรแสดงข้อความ ไม่ว่าข้อความนั้นจะเขียนอย่างไร ใช้ภาษาใด ฯลฯ

ลองอธิบายสถานที่ริมทะเล อาจเรียกว่า "ริมน้ำ" "ติดชายหาด" "เดินจากห้องไปมหาสมุทร" "sur la mer" "на берегу океана" ฯลฯ คำเหล่านี้ดูแตกต่างกัน แต่ความหมายเชิงความหมายหรือในคำศัพท์ของแมชชีนเลิร์นนิง การฝังควรจะใกล้เคียงกันมาก

เมื่อข้อมูลและบริบทพร้อมแล้ว เราจะเรียกใช้ SQL เพื่อเพิ่มการฝังของคำอธิบายผลิตภัณฑ์ลงในตารางในช่อง embedding คุณใช้โมเดลการฝังได้หลากหลาย เราใช้ text-embedding-004 จาก Vertex AI โปรดใช้โมเดลการฝังเดียวกันตลอดทั้งโปรเจ็กต์

หมายเหตุ: หากคุณใช้โปรเจ็กต์ Google Cloud ที่มีอยู่ซึ่งสร้างขึ้นเมื่อนานมาแล้ว คุณอาจต้องใช้โมเดลการฝังข้อความเวอร์ชันเก่าต่อไป เช่น textembedding-gecko

UPDATE
 apparels
SET
 embedding = embedding( 'text-embedding-004',
   pdt_desc)
WHERE
 TRUE;

ดูapparelsตารางอีกครั้งเพื่อดูการฝังบางส่วน อย่าลืมเรียกใช้คำสั่ง SELECT อีกครั้งเพื่อดูการเปลี่ยนแปลง

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 apparels;

ซึ่งควรแสดงผลเวกเตอร์การฝังที่มีลักษณะคล้ายอาร์เรย์ของจำนวนทศนิยมสำหรับข้อความตัวอย่างในคำค้นหา ดังที่แสดงด้านล่าง

c69c08d085389f74.png

หมายเหตุ: โปรเจ็กต์ Google Cloud ที่สร้างใหม่ภายใต้รุ่นฟรีอาจประสบปัญหาโควต้าเมื่อพูดถึงจำนวนคำขอ Embedding ที่อนุญาตต่อวินาทีไปยังโมเดล Embedding เราขอแนะนำให้คุณใช้การค้นหาตัวกรองสำหรับรหัส จากนั้นเลือก 1-5 ระเบียนและอื่นๆ ในขณะที่สร้างการฝัง

8. ทำการค้นหาเวกเตอร์

ตอนนี้ตาราง ข้อมูล และการฝังพร้อมแล้ว เรามาทำการค้นหาเวกเตอร์แบบเรียลไทม์สำหรับข้อความค้นหาของผู้ใช้กัน

สมมติว่าผู้ใช้ถามว่า

"ฉันต้องการเสื้อผู้หญิง สีชมพูแบบลำลองที่เป็นผ้าฝ้ายแท้เท่านั้น"

คุณดูการจับคู่สำหรับรายการนี้ได้โดยเรียกใช้การค้นหาด้านล่าง

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-004',
  'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
5;

มาดูรายละเอียดของคำค้นหานี้กัน

ในคำค้นหานี้

  1. ข้อความค้นหาของผู้ใช้คือ "ฉันต้องการเสื้อผู้หญิงสีชมพูแบบลำลองที่เป็นผ้าฝ้ายแท้เท่านั้น"
  2. เราจะแปลงเป็น Embedding ในembedding()โดยใช้โมเดล text-embedding-004 ขั้นตอนนี้ควรจะคุ้นเคยหลังจากขั้นตอนสุดท้าย ซึ่งเราได้ใช้ฟังก์ชันการฝังกับรายการทั้งหมดในตาราง
  3. "<=>" แสดงถึงการใช้วิธีการวัดระยะทางความคล้ายกันของโคไซน์ คุณดูการวัดความคล้ายกันทั้งหมดที่มีได้ในเอกสารประกอบของ pgvector
  4. เราจะแปลงผลลัพธ์ของวิธีการฝังเป็นประเภทเวกเตอร์เพื่อให้เข้ากันได้กับเวกเตอร์ที่จัดเก็บไว้ในฐานข้อมูล
  5. LIMIT 5 หมายความว่าเราต้องการดึงเพื่อนบ้านที่ใกล้ที่สุด 5 รายการสำหรับข้อความค้นหา

ผลลัพธ์จะมีลักษณะดังนี้

4193a68737400535.png

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

หมายเหตุสำคัญ:

สมมติว่าเราต้องการเพิ่มประสิทธิภาพ (เวลาในการค้นหา) ประสิทธิภาพ และการเรียกคืนผลการค้นหาเวกเตอร์นี้โดยใช้ดัชนี ScaNN โปรดอ่านขั้นตอนในบล็อกนี้เพื่อเปรียบเทียบความแตกต่างของผลลัพธ์ที่มีและไม่มีดัชนี เราจะแสดงขั้นตอนการสร้างดัชนีที่นี่เพื่อความสะดวก

  1. เนื่องจากเราได้สร้างคลัสเตอร์ อินสแตนซ์ บริบท และการฝังไว้แล้ว เราจึงเพียงแค่ต้องติดตั้งส่วนขยาย ScaNN โดยใช้คำสั่งต่อไปนี้

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

  1. จากนั้นเราจะสร้างดัชนี (ScaNN) ดังนี้

CREATE INDEX apparel_index ON apparels

USING scann (embedding cosine)

WITH (num_leaves=54);

ใน DDL ด้านบน apparel_index คือชื่อของดัชนี

"apparels" คือตารางของฉัน

"scann" คือวิธีการจัดทำดัชนี

"embedding" คือคอลัมน์ในตารางที่ฉันต้องการจัดทำดัชนี

"โคไซน์" คือวิธีการวัดระยะทางที่ฉันต้องการใช้กับดัชนี

"54" คือจำนวนพาร์ติชันที่จะใช้กับดัชนีนี้ ตั้งค่าเป็นค่าใดก็ได้ระหว่าง 1 ถึง 1048576 ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีตัดสินใจเลือกค่านี้ได้ที่ปรับดัชนี ScaNN

ฉันใช้รากที่สองของจำนวนจุดข้อมูลตามที่แนะนำใน ScaNN repo (เมื่อทำการแบ่งพาร์ติชัน num_leaves ควรเป็นรากที่สองของจำนวนจุดข้อมูลโดยประมาณ)

  1. ตรวจสอบว่ามีการสร้างดัชนีโดยใช้การค้นหาต่อไปนี้หรือไม่

SELECT * FROM pg_stat_ann_indexes;

  1. ทำการค้นหาเวกเตอร์โดยใช้คำค้นหาเดียวกันกับที่เราใช้โดยไม่มีดัชนี

select * from apparels

ORDER BY embedding <=> CAST(embedding('textembedding-gecko', 'white tops for girls without any print') as vector(768))

LIMIT 20

คำค้นหาข้างต้นเป็นคำค้นหาเดียวกันกับที่เราใช้ในห้องทดลองในขั้นตอนที่ 8 แต่ตอนนี้เราได้จัดทำดัชนีฟิลด์แล้ว

  1. ทดสอบด้วยคำค้นหาอย่างง่ายโดยมีและไม่มีดัชนี (โดยการวางดัชนี):

white tops for girls without any print

ข้อความค้นหาข้างต้นในคำค้นหาการค้นหาเวกเตอร์ในข้อมูลการฝังที่จัดทำดัชนีจะส่งผลให้ได้ผลการค้นหาที่มีคุณภาพและมีประสิทธิภาพ ดัชนีช่วยปรับปรุงประสิทธิภาพได้อย่างมาก (ในแง่ของเวลาในการดำเนินการ: 10.37 มิลลิวินาทีหากไม่มี ScaNN และ 0.87 มิลลิวินาทีหากมี ScaNN) ดูข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อนี้ได้ในบล็อกนี้

9. การตรวจสอบความถูกต้องของการจับคู่ด้วย LLM

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

ตรวจสอบว่าตั้งค่าอินสแตนซ์สำหรับ Gemini แล้ว

ก่อนอื่น ให้ตรวจสอบว่าได้เปิดใช้การผสานรวม ML ของ Google สำหรับคลัสเตอร์และอินสแตนซ์แล้วหรือยัง ใน AlloyDB Studio ให้ป้อนคำสั่งต่อไปนี้

show google_ml_integration.enable_model_support;

หากค่าแสดงเป็น "เปิด" คุณสามารถข้าม 2 ขั้นตอนถัดไปและไปที่การตั้งค่าการผสานรวมโมเดล AlloyDB และ Vertex AI ได้โดยตรง

  1. ไปที่อินสแตนซ์หลักของคลัสเตอร์ AlloyDB แล้วคลิกแก้ไขอินสแตนซ์หลัก

456ffdf292d3c0e0.png

  1. ไปที่ส่วนฟีเจอร์ทดลองในตัวเลือกการกำหนดค่าขั้นสูง และตรวจสอบว่าตั้งค่า google_ml_integration.enable_model_support flag เป็น "on" ตามที่แสดงด้านล่าง

6a59351fcd2a9d35.png

หากไม่ได้ตั้งค่าเป็น "เปิด" ให้ตั้งค่าเป็น "เปิด" แล้วคลิกปุ่มอัปเดตอินสแตนซ์ ขั้นตอนนี้จะใช้เวลาสักครู่

การผสานรวมโมเดล AlloyDB และ Vertex AI

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

ก่อนอื่น เราจะสร้างการเชื่อมต่อโมเดล Gemini 1.5 ดังที่แสดงด้านล่าง อย่าลืมแทนที่ $PROJECT_ID ในคำสั่งด้านล่างด้วยรหัสโปรเจ็กต์ Google Cloud ของคุณ

CALL
 google_ml.create_model( model_id => 'gemini-1.5',
   model_request_url => 'https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-1.5-pro:streamGenerateContent',
   model_provider => 'google',
   model_auth_type => 'alloydb_service_agent_iam');

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

select model_id,model_type from google_ml.model_info_view;

สุดท้ายนี้ เราต้องให้สิทธิ์แก่ผู้ใช้ฐานข้อมูลเพื่อเรียกใช้ฟังก์ชัน ml_predict_row เพื่อเรียกใช้การคาดการณ์ผ่านโมเดล Google Vertex AI เรียกใช้คำสั่งต่อไปนี้

GRANT EXECUTE ON FUNCTION ml_predict_row to postgres;

หมายเหตุ: หากคุณใช้โปรเจ็กต์ Google Cloud ที่มีอยู่และคลัสเตอร์/อินสแตนซ์ AlloyDB ที่มีอยู่ซึ่งสร้างขึ้นเมื่อนานมาแล้ว คุณอาจต้องทิ้งการอ้างอิงโมเดล gemini-1.5 แบบเก่าและสร้างใหม่ด้วยคำสั่ง CALL ด้านบน แล้วเรียกใช้ grant execute on function ml_predict_row อีกครั้งในกรณีที่คุณพบปัญหาในการเรียกใช้ gemini-1.5 ในอนาคต

การประเมินคำตอบ

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

  1. ก่อนอื่นเราจะส่งคำขอไปยังฐานข้อมูลเพื่อรับรายการที่ตรงกับคำค้นหาของผู้ใช้มากที่สุด 5 รายการ เราจะฮาร์ดโค้ดการค้นหาเพื่อให้ง่าย แต่ไม่ต้องกังวล เราจะแทรกการค้นหานี้ลงในการค้นหาในภายหลัง เราจะรวมรายละเอียดผลิตภัณฑ์จากตาราง apparels และเพิ่มฟิลด์ใหม่ 2 ฟิลด์ โดยฟิลด์หนึ่งจะรวมรายละเอียดกับดัชนี และอีกฟิลด์หนึ่งจะรวมคำขอเดิม ระบบจะบันทึกข้อมูลทั้งหมดนี้ไว้ในตารางชื่อ xyz (เป็นเพียงชื่อตารางชั่วคราว)
CREATE TABLE
 xyz AS
SELECT
 id || ' - ' || pdt_desc AS literature,
 pdt_desc AS content,
 'I want womens tops, pink casual only pure cotton.' AS  user_text
FROM
 apparels
ORDER BY
 embedding <=> embedding('text-embedding-004',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

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

  • literature
  • content
  • user_text
  1. เราจะใช้การค้นหาที่ซับซ้อนเพื่อพิจารณาว่าคำตอบถูกต้องเพียงใด โดยเราจะอธิบายวิธีประเมินคำตอบ โดยจะใช้ user_text และ content ในตาราง xyz เป็นส่วนหนึ่งของคําค้นหา
"Read this user search text: ', user_text, 
' Compare it against the product inventory data set: ', content, 
' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
  1. เมื่อใช้คำค้นหานั้นแล้ว เราจะตรวจสอบ "คุณภาพ" ของคำตอบในxyzตาราง
CREATE TABLE
  x AS
SELECT
  json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
      request_body => CONCAT('{
 "contents": [ 
        { "role": "user", 
          "parts": 
             [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match." 
             } ]
         } 
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
FROM
    xyz;
  1. predict_row จะแสดงผลลัพธ์ในรูปแบบ JSON โค้ด "-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'" ใช้เพื่อดึงข้อความจริงจาก JSON นั้น หากต้องการดู JSON จริงที่ส่งคืน คุณสามารถนำโค้ดนี้ออกได้
  2. สุดท้าย หากต้องการรับฟิลด์ LLM คุณเพียงแค่ต้องดึงข้อมูลจากตาราง x
SELECT 
LLM_RESPONSE 
FROM 
        x;
  1. ซึ่งสามารถรวมเป็นคำค้นหาถัดไปคำเดียวได้ดังนี้

คุณจะต้องลบตาราง xyz และ x ออกจากฐานข้อมูล AlloyDB ก่อนที่จะเรียกใช้คำสั่งนี้ หากคุณเรียกใช้คำค้นหาข้างต้นเพื่อตรวจสอบผลลัพธ์ระดับกลาง

SELECT
 LLM_RESPONSE
FROM (
 SELECT
 json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
     request_body => CONCAT('{
     "contents": [
       { "role": "user",
         "parts":
            [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
            } ]
        }
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
   FROM (
         SELECT
           id || ' - ' || pdt_desc AS literature,
           pdt_desc AS content,
         'I want womens tops, pink casual only pure cotton.' user_text
         FROM
           apparels
         ORDER BY
             embedding <=> embedding('text-embedding-004',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

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

โปรดทราบว่าโมเดล Gemini จะเปิดการสตรีมไว้โดยค่าเริ่มต้น ดังนั้นคำตอบจริงจะกระจายอยู่หลายบรรทัด 14e74d71293b7b9.png

10. นำแอปพลิเคชันไปใช้บนเว็บ

พร้อมที่จะนำแอปนี้ไปใช้บนเว็บแล้วใช่ไหม ทำตามขั้นตอนด้านล่างเพื่อทำให้ Knowledge Engine เป็นแบบไร้เซิร์ฟเวอร์ด้วยฟังก์ชัน Cloud Run

  1. ไปที่ฟังก์ชัน Cloud Run ใน Google Cloud Console เพื่อสร้างฟังก์ชัน Cloud Run ใหม่ หรือใช้ลิงก์ https://console.cloud.google.com/functions/add
  2. เลือกสภาพแวดล้อมเป็น "ฟังก์ชัน Cloud Run" ระบุชื่อฟังก์ชัน "retail-engine" และเลือกภูมิภาคเป็น "us-central1" ตั้งค่าการตรวจสอบสิทธิ์เป็น "อนุญาตการเรียกใช้ที่ไม่ผ่านการตรวจสอบสิทธิ์" แล้วคลิกถัดไป เลือก Java 17 เป็นรันไทม์และ Inline Editor สำหรับซอร์สโค้ด
  3. โดยค่าเริ่มต้น ระบบจะตั้งค่าจุดแรกเข้าเป็น "gcfv2.HelloHttpFunction" แทนที่โค้ดตัวยึดตำแหน่งใน HelloHttpFunction.java และ pom.xml ของฟังก์ชัน Cloud Run ด้วยโค้ดจากไฟล์ Java และ XML ตามลำดับ
  4. อย่าลืมเปลี่ยนตัวยึดตำแหน่ง $PROJECT_ID และข้อมูลเข้าสู่ระบบการเชื่อมต่อ AlloyDB ด้วยค่าของคุณในไฟล์ Java ข้อมูลเข้าสู่ระบบ AlloyDB คือข้อมูลที่เราใช้ตอนเริ่ม Codelab นี้ หากคุณใช้ค่าอื่น โปรดแก้ไขค่าดังกล่าวในไฟล์ Java
  5. คลิกทำให้ใช้งานได้

เมื่อติดตั้งใช้งานแล้ว เราจะสร้างเครื่องมือเชื่อมต่อ VPC เพื่ออนุญาตให้ Cloud Functions เข้าถึงอินสแตนซ์ฐานข้อมูล AlloyDB

ขั้นตอนสำคัญ:

เมื่อตั้งค่าสำหรับการติดตั้งใช้งานแล้ว คุณควรจะเห็นฟังก์ชันในคอนโซลฟังก์ชันของ Cloud Run ใน Google ค้นหาฟังก์ชันที่สร้างขึ้นใหม่ (retail-engine) คลิกฟังก์ชันนั้น แล้วคลิกแก้ไขและเปลี่ยนข้อมูลต่อไปนี้

  1. ไปที่การตั้งค่ารันไทม์ การสร้าง การเชื่อมต่อ และความปลอดภัย
  2. เพิ่มการหมดเวลาเป็น 180 วินาที
  3. ไปที่แท็บการเชื่อมต่อ

4e83ec8a339cda08.png

  1. ตรวจสอบว่าได้เลือก "อนุญาตการรับส่งข้อมูลทั้งหมด" ในการตั้งค่าขาเข้า
  2. ในส่วนการตั้งค่าขาออก ให้คลิกเมนูแบบเลื่อนลงของเครือข่าย แล้วเลือกตัวเลือก "เพิ่มตัวเชื่อมต่อ VPC ใหม่" จากนั้นทำตามวิธีการที่เห็นในกล่องโต้ตอบที่ปรากฏขึ้น

8126ec78c343f199.png

  1. ระบุชื่อเครื่องมือเชื่อมต่อ VPC และตรวจสอบว่าภูมิภาคตรงกับอินสแตนซ์ ปล่อยให้ค่าเครือข่ายเป็นค่าเริ่มต้น และตั้งค่าเครือข่ายย่อยเป็นช่วง IP ที่กำหนดเองโดยมีช่วง IP เป็น 10.8.0.0 หรือค่าที่คล้ายกันที่ใช้ได้
  2. ขยาย "แสดงการตั้งค่าการปรับขนาด" และตรวจสอบว่าคุณได้ตั้งค่าการกำหนดค่าเป็นดังนี้

7baf980463a86a5c.png

  1. คลิกสร้าง แล้วเครื่องมือเชื่อมต่อนี้ควรแสดงในการตั้งค่าขาออกในตอนนี้
  2. เลือกตัวเชื่อมต่อที่สร้างขึ้นใหม่
  3. เลือกให้กำหนดเส้นทางการรับส่งข้อมูลทั้งหมดผ่านเครื่องมือเชื่อมต่อ VPC นี้
  4. คลิกถัดไป แล้วคลิกติดตั้งใช้งาน

11. ทดสอบแอปพลิเคชัน

เมื่อติดตั้งใช้งาน Cloud Function ที่อัปเดตแล้ว คุณควรเห็นปลายทางในรูปแบบต่อไปนี้

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/retail-engine

คุณสามารถทดสอบได้จากเทอร์มินัล Cloud Shell โดยเรียกใช้คำสั่งต่อไปนี้

gcloud functions call retail-engine --region=us-central1 --gen2 --data '{"search": "I want some kids clothes themed on Disney"}'

หรือคุณจะทดสอบฟังก์ชัน Cloud Run ได้ดังนี้

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://us-central1-$PROJECT_ID.cloudfunctions.net/retail-engine \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

ผลลัพธ์ที่ได้มีดังนี้

88bc1ddfb5644a28.png

เท่านี้ก็เรียบร้อย การค้นหาเวกเตอร์ความคล้ายคลึงโดยใช้โมเดลการฝังในข้อมูล AlloyDB นั้นง่ายดายเพียงเท่านี้

การสร้างเอเจนต์แบบสนทนา

คุณจะได้สร้างเอเจนต์ในส่วนที่ 2 ของ Lab นี้

12. ล้างข้อมูล

หากคุณวางแผนที่จะทำส่วนที่ 2 ของแล็บนี้ให้เสร็จสมบูรณ์ ให้ข้ามขั้นตอนนี้เนื่องจากขั้นตอนนี้จะลบโปรเจ็กต์ปัจจุบัน

โปรดทำตามขั้นตอนต่อไปนี้เพื่อเลี่ยงไม่ให้เกิดการเรียกเก็บเงินกับบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ในโพสต์นี้

  1. ใน Google Cloud Console ให้ไปที่หน้าจัดการทรัพยากร
  2. ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่ต้องการลบ แล้วคลิกลบ
  3. ในกล่องโต้ตอบ ให้พิมพ์รหัสโปรเจ็กต์ แล้วคลิกปิดเพื่อลบโปรเจ็กต์

13. ขอแสดงความยินดี

ยินดีด้วย คุณทำการค้นหาความคล้ายคลึงโดยใช้ AlloyDB, pgvector และการค้นหาเวกเตอร์เรียบร้อยแล้ว การรวมความสามารถของ AlloyDB, Vertex AI และ Vector Search ทำให้เราก้าวกระโดดไปข้างหน้าในการทำให้การค้นหาตามบริบทและการค้นหาแบบเวกเตอร์เข้าถึงได้ มีประสิทธิภาพ และขับเคลื่อนด้วยความหมายอย่างแท้จริง ส่วนถัดไปของแล็บนี้จะครอบคลุมขั้นตอนการสร้างเอเจนต์