Trova il più vicino

Descrizione

Esegue una ricerca vettoriale del vicino più prossimo nel campo embedding specificato utilizzando la distance_measure richiesta.

Esempi

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

Comportamento

Misura della distanza

La fase find_nearest(...) supporta le seguenti opzioni per la distanza del vettore:

  • euclidean: misura la distanza euclidean tra i vettori. Per saperne di più, consulta Distanza euclidea.
  • cosine: confronta i vettori in base all'angolo tra loro, il che ti consente di misurare la somiglianza non basata sulla magnitudine dei vettori. Ti consigliamo di utilizzare dot_product con vettori normalizzati unitari anziché la distanza COSINE, che è matematicamente equivalente con prestazioni migliori. Per saperne di più, consulta Somiglianza del coseno.
  • dot_product: simile a cosine, ma è influenzato dalla magnitudine dei vettori. Per saperne di più, consulta Prodotto scalare.

Scegliere la misura della distanza

A seconda che tutti i vector embedding siano normalizzati o meno, puoi determinare quale misura della distanza utilizzare per trovare la misura della distanza. Un vector embedding normalizzato ha una magnitudine (lunghezza) pari esattamente a 1,0.

Inoltre, se conosci la misura della distanza con cui è stato addestrato il modello, utilizzala per calcolare la distanza tra i vector embedding.

Dati normalizzati

Se hai un set di dati in cui tutti i vector embedding sono normalizzati, tutte e tre le misure della distanza forniscono gli stessi risultati di ricerca semantica. In sostanza, anche se ogni misura della distanza restituisce un valore diverso, questi valori vengono ordinati nello stesso modo. Quando gli embedding vengono normalizzati, dot_product è in genere il più efficiente dal punto di vista computazionale, ma la differenza è trascurabile nella maggior parte dei casi. Tuttavia, se la tua applicazione è molto sensibile al rendimento, dot_product potrebbe aiutarti a ottimizzare il rendimento.

Dati non normalizzati

Se hai un set di dati in cui i vector embedding non sono normalizzati, non è matematicamente corretto utilizzare dot_product come misura della distanza perché il prodotto scalare non misura la distanza. A seconda di come sono stati generati gli embedding e del tipo di ricerca preferito, la misura della distanza cosine o euclidean produce risultati di ricerca soggettivamente migliori rispetto alle altre misure della distanza. Potrebbe essere necessario sperimentare con cosine o euclidean per determinare quale sia la migliore per il tuo caso d'uso.

Non sai se i dati sono normalizzati o non normalizzati

Se non sai se i tuoi dati sono normalizzati e vuoi utilizzare dot_product, ti consigliamo di utilizzare invece cosine. cosine è simile a dot_product con la normalizzazione integrata. La distanza misurata utilizzando cosine varia da 0 a 2. Un risultato vicino a 0 indica che i vettori sono molto simili.

Limitare i risultati

Puoi limitare il numero di documenti restituiti dalla query impostando il limit campo.

Node.js

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

Recuperare la distanza del vettore calcolata

Puoi recuperare la distanza del vettore calcolata assegnando un distance_field nome di proprietà di output nella fase find_nearest(...), come mostrato nell'esempio seguente:

Ad esempio, per la seguente raccolta:

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])});

Esegui una ricerca vettoriale con un output richiesto 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();

Che produce i seguenti documenti:

{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}

Limitazioni

Quando utilizzi i vector embedding, tieni presente la seguente limitazione: