สร้างแอปแนะนำชุดแต่งกายที่ทำงานด้วยระบบ AI ด้วย AlloyDB และรันไทม์แบบ Serverless

1. ภาพรวม

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

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

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

โซลูชัน: แอปแนะนำชุดช่วยแก้ปัญหาในการมอบประสบการณ์ด้านแฟชั่นที่ชาญฉลาด ปรับเปลี่ยนในแบบของคุณ และน่าสนใจ พร้อมทั้งแสดงความสามารถของ AlloyDB, Generative AI และเทคโนโลยีแบบ Serverless

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

ในห้องทดลองนี้ คุณจะทำสิ่งต่อไปนี้

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

ข้อกำหนด

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

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

สถาปัตยกรรมระดับสูงของแอปมีดังนี้

ส่วนต่อไปนี้จะเน้นขั้นตอนตามบริบทของบทแนะนำ

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

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

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

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

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

คำแนะนำของ Gemini:

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

RAG และ Vector Search ของ AlloyDB:

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

การสร้างรูปภาพตอบกลับ:

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

การสร้างรูปภาพด้วย Imagen:

ระบบจะรวมพรอมต์การจัดรูปแบบของผู้ใช้ คำแนะนำที่ผู้ใช้เลือก และคำขอการปรับเปลี่ยนในแบบของคุณเพื่อแจ้ง Imagen 3 ด้วยรูปภาพที่มีอยู่ ระบบจะสร้างรูปภาพการจัดแต่งตามพรอมต์นี้โดยใช้ Vertex AI API

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

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

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

gcloud auth list

เรียกใช้คำสั่งต่อไปนี้เพื่อยืนยันว่าคำสั่ง gcloud ในอนาคตจะระบุโปรเจ็กต์ของคุณได้อย่างถูกต้อง

gcloud config list project

หากไม่ได้ตั้งค่าโปรเจ็กต์ ให้ใช้คำสั่งต่อไปนี้เพื่อตั้งค่าอย่างชัดเจน

gcloud config set project <YOUR_PROJECT_ID>

เปิดใช้ API ที่จำเป็น

ทำตามลิงก์เพื่อเปิดใช้ API

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับคำสั่งและการใช้งาน gcloud ได้ที่เอกสารประกอบ

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

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

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

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

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

สร้างคลัสเตอร์และอินสแตนซ์ด้วยค่าต่อไปนี้

รหัสคลัสเตอร์: "shopping-cluster"
รหัสผ่าน: "alloydb"
รองรับ PostgreSQL 15
ภูมิภาค: "us-central1"
การสร้างเครือข่าย: "default"

ในเครือข่าย เมื่อเลือกเครือข่ายเริ่มต้น ตัวเลือกต่อไปนี้จะปรากฏขึ้น คลิกตั้งค่าการเชื่อมต่อเพื่อตั้งค่าเครือข่ายเริ่มต้น
เลือกใช้ช่วง IP ที่มีการจัดสรรโดยอัตโนมัติ แล้วคลิกต่อไป หลังจากตรวจสอบข้อมูลแล้ว ให้คลิกสร้างการเชื่อมต่อ

รอให้การสร้างเครือข่ายเริ่มต้นเสร็จสมบูรณ์

ในส่วนกำหนดค่าอินสแตนซ์หลัก ให้ตั้งค่ารหัสอินสแตนซ์เป็น "shopping-instance"

คลิกสร้างคลัสเตอร์เพื่อตั้งค่าคลัสเตอร์ให้เสร็จสมบูรณ์ดังนี้

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

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

ตรวจสอบสิทธิ์ไปยังฐานข้อมูล AlloyDB

ไปที่ AlloyDB ในคอนโซล Google Cloud เลือกคลัสเตอร์หลัก แล้วคลิก AlloyDB Studio ในการนำทางด้านซ้าย

ป้อนรายละเอียดต่อไปนี้เพื่อตรวจสอบสิทธิ์เข้าถึงฐานข้อมูล AlloyDB

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

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

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

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

ในการสร้างแอปนี้ เราจะใช้ส่วนขยาย "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) );

เมื่อเรียกใช้คำสั่งข้างต้นสำเร็จ คุณจะดูตารางได้ใน

ฐานข้อมูล รูปภาพต่อไปนี้แสดงตัวอย่าง

นำเข้าข้อมูล

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

คัดลอกคำสั่ง 20 บรรทัด/แทรกจากไฟล์ SQL ในแท็บ Editor ใหม่ใน AlloyDB Studio แล้วคลิกRUN

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

คลิกเรียกใช้เพื่อยืนยันว่ามีการแทรกแถว

ให้สิทธิ์แก่ผู้ใช้

เราจะให้สิทธิ์แก่postgresผู้ใช้ในการสร้างการฝังจากภายใน AlloyDB. ใน AlloyDB Studio ให้เรียกใช้คำสั่งต่อไปนี้เพื่อให้สิทธิ์ในการเรียกใช้ฟังก์ชัน embedding แก่ผู้ใช้ postgres

GRANT EXECUTE ON FUNCTION embedding TO postgres;

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

เราจะใช้โมเดลการฝังข้อความจาก Vertex AI เพื่อสร้างการฝังสำหรับบทบาทผู้ใช้ Vertex AI ในบัญชีบริการ AlloyDB

ในคอนโซล Google Cloud ให้คลิกไอคอนเทอร์มินัล 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. บริบทบิวด์

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

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

ในแท็บเอดิเตอร์ของ 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. สร้างการฝังสำหรับบริบท

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

ลองอธิบายสถานที่ริมทะเล โดยอาจเรียกว่า "on the water", "beachfront", "walk from your room to the ocean", "sur la mer", "на берегу океана" เป็นต้น คำเหล่านี้มีลักษณะแตกต่างกัน แต่ความหมายเชิงความหมายหรือในคำศัพท์ของแมชชีนเลิร์นนิง การฝังควรมีความใกล้เคียงกันมาก

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

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

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

ยืนยันว่าระบบสร้างการฝังโดยเรียกใช้คำสั่งต่อไปนี้

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 Apparels
LIMIT 5;

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

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

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

สมมติว่าข้อความค้นหาของผู้ใช้คือ "pink color, casual, pure cotton tops for women"

หากต้องการค้นหารายการที่ตรงกับคำค้นหานี้ ให้เรียกใช้คำค้นหา SQL ต่อไปนี้

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-005',
  'pink color, casual, pure cotton tops for women')::vector
LIMIT
5;

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

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

ข้อความค้นหาของผู้ใช้คือ "I want womens tops, pink casual only pure cotton."
เราจะแปลงข้อความค้นหานี้เป็น Embedding โดยใช้วิธี embedding() ร่วมกับโมเดล text-embedding-005 ขั้นตอนนี้ควรจะคุ้นเคยหลังจากขั้นตอนสุดท้าย ซึ่งเราได้ใช้ฟังก์ชันการฝังกับรายการทั้งหมดในตาราง
"<=>" แสดงถึงการใช้วิธีการวัดระยะทางความคล้ายคลึงของโคไซน์ คุณดูการวัดความคล้ายกันทั้งหมดที่มีได้ในเอกสารประกอบของ pgvector
เราจะแปลงผลลัพธ์ของวิธีการฝังเป็นประเภทข้อมูลเวกเตอร์เพื่อให้เข้ากันได้กับเวกเตอร์ที่จัดเก็บไว้ในฐานข้อมูล
LIMIT 5 หมายความว่าเราต้องการดึงเพื่อนบ้านที่ใกล้ที่สุด 5 รายการสำหรับข้อความค้นหา

ต่อไปนี้คือตัวอย่างการตอบกลับของการค้นหา SQL นี้

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

ดัชนี ScaNN ของ AlloyDB เพื่อประสิทธิภาพการค้นหา

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

หากต้องการใช้ดัชนี ScaNN ให้ลองทำตามขั้นตอนต่อไปนี้

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

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

สร้างดัชนี ScaNN โดยทำดังนี้

CREATE INDEX apparel_index ON apparels
USING scann (embedding cosine)
WITH (num_leaves=54);

ใน DDL ด้านบน

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

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

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

SELECT * FROM pg_stat_ann_indexes;

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

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

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

ทดสอบด้วยคำค้นหาง่ายๆ โดยมีและไม่มีดัชนี หากต้องการทดสอบโดยไม่มีดัชนี คุณต้องทิ้งดัชนี

white tops for girls without any print

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

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

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

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

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

show google_ml_integration.enable_model_support;

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

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

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

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

3. หากไม่ได้ตั้งค่าเป็น "on" ให้ตั้งค่าเป็น "on" แล้วคลิกอัปเดตอินสแตนซ์

ขั้นตอนนี้จะใช้เวลาสักครู่

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

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

