सबसे नज़दीकी

ब्यौरा

अनुरोध की गई 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();
Go
snapshot := client.Pipeline().Collection("cities").
	FindNearest("embedding", []float64{1.5, 2.345}, firestore.PipelineDistanceMeasureEuclidean).
	Execute(ctx)

व्यवहार

दूरी की माप

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();

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

कैलकुलेट की गई वेक्टर दूरी को वापस पाने के लिए, 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 डाइमेंशन इस्तेमाल किए जा सकते हैं. बड़े इंडेक्स सेव करने के लिए, डाइमेंशनैलिटी रिडक्शन का इस्तेमाल करें.