Codelab - สร้างแชทบ็อตแนะนำภาพยนตร์โดยใช้ Neo4j และ Vertex AI

1. ภาพรวม

ในโค้ดแล็บนี้ คุณจะได้สร้างแชทบ็อตแนะนำภาพยนตร์อัจฉริยะโดยใช้ Neo4j, Vertex AI และ Gemini แชทบ็อตใช้กราฟความรู้ Neo4j เป็นรากฐานในการนำเสนอภาพยนตร์ นักแสดง ผู้กำกับ ผู้สร้าง ประเภท ฯลฯ หากต้องการปรับปรุงประสบการณ์การค้นหา คุณจะต้องสร้างการฝังเวกเตอร์จากภาพรวมของพล็อตภาพยนตร์โดยใช้โมเดล text-embedding-004 ของ Vertex AI

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

คุณจะทําตามขั้นตอนทีละขั้นตอนผ่าน Codelab ดังนี้

  1. สร้างกราฟความรู้ Neo4j ด้วยข้อมูลที่เกี่ยวข้องกับภาพยนตร์
  2. เพิ่มประสิทธิภาพข้อมูลภาพยนตร์ด้วยการสร้างการฝังข้อความในภาพรวม/พล็อตของภาพยนตร์โดยใช้การฝังข้อความของ Vertex AI
  3. สร้างอินเทอร์เฟซแชทบ็อต Gradio ที่ทำงานด้วย Gemini สำหรับการค้นหาเชิงความหมายและการดึงข้อมูลจาก Neo4j ซึ่งรวบรวมทุกอย่างเข้าด้วยกัน
  4. หรือจะติดตั้งใช้งานใน Google Cloud Run เป็นเว็บแอปพลิเคชันแบบสแตนด์อโลนก็ได้ ดังที่แสดงด้านล่าง

สิ่งที่คุณจะได้เรียนรู้

  • วิธีสร้างกราฟความรู้เกี่ยวกับภาพยนตร์โดยใช้ Cypher และ Neo4j
  • วิธีใช้ Vertex AI เพื่อสร้างการฝังเชิงความหมายสําหรับข้อความ
  • วิธีผสานรวม Neo4j กับ Gemini เพื่อการดึงข้อมูลที่อัจฉริยะโดยอิงตามเวกเตอร์
  • วิธีสร้างและเรียกใช้ UI ของแชทบ็อตแบบสนทนาด้วย Gradio

สิ่งที่ต้องมี

  • เว็บเบราว์เซอร์ Chrome
  • บัญชี Gmail
  • โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน
  • บัญชี Neo4j Aura DB ฟรี
  • มีความคุ้นเคยพื้นฐานกับคำสั่งในเทอร์มินัลและ Python

Codelab นี้ออกแบบมาสำหรับนักพัฒนาซอฟต์แวร์ทุกระดับ (รวมถึงผู้เริ่มต้น) โดยใช้ Python และ Neo4j ในแอปพลิเคชันตัวอย่าง แม้ว่าการทําความคุ้นเคยเบื้องต้นกับ Python และฐานข้อมูลกราฟจะมีประโยชน์ แต่คุณก็ไม่จำเป็นต้องมีประสบการณ์มาก่อนเพื่อทําความเข้าใจแนวคิดหรือทําตาม 121747afa89e0e6.png

2. ตั้งค่า Neo4j AuraDB

Neo4j เป็นฐานข้อมูลกราฟเนทีฟชั้นนําที่เก็บข้อมูลเป็นเครือข่ายโหนด (เอนทิตี) และความสัมพันธ์ (การเชื่อมต่อระหว่างเอนทิตี) จึงเหมาะสําหรับกรณีการใช้งานที่การทําความเข้าใจการเชื่อมต่อเป็นกุญแจสําคัญ เช่น คําแนะนํา การตรวจจับการประพฤติมิชอบ กราฟความรู้ และอื่นๆ โมเดลกราฟที่ยืดหยุ่นของ Neo4j ช่วยให้แสดงข้อมูลที่ซับซ้อนและเชื่อมโยงกันได้อย่างมีประสิทธิภาพและใช้งานง่าย ซึ่งแตกต่างจากฐานข้อมูลที่สัมพันธ์กันหรือฐานข้อมูลที่อิงตามเอกสารซึ่งใช้ตารางแบบตายตัวหรือโครงสร้างตามลําดับชั้น

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

เช่น ในชุดข้อมูลภาพยนตร์

  • โหนดอาจแสดงถึง Movie, Actor หรือ Director
  • ความสัมพันธ์อาจเป็น ACTED_IN หรือ DIRECTED

