/ /

$scoreFusion (agregación)

La $rankFusion y $scoreFusion etapas están disponibles como funcionalidades de vista previa. Para obtener más información, consulte Funcionalidades de Previsualización.

Importante

$scoreFusion solo está disponible para implementaciones que utilizan MongoDB 8.2+.

Definición

$scoreFusion

$scoreFusion primero ejecuta todos los pipelines de entrada de forma independiente y luego elimina duplicados y combina los resultados de los pipelines de entrada en un conjunto de resultados finales puntuados.

$scoreFusion produce un conjunto clasificado de documentos basados en las puntuaciones de los documentos y en los pesos de sus pipelines de entrada. Puedes especificar una expresión aritmética para calcular la puntuación en función de las puntuaciones de entrada de la etapa de la pipeline. Por defecto, utiliza el promedio de los puntajes de los documentos de las diferentes etapas del pipeline de entrada.

Utiliza $scoreFusion para buscar documentos en una sola colección basándose en múltiples criterios y recuperar un conjunto de resultados finales puntuados que tenga en cuenta todos los criterios especificados.

Sintaxis

La etapa tiene la siguiente sintaxis:

{ $scoreFusion: {
    input: {
      pipelines: {
            <input-pipeline-name>: <expression>,
            <input-pipeline-name>: <expression>,
            ...
      },
      normalization: "none|sigmoid|minMaxScaler"
    },
    combination: {
      weights: {
            <input-pipeline-name>: <numeric expression>,
            <input-pipeline-name>: <numeric expression>,
            ...
      },
      method: "avg|expression",
      expression: <expression>
    }
} }

Campos

$scoreFusion requiere los siguientes campos:

Campo	Tipo	Descripción
`input`	Objeto	Define la entrada que combina `$scoreFusion`.
`input.` `pipelines`	Objeto	Contiene un mapa de nombres de canalización para las etapas de agregación que definen esa canalización. `input.pipelines` debe contener al menos una canalización. Debe especificar `$score` A la canalización de entrada si esta no devuelve una puntuación. Todas las canalizaciones deben operar en la misma colección y tener un nombre único. Para obtener más información sobre las restricciones de la entrada de pipelines, consultar la sección Pipelines de entrada y Nombres de pipelines de entrada.
`input.` `normalization`	String	Normaliza la puntuación en el rango de `0` a `1` antes de combinar los resultados. El valor puede ser: `none` - para no normalizar. `sigmoid` - para aplicar la expresión `$sigmoid`. `minMaxScaler` - para aplicar el `$minMaxScaler` operador de ventana.
`combination`	Objeto	Opcional. Define cómo combinar los resultados del pipeline `input`.
`combination.` `weights`	Objeto	opcional. Pesos que se deben aplicar a las puntuaciones normalizadas de la pipeline de entrada al combinar los resultados. Corresponde a los pipelines de entrada, uno por cada pipeline. El peso por defecto es `1` si no se especifica el peso de alguna pipeline. Cada valor de peso debe ser un número no negativo (entero o decimal). El peso puede ser `0`.
`combination.` `method`	String	Opcional. Especifica el método para combinar puntuaciones. El valor puede ser: `avg` - para calcular el promedio de las puntuaciones de entrada `expression` - para aplicar una expresión de agregación personalizada que especifique en el campo `combination.expression`. Si se omite, es por defecto `avg`.
`combination.` `expression`	Expresión aritmética	Opcional. Especifica la lógica para combinar las puntuaciones de entrada. Esta es la expresión personalizada que se utiliza cuando `combination.method` se establece en `expression`. Dentro de la expresión, utilice el nombre de la canalización de entrada para representar la puntuación de entrada correspondiente a un documento. Mutuamente excluyente con `combination.weights`.
`scoreDetails`	Booleano	opcional. Especifica si se debe incluir información detallada de puntuación de cada pipeline de entrada en los metadatos del documento de salida. Si se omite, se utilizará por defecto `false`.

Comportamiento

Colecciones

Solo puedes usar $scoreFusion con una única colección. No puedes usar esta etapa de agregación en el ámbito de la base de datos.

De-Duplication

$scoreFusion Desduplica los resultados de múltiples canales de entrada en la salida final. Cada documento de entrada único aparece como máximo una vez en la salida $scoreFusion, independientemente del número de veces que aparezca en las salidas del canal de entrada.

Tuberías de entrada

Cada input pipeline debe ser tanto un Pipeline de Selección como un Pipeline de puntuación.

Selección pipeline

