Descomponedor

El filtro decompounder divide las palabras compuestas en componentes individuales basándose en un diccionario especificado, lo que facilita la búsqueda de partes de términos compuestos. Este filtro es especialmente útil para idiomas que utilizan con frecuencia palabras compuestas, como el alemán. El diccionario de componentes puede suministrarse en línea mediante el parámetro word_list o cargarse desde un recurso de archivo registrado mediante el parámetro word_list_file.

Configuración

El filtro decompounder acepta su diccionario de componentes en línea mediante el parámetro word_list o desde un recurso de archivo registrado mediante el parámetro word_list_file.

Lista de palabras en línea

El filtro decompounder es un filtro personalizado de Milvus. Para usarlo, especifique "type": "decompounder" en la configuración del filtro, junto con un parámetro word_list que proporciona el diccionario de componentes de palabras a reconocer.

analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "decompounder", # Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Collections.singletonList(
                new HashMap<String, Object>() {{
                    put("type", "decompounder");
                    put("word_list", Arrays.asList("dampf", "schiff", "fahrt", "brot", "backen", "automat"));
                }}
        )
);

const analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "decompounder", // Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
};

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "decompounder",
        "word_list": []string{"dampf", "schiff", "fahrt", "brot", "backen", "automat"},
    }}}

# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "decompounder",
      "word_list": [
        "dampf",
        "schiff",
        "fahrt",
        "brot",
        "backen",
        "automat"
      ]
    }
  ]
}'

El filtro decompounder acepta los siguientes parámetros configurables.

Parámetro	Descripción
word_list	Una lista de componentes de palabras utilizados para dividir términos compuestos. Este diccionario determina cómo se descomponen las palabras compuestas en términos individuales.

El filtro decompounder funciona con los términos generados por el tokenizador, por lo que debe utilizarse en combinación con un tokenizador. Para obtener una lista de los tokenizadores disponibles en Milvus, consulte Standard Tokenizer y sus páginas hermanas.

Después de definir analyzer_params, puede aplicarlos a un campo VARCHAR al definir un esquema de colección. Esto permite a Milvus procesar el texto de ese campo utilizando el analizador especificado para una tokenización y filtrado eficientes. Para más detalles, consulte Ejemplo de uso.

Cargar componentes de palabras desde un recurso de archivoCompatible with Milvus 3.0.x

Para diccionarios de componentes grandes - especialmente listas de palabras de idiomas completos - almacene los componentes en un archivo y registre el archivo como un recurso de archivo remoto, luego haga referencia a él desde el filtro a través del parámetro word_list_file. Puede utilizar word_list_file solo o junto con word_list en línea; si ambos parámetros están activados, el filtro fusiona las dos fuentes en una única lista de componentes.

El archivo es texto plano UTF-8 con una palabra componente por línea. Por ejemplo:

dampf
schiff
fahrt
brot
backen
automat

Cargue el archivo en el almacén de objetos para el que está configurado su cluster Milvus y regístrelo:

from pymilvus import MilvusClient

client = MilvusClient(uri="http://localhost:19530")

# Register the uploaded file under a name you'll reference from analyzer configs.
client.add_file_resource(
    name="de_components",
    path="file/decompounder.txt",    # full S3 object key, including the rootPath prefix
)

Haga referencia al recurso registrado en el filtro a través de word_list_file:

analyzer_params = {
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list_file": {
            "type": "remote",
            "resource_name": "de_components",
            "file_name": "decompounder.txt",
        },
    }],
}

El parámetro word_list_file acepta un objeto con los siguientes campos:

Campo	Descripción
type	El tipo de recurso. Utilice "remote" para un archivo registrado a través de add_file_resource. Para la variante "local" utilizada en despliegues autoalojados, consulte Gestionar recursos de archivos.
resource_name	El nombre utilizado cuando se registró el archivo en add_file_resource.
file_name	La parte del nombre de archivo de la ruta del almacén de objetos del recurso registrado (por ejemplo, "decompounder.txt" si el recurso se registró con path="file/decompounder.txt").

Ejemplos

Antes de aplicar la configuración del analizador a su esquema de colección, verifique su comportamiento utilizando el método run_analyzer.

Configuración del analizador

analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "decompounder", # Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Collections.singletonList(
                new HashMap<String, Object>() {{
                    put("type", "decompounder");
                    put("word_list", Arrays.asList("dampf", "schiff", "fahrt", "brot", "backen", "automat"));
                }}
        )
);

// javascript

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "decompounder",
        "word_list": []string{"dampf", "schiff", "fahrt", "brot", "backen", "automat"},
    }}}

# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "decompounder",
      "word_list": [
        "dampf",
        "schiff",
        "fahrt",
        "brot",
        "backen",
        "automat"
      ]
    }
  ]
}'

Verificación mediante run_analyzer

from pymilvus import (
    MilvusClient,
)

client = MilvusClient(uri="http://localhost:19530")

# Sample text to analyze
sample_text = "dampfschifffahrt brotbackautomat"

# Run the standard analyzer with the defined configuration
result = client.run_analyzer(sample_text, analyzer_params)
print("Standard analyzer output:", result)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.RunAnalyzerReq;
import io.milvus.v2.service.vector.response.RunAnalyzerResp;

ConnectConfig config = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build();
MilvusClientV2 client = new MilvusClientV2(config);

List<String> texts = new ArrayList<>();
texts.add("dampfschifffahrt brotbackautomat");

RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
        .texts(texts)
        .analyzerParams(analyzerParams)
        .build());
List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();

// javascript

import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

bs, _ := json.Marshal(analyzerParams)
texts := []string{"dampfschifffahrt brotbackautomat"}
option := milvusclient.NewRunAnalyzerOption(texts).
    WithAnalyzerParams(string(bs))

result, err := client.RunAnalyzer(ctx, option)
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

# restful

Salida esperada

['dampf', 'schiff', 'fahrt', 'brotbackautomat']