โครงสร้างนี้ช่วยให้คุณถามคําถามต่างๆ ได้อย่างง่ายดาย เช่น

  • นักแสดงรายนี้แสดงในภาพยนตร์เรื่องใดบ้าง
  • ใครเคยร่วมงานกับคริสโตเฟอร์ โนแลนบ้าง
  • ภาพยนตร์ที่คล้ายกันตามนักแสดงหรือประเภทที่แชร์กันคืออะไร

Neo4j มาพร้อมกับภาษาการค้นหาที่มีประสิทธิภาพที่เรียกว่า Cypher ซึ่งออกแบบมาเพื่อการค้นหากราฟโดยเฉพาะ Cypher ช่วยให้คุณแสดงรูปแบบและการเชื่อมต่อที่ซับซ้อนในลักษณะที่กระชับและอ่านง่าย

Neo4j มีตัวเลือกต่างๆ ในการติดตั้งใช้งานตามความต้องการของคุณ ดังนี้

  • จัดการด้วยตนเอง: เรียกใช้ Neo4j ในโครงสร้างพื้นฐานของคุณเองโดยใช้ Neo4j Desktop หรือเป็นอิมเมจ Docker (ในองค์กรหรือในระบบคลาวด์ของคุณเอง) 397a3c535b52d3f6.png
  • ระบบคลาวด์ที่จัดการ: ติดตั้งใช้งาน Neo4j ในผู้ให้บริการระบบคลาวด์ยอดนิยมโดยใช้ข้อเสนอใน Marketplace
  • มีการจัดการครบวงจร: ใช้ Neo4j AuraDB ซึ่งเป็นบริการฐานข้อมูลระบบคลาวด์แบบครบวงจรของ Neo4j ซึ่งจัดการการจัดสรร การขยายขนาด การสำรองข้อมูล และการรักษาความปลอดภัยให้คุณ

ใน Codelab นี้ เราจะใช้ Neo4j AuraDB Free ซึ่งเป็นรุ่นที่ไม่มีค่าใช้จ่ายของ AuraDB ซึ่งให้บริการอินสแตนซ์ฐานข้อมูลกราฟที่มีการจัดการอย่างเต็มรูปแบบพร้อมพื้นที่เก็บข้อมูลและฟีเจอร์เพียงพอสำหรับการสร้างต้นแบบ การเรียนรู้ และการสร้างแอปพลิเคชันขนาดเล็ก ซึ่งเหมาะอย่างยิ่งสำหรับเป้าหมายของเราในการสร้างแชทบ็อตแนะนำภาพยนตร์ที่ทำงานด้วย GenAI

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

เหตุผลที่ควรใช้กราฟ

ในฐานข้อมูลเชิงสัมพันธ์แบบดั้งเดิม การตอบคําถามอย่าง"ภาพยนตร์เรื่องใดที่คล้ายกับ Inception โดยอิงตามนักแสดงหรือประเภทที่แชร์กัน" จะเกี่ยวข้องกับการดำเนินการ JOIN ที่ซับซ้อนในหลายตาราง ยิ่งความสัมพันธ์มีความซับซ้อนมากขึ้น ประสิทธิภาพและการอ่านก็ยิ่งแย่ลง

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

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

การสร้าง Neo4j AuraDB แบบไม่มีค่าใช้จ่าย

  1. ไปที่ https://console.neo4j.io
  2. ลงชื่อเข้าใช้ด้วยบัญชี Google หรืออีเมล
  3. คลิก "สร้างอินสแตนซ์แบบไม่มีค่าใช้จ่าย"
  4. ขณะจัดสรรอินสแตนซ์ หน้าต่างป๊อปอัปจะปรากฏขึ้นเพื่อแสดงข้อมูลเข้าสู่ระบบสำหรับการเชื่อมต่อฐานข้อมูล

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

NEO4J_URI=neo4j+s://<your-instance-id>.databases.neo4j.io
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=<your-generated-password>
AURA_INSTANCEID=<your-instance-id>
AURA_INSTANCENAME=<your-instance-name>

คุณจะใช้ค่าเหล่านี้เพื่อกำหนดค่าไฟล์ .env ในโปรเจ็กต์เพื่อตรวจสอบสิทธิ์กับ Neo4j ในขั้นตอนถัดไป

a1e29e56e6c412fc.png

