ทำการค้นหาความคล้ายคลึงกันของเวกเตอร์ด้วย Vertex AI

ยินดีต้อนรับสู่การค้นหาความคล้ายกันของเวกเตอร์ของ Firebase Data Connect ซึ่งเป็นการติดตั้งใช้งานการค้นหาเชิงความหมายของ Firebase ที่ผสานรวมกับ Google Vertex AI

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

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

คุณสามารถใช้การรองรับในตัวของ Data Connect ในการสร้างเวกเตอร์ Embedding โดยอัตโนมัติโดยใช้ Embeddings API ของ Vertex AI หรือใช้ API ดังกล่าวเพื่อสร้างด้วยตนเอง

ข้อกำหนดเบื้องต้น

• ตั้งค่า Data Connect สำหรับโปรเจ็กต์

• เปิดใช้ Vertex AI API

ตั้งค่า

คุณสามารถเลือกได้ระหว่างขั้นตอนการพัฒนาในเครื่อง (หากคุณเป็นนักพัฒนาเว็บ, Kotlin Android หรือ iOS) หรือขั้นตอน IDX (สำหรับนักพัฒนาเว็บ) คุณใช้ฐานข้อมูลในเครื่องหรือData Connectโปรเจ็กต์การผลิตและอินสแตนซ์ Cloud SQL สำหรับ PostgreSQL ของโปรเจ็กต์นั้นเพื่อการพัฒนาได้

คำสั่งเหล่านี้จะถือว่าคุณได้สร้างData Connectโปรเจ็กต์ ตามคู่มือเริ่มต้นฉบับย่อแล้ว

ผสานรวมกับ PostgreSQL ในเครื่อง

1. ตั้งค่าอินสแตนซ์ PostgreSQL ในเครื่อง
2. มอบบทบาท IAM ของผู้ใช้ Vertex AI ให้กับตัวคุณเอง
3. ตั้งค่าข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน Google Cloud ในสภาพแวดล้อมของคุณ
4. ติดตั้งส่วนขยาย pgvector ในอินสแตนซ์ PostgreSQL ในเครื่อง
5. เปิดใช้ส่วนขยายโดยใช้ CREATE EXTENSION vector ตามpgvector วิธีการในที่เก็บ

ผสานรวมกับ IDX

1. ตั้งค่าพื้นที่ทำงาน IDX โดยใช้เทมเพลตการเชื่อมต่อข้อมูล
2. มอบบทบาท IAM ของผู้ใช้ Vertex AI ให้กับตัวคุณเอง
3. เปิดใช้ส่วนขยายโดยใช้ CREATE EXTENSION vector ตามpgvector วิธีการในที่เก็บ

ออกแบบสคีมา

หากต้องการทำการค้นหาเวกเตอร์ ให้เพิ่มฟิลด์ใหม่ประเภท Vector ในสคีมา เช่น หากต้องการทำการค้นหาเชิงความหมายโดยใช้คำอธิบายภาพยนตร์ ให้เพิ่มฟิลด์เพื่อเก็บการฝังเวกเตอร์ที่เชื่อมโยงกับคำอธิบายภาพยนตร์ ในสคีมานี้ ระบบจะเพิ่ม descriptionEmbedding เพื่อจัดเก็บการฝังเวกเตอร์สำหรับฟิลด์ description