Una pipeline de selección recupera un conjunto de documentos de una colección sin realizar ninguna modificación después de la recuperación. $scoreFusion compara documentos a través de diferentes pipelines de entrada, lo que requiere que todas las pipelines de entrada produzcan los mismos documentos sin modificar.

Una pipeline de selección debe contener únicamente las siguientes etapas:

Tipo	Etapas
Etapas de búsqueda	`$match`, incluido `$match` con búsqueda de texto heredada `$geoNear` `$search` `$vectorSearch` Si usas `$geoNear` en un pipeline de selección, no puedes especificar `includeLogs` o `distanceField` porque esos campos modifican los documentos.
Etapas de ordenamiento	`$sort`
Etapas de paginación	`$skip` `$limit`

Pipeline de scoring

Una pipeline de puntuación ordena o clasifica los documentos en función de la puntuación de los documentos. $scoreFusion utiliza el orden de los resultados del pipeline puntuados para influir en las puntuaciones de salida. Las pipelines de puntuación deben cumplir uno de los siguientes criterios:

Comienza con una de las siguientes etapas ordenadas:
- $search
- $vectorSearch
- $match con búsqueda de texto heredada
- $geoNear
Contiene una etapa $score explícita si la pipeline precedente no retorna inherentemente una puntuación.

Nombres de canalizaciones de entrada

Los nombres de las pipeline en input deben cumplir con las siguientes restricciones:

No debe ser una cadena vacía
No debe comenzar con una $
No debe contener el delimitador de carácter nulo ASCII \0 en ninguna parte de la cadena
No debe contener una .

scoreDetails

Si estableces scoreDetails en true, $scoreFusion crea un campo de metadatos scoreDetails para cada documento. El campo scoreDetails contiene información sobre la clasificación final.

Nota

When you set scoreDetails to true, $scoreFusion establishes the scoreDetails campo de metadatos para cada documento. Por defecto, no genera automáticamente el scoreDetails metafield.

Para ver el campo de metadatos scoreDetails, debes configurarlo explícitamente a través de la expresión $meta en una etapa como $project, $addFields, o $set.

El campo scoreDetails contiene los siguientes subcampos:

Campo	Descripción
`value`	El valor numérico de la puntuación para este documento.
`description`	Una descripción de cómo `$scoreFusion` calculó la puntuación final.
`normalization`	El método de normalización utilizado para normalizar la puntuación.
`combination`	El método de combinación y la expresión utilizados para combinar los resultados de la canalización.
`details`	Un arreglo en el que cada entrada contiene información sobre las pipelines de entrada que generan este documento.

Cada entrada de arreglo en el campo details contiene los siguientes subcampos:

Campo	Descripción
`inputPipelineName`	El nombre de la pipeline de entrada que generó este documento.
`inputPipelineRawScore`	La puntuación del documento proveniente del pipeline antes de la normalización.
`weight`	El peso de la pipeline de entrada.
`value`	Opcional. Si la canalización de entrada genera un `{ $meta: 'score' }` para este documento, `value` contiene `{ $meta: 'score' }`.
`details`	El campo `scoreDetails` del pipeline de entrada. Si el pipeline de entrada no produce un campo `scoreDetails`, este campo es un arreglo vacío.

Advertencia

MongoDB no garantiza ningún formato de salida específico para scoreDetails.

Ejemplo

Los siguientes bloques de código muestran el campo scoreDetails para una operación $scoreFusion con los pipelines de entrada $search, $vectorSearch y $match:

  scoreDetails: {
  value: 7.847857250621068,
  description: 'the value calculated by combining the scores (either normalized or raw) across input pipelines from which this document is output from:',
  normalization: 'sigmoid',
  combination: {
    method: 'custom expression',
    expression: "{ string: { $sum: [ { $multiply: [ '$$searchOne', 10 ] }, '$$searchTwo' ] } }"
  },
  details: [
    {
      inputPipelineName: 'searchOne',
      inputPipelineRawScore: 0.7987099885940552,
      weight: 1,
      value: 0.6896984675751023,
      details: []
    },
    {
      inputPipelineName: 'searchTwo',
      inputPipelineRawScore: 2.9629626274108887,
      weight: 1,
      value: 0.950872574870045,
      details: []
    }
  ]
}

Explique los resultados

MongoDB convierte las operaciones $scoreFusion en un conjunto de etapas de agregación existentes que, en combinación, computan el resultado de salida antes de la ejecución de la query. La Explicación de resultados para una operación $scoreFusion muestran la ejecución completa de las etapas de agregación subyacentes que $scoreFusion utiliza para componer el resultado final.