Neo4j AuraDB Free เหมาะสําหรับการพัฒนา การทดสอบ และแอปพลิเคชันขนาดเล็ก เช่น Codelab นี้ แพ็กเกจนี้มีข้อจำกัดด้านการใช้งานที่กว้างขวาง โดยรองรับโหนด 200,000 รายการและความสัมพันธ์ 400,000 รายการ แม้ว่าจะมีฟีเจอร์ที่จำเป็นทั้งหมดในการสร้างและค้นหากราฟความรู้ แต่ก็ไม่รองรับการกำหนดค่าขั้นสูง เช่น ปลั๊กอินที่กำหนดเองหรือพื้นที่เก็บข้อมูลที่เพิ่มขึ้น สำหรับเวิร์กโหลดเวอร์ชันที่ใช้งานจริงหรือชุดข้อมูลขนาดใหญ่ คุณสามารถอัปเกรดเป็นแพ็กเกจ AuraDB ระดับที่สูงขึ้นซึ่งมีพื้นที่เก็บข้อมูล ประสิทธิภาพ และฟีเจอร์ระดับองค์กรที่มากขึ้น

ในส่วนการตั้งค่าแบ็กเอนด์ Neo4j AuraDB เสร็จสมบูรณ์แล้ว ในขั้นตอนถัดไป เราจะสร้างโปรเจ็กต์ Google Cloud, โคลนที่เก็บ และกำหนดค่าตัวแปรสภาพแวดล้อมที่จำเป็นเพื่อเตรียมสภาพแวดล้อมการพัฒนาให้พร้อมก่อนเริ่มใช้งาน Codelab

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 cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com \
                       aiplatform.googleapis.com

เมื่อเรียกใช้คําสั่งสําเร็จ คุณควรเห็นข้อความที่คล้ายกับข้อความที่แสดงด้านล่าง

Operation "operations/..." finished successfully.

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

หากมี API ใดขาดหายไป คุณสามารถเปิดใช้งานได้ทุกเมื่อในระหว่างการติดตั้งใช้งาน

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

โคลนที่เก็บและตั้งค่าสภาพแวดล้อม

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

git clone https://github.com/sidagarwal04/neo4j-vertexai-codelab.git

หากต้องการเปิดเครื่องมือแก้ไข ให้คลิกเปิดเครื่องมือแก้ไขในแถบเครื่องมือของหน้าต่าง Cloud Shell คลิกแถบเมนูที่มุมซ้ายบน แล้วเลือก "ไฟล์" → "เปิดโฟลเดอร์" ดังที่แสดงด้านล่าง

66221fd0d0e5202f.png

เลือกโฟลเดอร์ neo4j-vertexai-codelab แล้วคุณจะเห็นโฟลเดอร์เปิดขึ้นพร้อมไฟล์ต่อไปนี้ดังที่แสดงด้านล่าง

e49542efd70de22e.png

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

NEO4J_URI=
NEO4J_USER=
NEO4J_PASSWORD=
NEO4J_DATABASE=
PROJECT_ID=
LOCATION=

ตอนนี้ให้สร้างไฟล์ใหม่ชื่อ .env ในโฟลเดอร์เดียวกับไฟล์ example.env แล้วคัดลอกเนื้อหาของไฟล์ example.env ที่มีอยู่ จากนั้นอัปเดตตัวแปรต่อไปนี้

  • NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD และ NEO4J_DATABASE
  • กรอกค่าเหล่านี้โดยใช้ข้อมูลเข้าสู่ระบบที่ระบุไว้ในระหว่างการสร้างอินสแตนซ์ Neo4j AuraDB ฟรีในขั้นตอนก่อนหน้า
  • โดยทั่วไป NEO4J_DATABASE จะตั้งค่าเป็น neo4j สำหรับ AuraDB ฟรี
  • PROJECT_ID และ LOCATION
  • หากเรียกใช้โค้ดแล็บจาก Google Cloud Shell คุณสามารถเว้นช่องเหล่านี้ว่างไว้ได้ เนื่องจากระบบจะอนุมานค่าจากการกำหนดค่าโปรเจ็กต์ที่ใช้งานอยู่โดยอัตโนมัติ
  • หากคุณเรียกใช้เครื่องในเครื่องหรือนอก Cloud Shell ให้อัปเดต PROJECT_ID ด้วยรหัสของโปรเจ็กต์ Google Cloud ที่คุณสร้างไว้ก่อนหน้านี้ และตั้งค่า LOCATION เป็นภูมิภาคที่คุณเลือกสำหรับโปรเจ็กต์นั้น (เช่น us-central1)

เมื่อกรอกค่าเหล่านี้แล้ว ให้บันทึกไฟล์ .env การกําหนดค่านี้จะช่วยให้แอปพลิเคชันเชื่อมต่อกับทั้งบริการ Neo4j และ Vertex AI ได้