ไปที่ AlloyDB ในคอนโซล Google Cloud เลือกคลัสเตอร์หลัก แล้วคลิก AlloyDB Studio ในการนำทางด้านซ้าย
เราจะใช้ gemini-1.5-pro:generateContent ที่พร้อมใช้งานโดยค่าเริ่มต้นกับส่วนขยาย google_ml_integration
คุณตรวจสอบโมเดลที่กำหนดค่าสำหรับการเข้าถึงได้โดยใช้คำสั่งต่อไปนี้ใน 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;

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

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

เราจะดูส่วนต่างๆ ที่ประกอบกันเป็นคำค้นหาที่ใหญ่ขึ้นซึ่งเราใช้ในท้ายที่สุด

ก่อนอื่นเราจะส่งคำขอไปยังฐานข้อมูลเพื่อรับรายการที่ตรงกันมากที่สุด 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-005',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

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

ตารางใหม่ xyz จะมี 5 แถว โดยแต่ละแถวจะมีคอลัมน์ต่อไปนี้

literature
content
user_text

เราจะใช้การค้นหาที่ซับซ้อนเพื่อพิจารณาว่าคำตอบถูกต้องเพียงใด โดยเราจะอธิบายวิธีประเมินคำตอบ โดยจะใช้ 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."

เมื่อใช้คำค้นหานั้นแล้ว เราจะตรวจสอบ "คุณภาพ" ของคำตอบใน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;

predict_row จะแสดงผลลัพธ์ในรูปแบบ JSON โค้ด "-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'" ใช้เพื่อดึงข้อความจริงจาก JSON นั้น หากต้องการดู JSON จริงที่ส่งคืน คุณสามารถนำโค้ดนี้ออกได้
สุดท้าย หากต้องการรับฟิลด์ LLM คุณเพียงแค่ต้องดึงข้อมูลจากตาราง x

SELECT 
LLM_RESPONSE 
FROM 
        x;

ซึ่งสามารถรวมเป็นคำค้นหาเดียวได้ดังนี้

คำเตือน: หากคุณเรียกใช้การค้นหาข้างต้นเพื่อตรวจสอบผลลัพธ์ระดับกลาง

ตรวจสอบว่าคุณลบตาราง 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-005',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

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

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

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

ตอนนี้เราจะโฮสต์แอปพลิเคชันนี้เพื่อให้เข้าถึงได้จากอินเทอร์เน็ต

สร้างฟังก์ชัน Cloud Run

ในคอนโซล Google Cloud ให้ไปที่ฟังก์ชัน Cloud Run โดยใช้ลิงก์ต่อไปนี้

https://console.cloud.google.com/run/create?deploymentType=function

ในส่วนกำหนดค่า ให้ตั้งชื่อฟังก์ชันเป็น "retail-engine" และเลือกภูมิภาคเป็น "us-central1"
ใน URL ปลายทาง ให้เลือกรันไทม์เป็น Java 17
ในการตรวจสอบสิทธิ์ ให้เลือกอนุญาตการเรียกใช้ที่ไม่ผ่านการตรวจสอบสิทธิ์
ขยายคอนเทนเนอร์ ปริมาณข้อมูล เครือข่าย ความปลอดภัย แล้วคลิกแท็บเครือข่าย
เลือกเชื่อมต่อกับ VPC สำหรับการรับส่งข้อมูลขาออก แล้วคลิกใช้เครื่องมือเชื่อมต่อการเข้าถึง VPC แบบ Serverless
ในส่วนเครือข่าย ให้คลิกเพิ่มตัวเชื่อมต่อ VPC ใหม่ เปิดใช้ Serverless VPC Access API หากยังไม่ได้เปิดใช้
ในเครื่องมือเชื่อมต่อที่สร้าง ให้ตั้งชื่อเป็น alloydb-test-conn
ตั้งค่าภูมิภาคเป็น us-central
ปล่อยค่าเครือข่ายเป็นค่าเริ่มต้น และตั้งค่าเครือข่ายย่อยเป็นช่วง IP ที่กำหนดเองโดยมีช่วง IP เป็น 10.8.0.0 หรือค่าที่คล้ายกันซึ่งพร้อมใช้งาน
ขยายการตั้งค่าแสดงการปรับขนาด แล้วตั้งค่าอินสแตนซ์ขั้นต่ำเป็น 2 และอินสแตนซ์สูงสุดเป็น 3
เลือกประเภทอินสแตนซ์เป็น f1-micro ตัวเลือกสร้างตัวเชื่อมต่อมีดังนี้

คลิกสร้างเพื่อสร้างตัวเชื่อมต่อ
ในการกำหนดเส้นทางการรับส่งข้อมูล ให้เลือกกำหนดเส้นทางการรับส่งข้อมูลทั้งหมดไปยัง VPC
คลิกสร้างเพื่อสร้างฟังก์ชัน

