सबसे नज़दीकी

ब्यौरा

अनुरोध की गई distance_measure का इस्तेमाल करके, दी गई embedding फ़ील्ड पर, सबसे नज़दीकी पड़ोसी वेक्टर की खोज करता है.

उदाहरण

Node.js
const results = await db.pipeline()
  .collection("cities")
  .findNearest({
      field: "embedding",
      vectorValue: [1.5, 2.345],
      distanceMeasure: "euclidean"
  })
  .execute();

Web

const results = await execute(db.pipeline()
  .collection("cities")
  .findNearest({
      field: "embedding",
      vectorValue: [1.5, 2.345],
      distanceMeasure: "euclidean"
  }));
Swift
let results = try await db.pipeline()
  .collection("cities")
  .findNearest(
    field: Field("embedding"),
    vectorValue: VectorValue([1.5, 2.345]),
    distanceMeasure: .euclidean
  )
  .execute()

Kotlin

val results = db.pipeline()
    .collection("cities")
    .findNearest(
        "embedding",
        doubleArrayOf(1.5, 2.345),
        FindNearestStage.DistanceMeasure.EUCLIDEAN
    )
    .execute()

Java

Task<Pipeline.Snapshot> results = db.pipeline()
        .collection("cities")
        .findNearest(
            "embedding",
            new double[] {1.5, 2.345},
            FindNearestStage.DistanceMeasure.EUCLIDEAN
        )
        .execute();
Python
from google.cloud.firestore_v1.vector import Vector
from google.cloud.firestore_v1.base_vector_query import DistanceMeasure

results = (
    client.pipeline()
    .collection("cities")
    .find_nearest(
        field="embedding",
        vector_value=Vector([1.5, 2.345]),
        distance_measure=DistanceMeasure.EUCLIDEAN,
    )
    .execute()
)
Java
Pipeline.Snapshot results =
    firestore
        .pipeline()
        .collection("cities")
        .findNearest(
            "embedding",
            new double[] {1.5, 2.345},
            FindNearest.DistanceMeasure.EUCLIDEAN,
            new FindNearestOptions())
        .execute()
        .get();

व्यवहार

दूरी मापने की इकाई

find_nearest(...) स्टेज, वेक्टर की दूरी के लिए ये विकल्प उपलब्ध कराता है:

  • euclidean: वेक्टर के बीच की euclidean दूरी को मापता है. ज़्यादा जानने के लिए, यूक्लिडियन देखें.
  • cosine: वेक्टर की तुलना, उनके बीच के कोण के आधार पर करता है. इससे आपको ऐसी समानता को मापने में मदद मिलती है जो वेक्टर के मैग्नीट्यूड पर आधारित नहीं होती. हमारा सुझाव है कि COSINE दूरी के बजाय, यूनिट नॉर्मलाइज़्ड वेक्टर के साथ dot_product का इस्तेमाल करें. यह गणित के हिसाब से एक जैसा है और इसकी परफ़ॉर्मेंस बेहतर है. ज़्यादा जानने के लिए, कोसाइन समानता देखें.
  • dot_product: यह cosine के जैसा है, लेकिन यह वेक्टर के मैग्नीट्यूड से प्रभावित होता है. ज़्यादा जानने के लिए, डॉट प्रॉडक्ट देखें.

दूरी मापने की इकाई चुनना

यह तय करने के लिए कि दूरी मापने की कौनसी इकाई इस्तेमाल करनी है, यह देखें कि आपके सभी वेक्टर एंबेडिंग नॉर्मलाइज़ किए गए हैं या नहीं. नॉर्मलाइज़ किए गए वेक्टर एंबेडिंग का मैग्नीट्यूड (लंबाई) ठीक 1.0 होती है.

इसके अलावा, अगर आपको पता है कि आपके मॉडल को ट्रेनिंग देने के लिए, दूरी मापने की कौनसी इकाई इस्तेमाल की गई थी, तो अपने वेक्टर एंबेडिंग के बीच की दूरी का हिसाब लगाने के लिए, दूरी मापने की उसी इकाई का इस्तेमाल करें.

नॉर्मलाइज़ किया गया डेटा