ขั้นตอนสุดท้ายในการตั้งค่าสภาพแวดล้อมการพัฒนาซอฟต์แวร์คือการสร้างสภาพแวดล้อมเสมือนของ Python และติดตั้งข้อกำหนดที่จำเป็นทั้งหมดที่ระบุไว้ในไฟล์ requirements.txt ไลบรารีเหล่านี้รวมถึงไลบรารีที่จําเป็นสําหรับทํางานร่วมกับ Neo4j, Vertex AI, Gradio และอื่นๆ

ก่อนอื่น ให้สร้างสภาพแวดล้อมเสมือนชื่อ .venv โดยเรียกใช้คําสั่งต่อไปนี้

python -m venv .venv

เมื่อสร้างสภาพแวดล้อมแล้ว เราจะต้องเปิดใช้งานสภาพแวดล้อมที่สร้างขึ้นด้วยคําสั่งต่อไปนี้

source .venv/bin/activate

ตอนนี้คุณควรเห็น (.venv) ที่จุดเริ่มต้นของพรอมต์เทอร์มินัล ซึ่งบ่งบอกว่าสภาพแวดล้อมทำงานอยู่ เช่น (.venv) yourusername@cloudshell:

จากนั้นติดตั้งการอ้างอิงที่จำเป็นโดยเรียกใช้คำสั่งต่อไปนี้

pip install -r requirements.txt

ภาพรวมของข้อกําหนดเบื้องต้นที่สําคัญที่แสดงในไฟล์มีดังนี้

gradio>=4.0.0
neo4j>=5.0.0
numpy>=1.20.0
python-dotenv>=1.0.0
google-cloud-aiplatform>=1.30.0
vertexai>=0.0.1

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

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

4. เตรียมชุดข้อมูลภาพยนตร์

งานแรกของเราคือเตรียมชุดข้อมูลภาพยนตร์ที่จะใช้สร้างกราฟความรู้และขับเคลื่อนแชทบอทแนะนำ เราจะใช้ชุดข้อมูลแบบเปิดที่มีอยู่และต่อยอดจากชุดข้อมูลนั้นแทนที่จะเริ่มต้นจากศูนย์

เราใช้ The Movies Dataset โดย Rounak Banik ซึ่งเป็นชุดข้อมูลสาธารณะที่รู้จักกันดีใน Kaggle ซึ่งรวมถึงข้อมูลเมตาของภาพยนตร์กว่า 45,000 เรื่องจาก TMDB ซึ่งรวมถึงนักแสดง ทีมงาน คีย์เวิร์ด การจัดประเภท และอื่นๆ

9e3a1dc4c286af1b.png

หากต้องการสร้างแชทบ็อตแนะนำภาพยนตร์ที่เชื่อถือได้และมีประสิทธิภาพ คุณจะต้องเริ่มต้นด้วย Structured Data ที่สะอาด สม่ำเสมอ และถูกต้อง แม้ว่าชุดข้อมูลภาพยนตร์จาก Kaggle จะเป็นแหล่งข้อมูลที่อุดมสมบูรณ์ซึ่งมีระเบียนภาพยนตร์มากกว่า 45,000 รายการและข้อมูลเมตาโดยละเอียด ซึ่งรวมถึงประเภท นักแสดง ทีมงาน และอื่นๆ แต่ก็มีข้อมูลที่ไม่เกี่ยวข้อง ความไม่สอดคล้อง และโครงสร้างข้อมูลที่ซ้อนกันซึ่งไม่เหมาะสําหรับการสร้างโมเดลกราฟหรือการฝังข้อมูลเชิงความหมาย

ในการแก้ปัญหานี้ เราได้เตรียมข้อมูลและทำให้ชุดข้อมูลเป็นมาตรฐานเพื่อให้เหมาะกับการสร้างกราฟความรู้ Neo4j และสร้างการฝังคุณภาพสูง กระบวนการนี้เกี่ยวข้องกับสิ่งต่อไปนี้

  • การนำรายการที่ซ้ำกันและระเบียนที่ไม่สมบูรณ์ออก
  • การใช้ฟิลด์คีย์ที่เป็นมาตรฐาน (เช่น ชื่อประเภท ชื่อบุคคล)
  • การแปลงโครงสร้างที่ซับซ้อนซึ่งซ้อนกัน (เช่น นักแสดงและทีมงาน) เป็น CSV ที่มีโครงสร้าง
  • การเลือกชุดย่อยที่เป็นตัวแทนของภาพยนตร์ประมาณ 12,000 เรื่องเพื่อให้อยู่ภายในขีดจำกัดของ Neo4j AuraDB แบบไม่มีค่าใช้จ่าย