Ejemplos

Este ejemplo utiliza una colección con incrustaciones y campos de texto. Cree índices de tipo search y vectorSearch en la colección.

La siguiente definición de índice indexa automáticamente todos los campos indexables dinámicamente en la colección para ejecutar consultas contra los campos $search indexados.

Índice de búsqueda

db.embedded_movies.createSearchIndex(
   "<INDEX_NAME>",
   {
      mappings: { dynamic: true }
   }
)

La siguiente definición de índice indexa el campo con las incrustaciones en la colección para ejecutar consultas de $vectorSearch query contra ese campo.

Índice vectorSearch

db.embedded_movies.createSearchIndex(
   "<INDEX_NAME>",
   "vectorSearch",
   {
      "fields": [
         {
            "type": "vector",
            "path": "<FIELD_NAME>",
            "numDimensions": <NUMBER_OF_DIMENSIONS>,
            "similarity": "dotProduct"
         }
      ]
   }
);

El siguiente pipeline de agregación usa $scoreFusion con los siguientes pipelines de entrada:

pipeline	Número de Documentos Devueltos	Descripción
`searchOne`	20	Ejecuta una búsqueda vectorial en el campo indexado como tipo `vector` para el término especificado como embeddings. La query considera hasta 500 vecinos más cercanos, pero limita los resultados a 20 documentos.
`searchTwo`	20	Ejecuta una búsqueda de texto completo para el mismo término y limita los resultados a 20 documentos.

1 db.embedded_movies.aggregate( [
2    {
3       $scoreFusion: {
4          input: {
5             pipelines: {
6                searchOne: [
7                   {
8                      "$vectorSearch": {
9                         "index": "<INDEX_NAME>",
10                         "path": "<FIELD_NAME>",
11                         "queryVector": <QUERY_EMBEDDINGS>,
12                         "numCandidates": <NUMBER_OF_NEAREST_NEIGHBORS_TO_CONSIDER>,
13                         "limit": <NUBMER_OF_DOCUMENTS_TO_RETURN>
14                      }
15                   }
16                ],
17                searchTwo: [
18                   {
19                      "$search": {
20                         "index": "<INDEX_NAME>",
21                         "text": {
22                            "query": "<QUERY_TERM>",
23                            "path": "<FIELD_NAME>"
24                         }
25                      }
26                   },
27                ]
28             },
29             normalization: "sigmoid"
30          },
31          combination: {
32             method: "expression",
33             expression: {
34                $sum: [
35                  {$multiply: [ "$$searchOne", 10]}, "$$searchTwo"
36                ]
37             }
38          },
39          "scoreDetails": true
40       }
41    },
42    {
43       "$project": {
44          _id: 1,
45          title: 1,
46          plot: 1,
47          scoreDetails: {"$meta": "scoreDetails"}
48       }
49    },
50    { $limit: 20 }
51 ] )

Este pipeline realiza las siguientes acciones:

Ejecuta las input pipelines
Combina los resultados devueltos
Muestra los primeros 20 documentos que son los primeros 20 resultados clasificados del pipeline $scoreFusion

Volver

$score

$search

1	db.embedded_movies.aggregate( [
2	{
3	$scoreFusion: {
4	input: {
5	pipelines: {
6	searchOne: [
7	{
8	"$vectorSearch": {
9	"index": "<INDEX_NAME>",
10	"path": "<FIELD_NAME>",
11	"queryVector": <QUERY_EMBEDDINGS>,
12	"numCandidates": <NUMBER_OF_NEAREST_NEIGHBORS_TO_CONSIDER>,
13	"limit": <NUBMER_OF_DOCUMENTS_TO_RETURN>
14	}
15	}
16	],
17	searchTwo: [
18	{
19	"$search": {
20	"index": "<INDEX_NAME>",
21	"text": {
22	"query": "<QUERY_TERM>",
23	"path": "<FIELD_NAME>"
24	}
25	}
26	},
27	]
28	},
29	normalization: "sigmoid"
30	},
31	combination: {
32	method: "expression",
33	expression: {
34	$sum: [
35	{$multiply: [ "$$searchOne", 10]}, "$$searchTwo"
36	]
37	}
38	},
39	"scoreDetails": true
40	}
41	},
42	{
43	"$project": {
44	_id: 1,
45	title: 1,
46	plot: 1,
47	scoreDetails: {"$meta": "scoreDetails"}
48	}
49	},
50	{ $limit: 20 }
51	] )