ทำให้แอปพลิเคชันใช้งานได้

หลังจากสร้างฟังก์ชันแล้ว ให้อัปเดตแหล่งที่มาและติดตั้งแอปพลิเคชันอีกครั้ง

ใน Cloud Run ให้คลิกแท็บบริการ แล้วคลิกฟังก์ชัน retail-engine
คลิกแท็บแหล่งที่มา ปล่อยให้จุดแรกเข้าของฟังก์ชันเริ่มต้นตั้งค่าเป็น "gcfv2.HelloHttpFunction"
แทนที่เนื้อหาของไฟล์ HelloHttpFunction.java ด้วยเนื้อหาจากไฟล์ Java นี้
อัปเดตรายละเอียด AlloyDbJdbcConnector ในไฟล์ตามรายละเอียดของอินสแตนซ์และคลัสเตอร์ AlloyDB แทนที่ $PROJECT_ID ด้วยรหัสโปรเจ็กต์ของคลัสเตอร์และอินสแตนซ์ AlloyDB

แทนที่เนื้อหาของไฟล์ pom.xml ด้วยเนื้อหาของไฟล์ XML นี้
คลิกบันทึกและติดตั้งใช้งานอีกครั้งเพื่อติดตั้งใช้งานฟังก์ชัน

11. ทดสอบแอปพลิเคชันเครื่องมือค้าปลีก

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

https://retail-engine-PROJECT_NUMBER.us-central1.run.app

คุณสามารถทดสอบได้จากเทอร์มินัล 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://retail-engine-$PROJECT_NUMBER.us-central1.run.app \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

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

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

12. ทำความเข้าใจขั้นตอนการแนะนำชุด

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

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

หากต้องการเริ่มสร้างแอปแนะนำชุด ให้ทำตามขั้นตอนต่อไปนี้

ใน Cloud Run ให้เปิดแอป retail-engine แล้วจด URL ของแอปพลิเคชัน นี่คือที่เก็บการฝังที่เราจะใช้เพื่อสร้างคำแนะนำที่คล้ายกัน
ใน IDE ให้โคลนที่เก็บ https://github.com/AbiramiSukumaran/outfit-recommender/ สำหรับการฝึกหัดนี้ ขั้นตอนที่แสดงจะดำเนินการใน Visual Studio Code IDE

git clone https://github.com/AbiramiSukumaran/outfit-recommender/

ไฟล์สำคัญบางส่วนในไดเรกทอรีของแอปมีดังนี้

src/main: ไดเรกทอรีต้นทางที่มีไฟล์แอปพลิเคชันและ HTML อยู่
HelloWorldApplication.java: จุดแรกเข้าหลักสำหรับแอปพลิเคชัน Spring Boot
HelloWorldController.java: คอนโทรลเลอร์ REST ของ Spring Boot ที่จัดการคำขอ HTTP ที่เกี่ยวข้องกับแอปพลิเคชันระบบแนะนำชุด ไฟล์นี้จะจัดการคำขอ GET และ POST ประมวลผลพรอมต์ของผู้ใช้ วิเคราะห์รูปภาพ โต้ตอบกับการฝัง AlloyDB และแสดงผลลัพธ์สุดท้ายไปยัง UI ตัวควบคุมนี้เรียกใช้คลาส GenerateImageSample
GenerateImageSample.java: มีคลาสการสร้างรูปภาพที่เชื่อมต่อกับ Vertex AI จัดรูปแบบพรอมต์ของผู้ใช้ ทำการเรียก API ไปยังโมเดล Imagen และส่งคืนรูปภาพที่คาดการณ์ไปยังคลาสคอนโทรลเลอร์
Resources: ไดเรกทอรีนี้มีรูปภาพและไฟล์ HTML ที่จำเป็นต่อการสร้าง UI ของแอปพลิเคชัน
Pom.xml: กำหนดทรัพยากร Dependency และการกำหนดค่าของโปรเจ็กต์

ใน Visual Studio Code ให้เปิด HelloWorldController.java และอัปเดตอินสแตนซ์ของรหัสโปรเจ็กต์และตำแหน่งตามที่สร้างอินสแตนซ์ AlloyDB

อัปเดต endpoint เป็น URL ของแอปเครื่องมือค้าปลีกที่คุณโฮสต์ไว้ก่อนหน้านี้

เปิด GenerateImageSample.java แล้วอัปเดตรหัสโปรเจ็กต์และตำแหน่งตามที่สร้างอินสแตนซ์ AlloyDB