ข้อมูลที่แปลงเป็นมาตรฐานและมีคุณภาพสูงจะช่วยให้มั่นใจได้ว่า

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

คุณสามารถเข้าถึงชุดข้อมูลที่ล้างและทำให้เป็นไปตามมาตรฐานได้ในโฟลเดอร์ normalized_data/ ของที่เก็บ GitHub นี้ ชุดข้อมูลนี้ยังได้รับการมิเรอร์ไว้ในที่เก็บข้อมูล Google Cloud Storage เพื่อให้เข้าถึงสคริปต์ Python ที่กำลังจะเผยแพร่ได้ง่ายๆ

เมื่อล้างข้อมูลและเตรียมข้อมูลเรียบร้อยแล้ว เราก็พร้อมที่จะโหลดข้อมูลไปยัง Neo4j และเริ่มสร้างกราฟความรู้เกี่ยวกับภาพยนตร์

5. สร้างกราฟความรู้ภาพยนตร์

เราต้องจัดโครงสร้างชุดข้อมูลภาพยนตร์ในลักษณะที่เก็บเครือข่ายการเชื่อมต่อที่สมบูรณ์ระหว่างภาพยนตร์ นักแสดง ผู้กำกับ ประเภท และข้อมูลเมตาอื่นๆ เพื่อขับเคลื่อนแชทบอทแนะนำภาพยนตร์ที่เปิดใช้ GenAI ในส่วนนี้ เราจะสร้าง Movies Knowledge Graph ใน Neo4j โดยใช้ชุดข้อมูลที่ล้างและทำให้ถูกต้องซึ่งคุณเตรียมไว้ก่อนหน้านี้

เราจะใช้ความสามารถ LOAD CSV ของ Neo4j เพื่อนำเข้าไฟล์ CSV ที่โฮสต์ในที่เก็บข้อมูล Google Cloud Storage (GCS) สาธารณะ ไฟล์เหล่านี้แสดงถึงองค์ประกอบต่างๆ ของชุดข้อมูลภาพยนตร์ เช่น ภาพยนตร์ ประเภท นักแสดง ทีมงาน บริษัทผู้ผลิต และคะแนนของผู้ใช้

ขั้นตอนที่ 1: สร้างข้อจำกัดและดัชนี

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

CREATE CONSTRAINT unique_tmdb_id IF NOT EXISTS FOR (m:Movie) REQUIRE m.tmdbId IS UNIQUE;
CREATE CONSTRAINT unique_movie_id IF NOT EXISTS FOR (m:Movie) REQUIRE m.movieId IS UNIQUE;
CREATE CONSTRAINT unique_prod_id IF NOT EXISTS FOR (p:ProductionCompany) REQUIRE p.company_id IS UNIQUE;
CREATE CONSTRAINT unique_genre_id IF NOT EXISTS FOR (g:Genre) REQUIRE g.genre_id IS UNIQUE;
CREATE CONSTRAINT unique_lang_id IF NOT EXISTS FOR (l:SpokenLanguage) REQUIRE l.language_code IS UNIQUE;
CREATE CONSTRAINT unique_country_id IF NOT EXISTS FOR (c:Country) REQUIRE c.country_code IS UNIQUE;

CREATE INDEX actor_id IF NOT EXISTS FOR (p:Person) ON (p.actor_id);
CREATE INDEX crew_id IF NOT EXISTS FOR (p:Person) ON (p.crew_id);
CREATE INDEX movieId IF NOT EXISTS FOR (m:Movie) ON (m.movieId);
CREATE INDEX user_id IF NOT EXISTS FOR (p:Person) ON (p.user_id);

ขั้นตอนที่ 2: นําเข้าข้อมูลเมตาและความสัมพันธ์ของภาพยนตร์

มาดูวิธีที่เรานําเข้าข้อมูลเมตาของภาพยนตร์โดยใช้คําสั่ง LOAD CSV ตัวอย่างนี้จะสร้างโหนดภาพยนตร์ที่มีแอตทริบิวต์หลัก เช่น ชื่อ ภาพรวม ภาษา และรันไทม์