अगर आपके पास ऐसा डेटासेट है जिसमें सभी वेक्टर एंबेडिंग नॉर्मलाइज़ किए गए हैं, तो दूरी मापने की तीनों इकाइयां, सेमैंटिक खोज के एक जैसे नतीजे देती हैं. असल में, दूरी मापने की हर इकाई अलग-अलग वैल्यू दिखाती है, लेकिन उन वैल्यू को एक ही तरीके से क्रम में लगाया जाता है. जब एंबेडिंग नॉर्मलाइज़ किए जाते हैं, तो आम तौर पर dot_product सबसे ज़्यादा कंप्यूटेशन के हिसाब से कारगर होता है. हालांकि, ज़्यादातर मामलों में यह अंतर न के बराबर होता है. हालांकि, अगर आपका ऐप्लिकेशन परफ़ॉर्मेंस के हिसाब से बहुत संवेदनशील है, तो dot_product परफ़ॉर्मेंस को बेहतर बनाने में मदद कर सकता है.

नॉर्मलाइज़ नहीं किया गया डेटा

अगर आपके पास ऐसा डेटासेट है जिसमें वेक्टर एंबेडिंग नॉर्मलाइज़ नहीं किए गए हैं, तो दूरी मापने की इकाई के तौर पर dot_product का इस्तेमाल करना गणित के हिसाब से सही नहीं है, क्योंकि डॉट प्रॉडक्ट दूरी नहीं मापता. एंबेडिंग कैसे जनरेट किए गए थे और किस तरह की खोज को प्राथमिकता दी जाती है, इसके आधार पर, cosine या euclidean दूरी मापने की इकाई, खोज के ऐसे नतीजे देती है जो दूरी मापने की अन्य इकाइयों के मुकाबले बेहतर होते हैं. यह तय करने के लिए कि आपके इस्तेमाल के मामले के लिए कौनसा विकल्प सबसे अच्छा है, cosine या euclidean के साथ एक्सपेरिमेंट करना ज़रूरी हो सकता है.

यह पक्का नहीं है कि डेटा नॉर्मलाइज़ किया गया है या नहीं

अगर आपको यह पक्का नहीं है कि आपका डेटा नॉर्मलाइज़ किया गया है या नहीं और आपको dot_product का इस्तेमाल करना है, तो हमारा सुझाव है कि इसके बजाय, cosine का इस्तेमाल करें. cosine, नॉर्मलाइज़ेशन की सुविधा के साथ dot_product की तरह काम करता है. cosine का इस्तेमाल करके मापी गई दूरी, 0 से 2 के बीच होती है. अगर कोई नतीजा 0 के आस-पास है, तो इसका मतलब है कि वेक्टर बहुत मिलते-जुलते हैं.

नतीजों की संख्या सीमित करना

सीमा फ़ील्ड सेट करके, क्वेरी से मिलने वाले दस्तावेज़ों की संख्या सीमित की जा सकती है.limit

Node.js

const results = await db.pipeline()
  .collection("cities")
  .findNearest({
      field: "embedding",
      vectorValue: vector([1.5, 2.345]),
      distanceMeasure: "euclidean",
      limit: 10,
  })
  .execute();

वेक्टर की कैलकुलेट की गई दूरी वापस पाना

वेक्टर की कैलकुलेट की गई दूरी वापस पाने के लिए, a distance_field आउटपुट प्रॉपर्टी का नाम find_nearest(...) स्टेज पर असाइन करें, जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

उदाहरण के लिए, यहां दिए गए कलेक्शन के लिए:

Node.js

await db.collection("cities").doc("SF").set({name: "San Francisco", embedding: vector([1.0, -1.0])});
await db.collection("cities").doc("TO").set({name: "Toronto", embedding: vector([5.0, -10.0])});
await db.collection("cities").doc("AT").set({name: "Atlantis", embedding: vector([2.0, -4.0])});

अनुरोध किए गए आउटपुट distance_field के साथ, वेक्टर की खोज करें:

Node.js

const results = await db.pipeline()
  .collection("cities")
  .findNearest({
      field: "embedding",
      vectorValue: vector([1.3, 2.345]),
      distanceMeasure: "euclidean",
      distanceField: "computedDistance",
  })
  .execute();

इससे ये दस्तावेज़ मिलते हैं:

{name: "San Francisco", embedding: vector([1.0, -1.0]), computedDistance: 3.3584259705999178},
{name: "Atlantis", embedding: vector([2.0, -4.0]), computedDistance: 6.383496299051172},
{name: "Toronto", embedding: vector([5.0, -10.0]), computedDistance: 12.887553103673328}

सीमाएं

वेक्टर एंबेडिंग के साथ काम करते समय, इन सीमाओं का ध्यान रखें:

  • एंबेडिंग का ज़्यादा से ज़्यादा डाइमेंशन 2048 हो सकता है. बड़े इंडेक्स सेव करने के लिए, डाइमेंशनैलिटी रिडक्शन का इस्तेमाल करें.