type Movie @table {
 id: ID! @col(name: "movie_id") @default(id: ID! @col(name: "movie_id") @default(expr: "uuidV4()")
 title: String!
 description: String
 descriptionEmbedding: Vector! @col(size:768)
 // ...
}

สร้างและเรียกข้อมูลการฝัง

Data Connect รองรับการฝังเวกเตอร์แบบผสานรวมด้วยค่าเซิร์ฟเวอร์ _embed ซึ่งจะสั่งให้ Data Connect สร้าง การฝังเวกเตอร์โดยเรียกใช้ Embedding API ของ Vertex AI ภายใน _embed ค่าเซิร์ฟเวอร์ใช้ได้ทั้งในการเปลี่ยนแปลงและการค้นหา

การกลายพันธุ์

สร้างและจัดเก็บการฝังผ่าน Data Connect

ในแอปการค้นหาเวกเตอร์ คุณอาจต้องการขอให้สร้างการฝังทันทีที่เพิ่มระเบียนลงในฐานข้อมูล ต่อไปนี้คือcreateMovie การเปลี่ยนแปลงที่เพิ่มระเบียนภาพยนตร์ลงในตาราง Movie และส่งคำอธิบายภาพยนตร์ พร้อมการฝังที่ระบุ model

mutation createMovie($title: String!, $description: String!) {
  movie_insert(data: {
    title: $title,
    description: $description,
    descriptionEmbedding_embed: {model: "textembedding-gecko@003", text: $description}
  })
}

ในบางกรณี คุณอาจต้องการอัปเดตคำอธิบายและการฝังภาพยนตร์

mutation updateDescription($id: String!, $description: String!) {
  movie_update(id: $id, data: {
    description: $description,
    descriptionEmbedding_embed: {model: "textembedding-gecko@003", text: $description}
  })
}

หากต้องการเรียกใช้การเปลี่ยนแปลงหลังสุดจากไคลเอ็นต์ ให้ทำดังนี้

import { updateMovieDescription } from 'lib/dataconnect-sdk/';

await updateMovieDescription({ id: movieId, description: description});

// Use the response

คำค้นหา

ดึงข้อมูลการฝังเวกเตอร์โดยใช้การค้นหา เช่น การค้นหาต่อไปนี้ โปรดทราบว่า descriptionEmbedding ที่การค้นหาแสดงผลคืออาร์เรย์ของจำนวนทศนิยม ซึ่งโดยปกติแล้ว มนุษย์จะอ่านไม่ได้ ดังนั้น Data Connect SDK ที่สร้างขึ้นจึงไม่ รองรับการส่งคืนโดยตรง

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

query getMovieDescription($id: String!) @auth(level: PUBLIC) {
 movie(id: $id)
   id
   description
   descriptionEmbedding
}

ค้นหาความคล้ายคลึง

ตอนนี้เราสามารถทำการค้นหาความคล้ายกันได้แล้ว

สำหรับฟิลด์ Vector แต่ละฟิลด์ Data Connect จะสร้างฟังก์ชัน GraphQL ที่ใช้การค้นหาความคล้ายคลึงกัน ฟังก์ชันที่สร้างขึ้นนี้มีชื่อว่า ${pluralType}_${vectorFieldName}_similarity โดยรองรับพารามิเตอร์บางรายการ ดังที่แสดงในตัวอย่างต่อไปนี้และในรายการอ้างอิง

คุณสามารถกำหนดฟังก์ชัน GraphQL ที่เรียกใช้การค้นหาความคล้ายกันได้ ดังที่กล่าวไว้ข้างต้น ค่าเซิร์ฟเวอร์ _embed จะสั่งให้ Data Connect สร้างการฝังเวกเตอร์โดยใช้ Embedding API ของ Vertex AI ในกรณีนี้คือเพื่อสร้างการฝังสำหรับสตริงการค้นหาที่ใช้เปรียบเทียบกับการฝังคำอธิบายภาพยนตร์

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

query searchMovieDescriptionUsingL2Similarity ($query: String!) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare_embed: {model: "textembedding-gecko@003", text: $query},
      where: {content: {ne: "No info available for this movie."}}, limit: 5)
      {
        id
        title
        description
      }
  }

ปรับแต่งการค้นหาความคล้ายคลึงกัน

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

หากต้องการค้นหาค่าที่เหมาะสมสำหรับ within เราสามารถเพิ่ม _metadata.distance ลงใน ฟิลด์ที่เลือกเพื่อดูว่าแต่ละผลลัพธ์อยู่ห่างจากเวกเตอร์การค้นหามากน้อยเพียงใด เราสามารถตั้งค่าพารามิเตอร์ within ตามค่า distance ที่ส่งคืนได้ โดยจะรวมเฉพาะผลลัพธ์ที่มี ระยะทางน้อยกว่าค่าของ within

query searchMovieDescriptionUsingL2Similarity ($query: String!) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare_embed: {model: "textembedding-gecko@003", text: $query},
      within: 2,
      where: {content: {ne: "No info available for this movie."}}, limit: 5)
      {
        id
        title
        description
        _metadata {
          distance
        }
      }
  }

คุณยังทดลองใช้ฟังก์ชันระยะทางต่างๆ ได้ด้วยโดยการตั้งค่าmethod พารามิเตอร์

query searchMovieDescriptionUsingL2Similarity ($query: String!) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare_embed: {model: "textembedding-gecko@003", text: $query},
      within: .5,
      method: COSINE,
      where: {content: {ne: "No info available for this movie."}}, limit: 5)
      {
        id
        title
        description
        _metadata {
          distance
        }
      }
  }

โปรดทราบว่าวิธีการต่างๆ จะแสดงค่าระยะทางที่แตกต่างกันมาก หากคุณตั้งค่า within คุณจะต้องปรับค่าดังกล่าวอีกครั้งหลังจากเปลี่ยน method

เรียกใช้การค้นหาความคล้ายคลึง

วิธีเรียกใช้การค้นหาความคล้ายคลึงจากโค้ดฝั่งไคลเอ็นต์

import { searchMovieDescriptionUsingL2similarity} from 'lib/dataconnect-sdk';

const response = await searchMovieDescriptionUsingL2similarity({ query });

// Use the response

ใช้การฝังที่กำหนดเอง

Data Connect ยังช่วยให้คุณทำงานกับ Embedding ได้โดยตรงในรูปแบบ Vectors แทนที่จะใช้ค่าเซิร์ฟเวอร์ _embed เพื่อสร้าง

จัดเก็บการฝังที่กำหนดเอง