LOAD CSV WITH HEADERS FROM "https://storage.googleapis.com/neo4j-vertexai-codelab/normalized_movies.csv" AS row
WITH row, toInteger(row.tmdbId) AS tmdbId
WHERE tmdbId IS NOT NULL
WITH row, tmdbId
LIMIT 12000
MERGE (m:Movie {tmdbId: tmdbId})
ON CREATE SET m.title = coalesce(row.title, "None"),
              m.original_title = coalesce(row.original_title, "None"),
              m.adult = CASE 
                            WHEN toInteger(row.adult) = 1 THEN 'Yes' 
                            ELSE 'No' 
                        END,
              m.budget = toInteger(coalesce(row.budget, 0)),
              m.original_language = coalesce(row.original_language, "None"),
              m.revenue = toInteger(coalesce(row.revenue, 0)),
              m.tagline = coalesce(row.tagline, "None"),
              m.overview = coalesce(row.overview, "None"),
              m.release_date = coalesce(row.release_date, "None"),
              m.runtime = toFloat(coalesce(row.runtime, 0)),
              m.belongs_to_collection = coalesce(row.belongs_to_collection, "None");

คุณสามารถใช้คำสั่ง Cypher ที่คล้ายกันเพื่อนำเข้าเอนทิตีที่เกี่ยวข้อง เช่น ประเภท บริษัทโปรดักชัน ภาษา ประเทศ นักแสดง ทีมงาน และการจัดประเภท

โหลดกราฟแบบเต็มผ่าน Python

เราขอแนะนำให้ใช้สคริปต์ Python แบบอัตโนมัติที่มีให้ในโค้ดแล็บนี้แทนการเรียกใช้การค้นหา Cypher หลายรายการด้วยตนเอง

สคริปต์ graph_build.py จะโหลดชุดข้อมูลทั้งหมดจาก GCS ลงในอินสแตนซ์ Neo4j AuraDB โดยใช้ข้อมูลเข้าสู่ระบบในไฟล์ .env

python graph_build.py

สคริปต์จะโหลดไฟล์ CSV ที่จำเป็นทั้งหมดตามลำดับ สร้างโหนดและความสัมพันธ์ ตลอดจนจัดโครงสร้างกราฟความรู้ที่สมบูรณ์เกี่ยวกับภาพยนตร์

ตรวจสอบความถูกต้องของกราฟ

หลังจากโหลดแล้ว คุณสามารถตรวจสอบกราฟได้โดยเรียกใช้การค้นหา Cypher แบบง่าย เช่น

MATCH (m:Movie) RETURN m LIMIT 5;
MATCH (a:Actor)-[:ACTED_IN]->(m:Movie) RETURN a.name, m.title LIMIT 5;

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

6. สร้างและโหลดการฝังเพื่อทำการค้นหาความคล้ายคลึงของเวกเตอร์

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

⚠️ หมายเหตุเกี่ยวกับประสิทธิภาพ

การสร้างการฝังสำหรับคำอธิบายภาพยนตร์หลายพันรายการแบบเรียลไทม์นั้นทั้งใช้เวลาและทรัพยากรมาก เราได้คํานวณการฝังข้อมูลคร่าวๆ ของภาพยนตร์ทั้งหมดประมาณ 12,000 เรื่องไว้ล่วงหน้าโดยใช้ Vertex AI ของ

text-embedding-004

รูปแบบและจัดเก็บไว้ในไฟล์ CSV ที่เผยแพร่ต่อสาธารณะ

bcca07eaee60787b.png

ตัวเลือกที่ 1: โหลดการฝังที่ประมวลผลล่วงหน้าผ่าน Cypher

หากต้องการแนบการฝังกับโหนด Movie ที่เกี่ยวข้องใน Neo4j อย่างรวดเร็ว ให้เรียกใช้คําสั่ง Cypher ต่อไปนี้ในเบราว์เซอร์ Neo4j

LOAD CSV WITH HEADERS FROM 'https://storage.googleapis.com/neo4j-vertexai-codelab/movie_embeddings.csv' AS row
WITH row
MATCH (m:Movie {tmdbId: toInteger(row.tmdbId)})
SET m.embedding = apoc.convert.fromJsonList(row.embedding)

คำสั่งนี้จะอ่านเวกเตอร์การฝังจาก CSV และแนบเป็นพร็อพเพอร์ตี้ (m.embedding) ในโหนด Movie แต่ละโหนด

ตัวเลือกที่ 2: โหลดการฝังโดยใช้ Python

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

python load_embeddings.py

สคริปต์นี้จะอ่าน CSV เดียวกันจาก GCS และเขียนการฝังลงใน Neo4j โดยใช้ไดรเวอร์ Python Neo4j

[ไม่บังคับ] สร้างการฝังด้วยตนเอง (สําหรับการสํารวจ)

หากต้องการทําความเข้าใจวิธีสร้างการฝัง คุณสามารถดูตรรกะในสคริปต์ generate_embeddings.py เอง โดยใช้ Vertex AI เพื่อฝังข้อความภาพรวมของภาพยนตร์แต่ละเรื่องโดยใช้โมเดล text-embedding-004

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

# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "./service-account.json"

⚠️ การดำเนินการตามกระบวนการสร้างการฝังอย่างเต็มรูปแบบจะใช้โควต้า Vertex AI และอาจใช้เวลานาน โดยเฉพาะเมื่อมีระเบียนหลายพันรายการ

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

7. แชทบ็อตแนะนำภาพยนตร์

เมื่อสร้างกราฟความรู้และการฝังข้อมูลแล้ว ก็ถึงเวลารวมทุกอย่างเข้าด้วยกันในอินเทอร์เฟซแบบสนทนา ซึ่งก็คือแชทบ็อตแนะนำภาพยนตร์

แชทบ็อตติดตั้งใช้งานโดยใช้ Python และ Gradio ซึ่งเป็นเฟรมเวิร์กที่มีน้ำหนักเบาสําหรับการสร้าง UI บนเว็บ ตรรกะหลักอยู่ในสคริปต์ chatbot.py ซึ่งเชื่อมต่อกับอินสแตนซ์ Neo4j AuraDB และทำการค้นหาความคล้ายคลึงของเวกเตอร์ในการฝังภาพยนตร์ตามพรอมต์ที่เป็นภาษาธรรมชาติ

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

เรียกใช้แชทบ็อตในเครื่อง

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

python chatbot.py

คุณควรเห็นเอาต์พุตที่คล้ายกับตัวอย่างต่อไปนี้

Old index dropped
Creating new vector index
Vector index created successfully
* Running on local URL:  http://127.0.0.1:7860
To create a public link, set `share=True` in `launch()`.

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

โต้ตอบกับแชทบ็อต

เมื่อเรียกใช้แล้ว ให้เปิด URL ที่แสดงในเทอร์มินัล ซึ่งมักจะเป็น 👉 http://127.0.0.1:7860

คุณจะเห็นอินเทอร์เฟซแชทแบบง่ายที่คุณสามารถพิมพ์คำค้นหาที่เป็นภาษาธรรมชาติได้ เช่น

  • "แนะนำภาพยนตร์ไซไฟระทึกขวัญให้ฉันหน่อย เช่น Inception"
  • "แนะนำภาพยนตร์โรแมนติกที่มีทอม แฮงส์"
  • "ฉันอยากดูละครครอบครัวที่ให้ความบันเทิงและผ่อนคลาย"

c76b6c6e2bcb25d9.png

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

ระบบจะแสดงผลคําแนะนําแต่ละรายการในเลย์เอาต์สไตล์การ์ดที่มีผลลัพธ์ที่จัดรูปแบบอย่างเรียบร้อย

เมื่อแชทบ็อตทำงานในเครื่องแล้ว คุณจะมีระบบแนะนำภาพยนตร์ที่ทำงานได้อย่างเต็มรูปแบบซึ่งทำงานด้วย Gen AI ที่รวมเอาข้อดีของ กราฟความรู้, LLM (Gemini) และการค้นหาเชิงความหมายเข้าด้วยกันโดยใช้การฝัง Vertex AI

8. (ไม่บังคับ) การปรับใช้ใน Google Cloud Run

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

ก่อนทำให้ใช้งานได้ ให้ตรวจสอบว่าไฟล์ต่อไปนี้อยู่ในโปรเจ็กต์ (ไฟล์เหล่านี้รวมอยู่ในที่เก็บข้อมูลนี้อยู่แล้ว)

  • requirements.txt – แสดงรายการไลบรารี Python ทั้งหมดที่จําเป็นต่อการใช้งานแอปพลิเคชัน ซึ่งรวมถึง Neo4j และ Vertex AI
  • Dockerfile – กำหนดสภาพแวดล้อมคอนเทนเนอร์ ซึ่งรวมถึงอิมเมจฐาน การติดตั้งข้อกำหนด และวิธีเปิดแอป

ขั้นตอนที่ 1: ตั้งค่าตัวแปรสภาพแวดล้อม

ในเทอร์มินัล ให้ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้ (แทนที่ค่าตัวยึดตําแหน่งด้วยการตั้งค่าโปรเจ็กต์จริง)

# Set your Google Cloud project ID
export GCP_PROJECT='your-project-id'  # Change this

# Set your preferred deployment region
export GCP_REGION='us-central1'

ขั้นตอนที่ 2: สร้างที่เก็บอาร์ติแฟกต์และสร้างคอนเทนเนอร์

# Artifact Registry repo and service name
export AR_REPO='your-repo-name'       # Change this
export SERVICE_NAME='movies-chatbot'  # Or any name you prefer