บันทึกไฟล์ทั้งหมด

ตอนนี้เราจะทำให้ใช้งานได้แอปพลิเคชันนี้ในรันไทม์แบบ Serverless ของ Cloud Run

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

ตอนนี้เราได้เพิ่มรายละเอียดโปรเจ็กต์ สถานที่ตั้ง และรายละเอียดแอปเครื่องมือค้าปลีกที่เกี่ยวข้องลงในแอปพลิเคชัน Spring Boot ของเครื่องมือแนะนำชุดแล้ว เราจึงสามารถทำให้ใช้งานได้แอปพลิเคชันไปยัง Cloud Run ได้

เราจะใช้คำสั่ง gcloud run deploy ในเทอร์มินัล Visual Code Studio เพื่อติดตั้งใช้งานแอปพลิเคชัน สำหรับ Visual Studio Code คุณสามารถติดตั้งส่วนขยาย Google Cloud Code เพื่อเริ่มใช้ gcloud CLI ได้

หากต้องการติดตั้งใช้งานแอปพลิเคชัน ให้ทำตามขั้นตอนต่อไปนี้

เปิดไดเรกทอรีที่โคลนแล้วใน IDE และเริ่มเทอร์มินัล สำหรับ Visual Code Studio ให้คลิก Terminal > New Terminal
ทำตามวิธีการในเอกสารนี้เพื่อติดตั้ง gcloud CLI
หากใช้ Visual Code Studio ให้คลิกส่วนขยาย ค้นหา Google Cloud Code แล้วติดตั้งส่วนขยาย
ในเทอร์มินัล IDE ให้ตรวจสอบสิทธิ์บัญชี Google โดยเรียกใช้คำสั่งต่อไปนี้

gcloud auth application-default login

ตั้งค่ารหัสโปรเจ็กต์เป็นโปรเจ็กต์เดียวกับที่อินสแตนซ์ AlloyDB อยู่

gcloud config set project PROJECT_ID

เริ่มกระบวนการทำให้ใช้งานได้

gcloud run deploy

ใน Source code location ให้กด Enter เพื่อเลือกไดเรกทอรี GitHub ที่โคลน
ใน Service name ให้ป้อนชื่อบริการ เช่น outfit-recommender แล้วกด Enter
ใน Please specify a region ให้ป้อนตำแหน่งที่โฮสต์อินสแตนซ์ AlloyDB และแอปพลิเคชัน retail-engine เช่น 32 สำหรับ us-central1 แล้วกด Enter

ใน Allow unauthenticated invocations to [..] ให้ป้อน Y แล้วกด Enter

รูปภาพต่อไปนี้แสดงความคืบหน้าในการติดตั้งใช้งานแอปพลิเคชัน

14. ทดสอบแอปพลิเคชันเครื่องมือแนะนำชุด

หลังจากทำให้แอปพลิเคชันใช้งานได้ใน Cloud Run เรียบร้อยแล้ว คุณจะเห็นบริการในคอนโซล Google Cloud ดังนี้

ไปที่ Cloud Run ในคอนโซล Google Cloud
ในบริการ ให้คลิกบริการเครื่องมือแนะนำชุดที่คุณติดตั้งใช้งาน คุณควรเห็นทั้งบริการ retail-engine และ outfit-recommender ดังนี้

คลิก URL ของแอปพลิเคชันเพื่อเปิด UI ของแอปแนะนำ

    The following is a sample URL that you will use:

https://outfit-recommender-22905290964.us-central1.run.app/style

คุณจะเห็นแอปพลิเคชันที่ติดตั้งใช้งานดังนี้

การใช้แอปพลิเคชัน

หากต้องการเริ่มใช้แอปพลิเคชัน ให้ทำตามขั้นตอนต่อไปนี้

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

แอปจะสร้างคำแนะนำรูปภาพพร้อมพรอมต์โดยอิงตามรูปภาพที่มีคำแนะนำการจัดรูปแบบ ตัวอย่างเช่น A white semi-sheer button up blouse with pink floral patterns on it, with balloon sleeves.

คุณส่งพรอมต์เพิ่มเติมไปยังคำแนะนำสไตล์ที่สร้างขึ้นโดยอัตโนมัตินี้ได้ ตัวอย่างเช่น STYLE RECOMMENDATION: Cute brown skirt on a curly updo. Make it photo realistic. Accessorize with cherry earrings and burgundy plastic case sling bag.
คลิกแสดงเพื่อดูสไตล์สุดท้าย

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

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

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

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

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