เมื่อใช้ Vertex Embeddings API ให้ระบุโมเดลที่ตรงกันและขอผลลัพธ์การฝังที่มีมิติข้อมูลที่ถูกต้อง

จากนั้นแปลงอาร์เรย์ของจำนวนทศนิยมที่ส่งคืนเป็น Vector เพื่อส่งไปยังการดำเนินการ update สำหรับการจัดเก็บ

mutation updateDescription($id: String!, $description: String!, $descriptionEmbedding: Vector!) {
  movie_update(id: $id, data: {
    // title, genre...
    description: $description,
    descriptionEmbedding: $descriptionEmbedding
  })
}

ทำการค้นหาความคล้ายคลึงโดยใช้การฝังที่กำหนดเอง

ดำเนินการเดียวกันเพื่อดึงข้อมูลการฝังสำหรับข้อความค้นหาและแคสต์ ไปยัง Vectors

จากนั้นเรียกใช้ _similarity query เพื่อทำการค้นหาแต่ละครั้ง

query searchMovieDescriptionUsingL2Similarity($compare: Vector!, $within: Float, $excludesContent: String, $limit: Int) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare: $compare,
      method: L2,
      within: $within,
      where: {content: {ne: $excludesContent}}, limit: $limit)
      {
        id
        title
        description
      }
  }

ติดตั้งใช้งานในเวอร์ชันที่ใช้งานจริง

ติดตั้งใช้งานสคีมาและตัวเชื่อมต่อ

ขั้นตอนสุดท้ายในการทำซ้ำตามปกติคือการนำชิ้นงานไปใช้งานจริงData Connect

เมื่อติดตั้งใช้งานสคีมาที่มีVectorประเภทไปยัง CloudSQL โดยใช้คำสั่ง firebase deploy Firebase CLI จะดำเนินการตามขั้นตอนที่จำเป็นเพื่อเปิดใช้การสร้างการฝังที่อิงตาม Vertex AI ในอินสแตนซ์ CloudSQL

firebase deploy --only dataconnect

หากต้องการเปิดใช้การรองรับการฝังในอินสแตนซ์ CloudSQL ด้วยตนเอง หรือ พบข้อผิดพลาดใน CLI ให้ทำตามวิธีการเหล่านี้

ไวยากรณ์การค้นหาเวกเตอร์

ส่วนขยายสคีมา

ประเภทข้อมูล Data Connect ของ Vector จะแมปกับประเภท vector ของ PostgreSQL ตามที่กำหนดโดยpgvector ส่วนขยาย ระบบจะจัดเก็บประเภท vector ของ pgvector เป็นอาร์เรย์ของตัวเลขทศนิยมแบบความแม่นยำเดี่ยว ใน PostgreSQL

ใน Data Connect ประเภท Vector จะแสดงเป็นอาร์เรย์ของ ตัวเลข JSON ระบบจะบังคับให้ป้อนข้อมูลเป็นอาร์เรย์ของค่า float32 หากการบังคับ ล้มเหลว ระบบจะแสดงข้อผิดพลาด

ใช้พารามิเตอร์ขนาดของคำสั่ง @col เพื่อตั้งค่าขนาดของเวกเตอร์

type Question @table {
    text: String!
    category: String!
    textEmbedding: Vector! @col(size: 768)
}

size รองรับเฉพาะประเภท Vector Vector เช่น การค้นหาความคล้ายคลึง จำเป็นต้องมีVectorที่มีจำนวนมิติข้อมูลเท่ากัน

directive @col(
  # … existing args
  """
  Defines a fixed column size for certain scalar types.

  - For Vector, size is required.
  - For all other types, size is currently unsupported and hence supplying it will result in a schema error.
  """
  size: Int
) on FIELD_DEFINITION

ค่าเซิร์ฟเวอร์ _embed สำหรับการค้นหาและการเปลี่ยนแปลง

_embed

ค่าเซิร์ฟเวอร์นี้จะสั่งให้Data Connectสร้างและจัดเก็บการฝังโดยใช้ Embedding API ของ Vertex AI ค่าเซิร์ฟเวอร์นี้ใช้ได้กับทั้งการค้นหาและการเปลี่ยนแปลง

พารามิเตอร์สำหรับการค้นหาความคล้ายคลึง

method: COSINE|INNER_PRODUCT|L2

ฟังก์ชันระยะทางที่ใช้ในการค้นหาเพื่อนบ้านที่อยู่ใกล้เคียง อัลกอริทึมที่รองรับในปัจจุบัน เป็นส่วนย่อยของอัลกอริทึมการค้นหา pgvector

within: float

ข้อจำกัดเกี่ยวกับระยะทางที่ใช้ในการค้นหาจุดข้อมูลที่อยู่ใกล้ที่สุด

where: FDC filter condition

ดูคำแนะนำเกี่ยวกับสคีมา การค้นหา และการเปลี่ยนแปลง

limit: int

จำนวนผลลัพธ์ที่จะแสดง