# Create the Artifact Registry repository
gcloud artifacts repositories create "$AR_REPO" \
  --location="$GCP_REGION" \
  --repository-format=Docker

# Authenticate Docker with Artifact Registry
gcloud auth configure-docker "$GCP_REGION-docker.pkg.dev"

# Build and submit the container image
gcloud builds submit \
  --tag "$GCP_REGION-docker.pkg.dev/$GCP_PROJECT/$AR_REPO/$SERVICE_NAME"

คำสั่งนี้จะแพ็กเกจแอปของคุณโดยใช้ Dockerfile และอัปโหลดอิมเมจคอนเทนเนอร์ไปยัง Google Cloud Artifact Registry

ขั้นตอนที่ 3: ติดตั้งใช้งานใน Cloud Run

ก่อนทำให้ใช้งานได้ โปรดตรวจสอบว่าตัวแปรสภาพแวดล้อมที่จำเป็นทั้งหมด (เช่น ข้อมูลเข้าสู่ระบบ Neo4j, การตั้งค่าโปรเจ็กต์) จะแสดงอยู่ในไฟล์ .env

ใช้ข้อมูลโค้ดต่อไปนี้เพื่อแปลงไฟล์ .env แบบไดนามิกเป็นรูปแบบที่เข้ากันได้กับ Flag --set-env-vars

ENV_VARS=$(grep -v '^#' .env | sed 's/ *= */=/g' | xargs -I{} echo -n "{},")
ENV_VARS=${ENV_VARS%,}

จากนั้นให้ทำให้แอปใช้งานได้โดยใช้คำสั่งต่อไปนี้

gcloud run deploy "$SERVICE_NAME" \
  --port=8080 \
  --image="$GCP_REGION-docker.pkg.dev/$GCP_PROJECT/$AR_REPO/$SERVICE_NAME" \
  --allow-unauthenticated \
  --region=$GCP_REGION \
  --platform=managed \
  --project=$GCP_PROJECT \
  --set-env-vars="GCP_PROJECT=$GCP_PROJECT,GCP_REGION=$GCP_REGION,$ENV_VARS"

เข้าถึงแชทบ็อต

เมื่อทําให้การเผยแพร่ใช้งานได้แล้ว Cloud Run จะแสดง URL ของบริการสาธารณะในรูปแบบต่อไปนี้

https://movies-chatbot-[UNIQUE_ID].${GCP_REGION}.run.app

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

หมายเหตุและเคล็ดลับ

  • ตรวจสอบว่า Dockerfile เรียกใช้ pip install -r requirements.txt ในระหว่างการสร้าง
  • หากไม่ได้ใช้ Cloud Shell คุณจะต้องตรวจสอบสิทธิ์สภาพแวดล้อมโดยใช้บัญชีบริการที่มีสิทธิ์ Vertex AI และ Artifact Registry
  • คุณตรวจสอบบันทึกและเมตริกการทำให้ใช้งานได้จาก Google Cloud Console > Cloud Run

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

bccf390b7099e73b.png

คุณสามารถดูรายละเอียดของบริการ เช่น URL, การกําหนดค่า, บันทึก และอื่นๆ ได้โดยคลิกที่ชื่อบริการที่ต้องการ (ในกรณีนี้คือ movies-chatbot)

3709b596167cdaa0.png

การดำเนินการนี้ทำให้แชทบ็อตแนะนำภาพยนตร์ใช้งานได้ ปรับขนาดได้ และแชร์ได้ 🎉

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

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

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

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

คุณสร้างและติดตั้งใช้งานแชทบอทแนะนำภาพยนตร์ที่ทำงานด้วยกราฟและปรับปรุงด้วย GenAI โดยใช้ Neo4j, Vertex AI และ Gemini เรียบร้อยแล้ว การรวมความสามารถในการโมเดลที่สื่อความหมายของ Neo4j เข้ากับความสามารถเชิงความหมายของ Vertex AI ในการฝังข้อมูลและปัญญาการสนทนาของ Gemini จะช่วยให้คุณสร้างระบบที่ใช้งานง่ายและชาญฉลาดซึ่งเข้าใจการค้นหาที่เป็นภาษาธรรมชาติและแสดงภาพยนตร์แนะนำที่เกี่ยวข้องตามบริบท

สิ่งที่คุณจะได้เรียนรู้ใน Codelab นี้

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

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

สำรวจและสร้างต่อไป และอย่าลืมติดตามข่าวสารล่าสุดจาก Neo4j, Vertex AI และ Google Cloud เพื่อยกระดับแอปพลิเคชันอัจฉริยะของคุณไปอีกขั้น

เอกสารอ้างอิง