Detener

El filtro stop elimina las palabras de parada especificadas del texto tokenizado, lo que ayuda a eliminar las palabras comunes y menos significativas. Puede configurar la lista de palabras de parada utilizando el parámetro stop_words.

Configuración

El filtro stop acepta su lista de palabras de detención en línea mediante el parámetro stop_words o desde un recurso de archivo registrado mediante el parámetro stop_words_file.

Lista de palabras clave en línea

Para utilizar el filtro stop con una lista en línea, especifique "type": "stop" en la configuración del filtro, junto con un parámetro stop_words que proporcione la lista de palabras de detención.

analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "stop", # Specifies the filter type as stop
        "stop_words": ["of", "to", "_english_"], # Defines custom stop words and includes the English stop word list
    }],
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Collections.singletonList(
                new HashMap<String, Object>() {{
                    put("type", "stop");
                    put("stop_words", Arrays.asList("of", "to", "_english_"));
                }}
        )
);

const analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "stop", # Specifies the filter type as stop
        "stop_words": ["of", "to", "_english_"], # Defines custom stop words and includes the English stop word list
    }],
};

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "stop",
        "stop_words": []string{"of", "to", "_english_"},
    }}}

# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "stop",
      "stop_words": [
        "of",
        "to",
        "_english_"
      ]
    }
  ]
}'

El filtro stop acepta los siguientes parámetros configurables.

Parámetro

Descripción

stop_words

Una lista de palabras que deben eliminarse de la tokenización. Por defecto, el filtro utiliza el diccionario _english_ incorporado. Puede anularlo o ampliarlo de tres formas: Diccionarios incorporados: proporcione uno de estos alias de idioma para utilizar un diccionario predefinido: "_english_", "_danish_", "_dutch_", "_finnish_", "_french_", "_german_", "_hungarian_", "_italian_", "_norwegian_", "_portuguese_", "_russian_", "_spanish_", "_swedish_" Lista personalizada: pase una matriz con sus propios términos, por ejemplo, ["foo", "bar", "baz"]. Lista mixta - combina alias y términos personalizados, por ejemplo ["of", "to", "_english_"]. Para más detalles sobre el contenido exacto de cada diccionario predefinido, consulte stop_words.

El filtro stop 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 palabras de detención de un recurso de archivoCompatible with Milvus 3.0.x

Para listas de palabras clave personalizadas de gran tamaño (listas específicas de un idioma, vocabularios de dominio o listas que desee compartir en varias colecciones), almacene las palabras en un archivo y regístrelo como recurso de archivo remoto; a continuación, haga referencia a él desde el filtro mediante el parámetro stop_words_file. Puede utilizar stop_words_file solo o junto con stop_words en línea; si ambos parámetros están activados, el filtro fusiona las dos fuentes en una única lista de palabras clave.

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

the
of
for

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="en_stop_words",
    path="file/stop_words.txt",    # full S3 object key, including the rootPath prefix
)

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

analyzer_params = {
    "tokenizer": "standard",
    "filter": [{
        "type": "stop",
        "stop_words_file": {
            "type": "remote",
            "resource_name": "en_stop_words",
            "file_name": "stop_words.txt",
        },
    }],
}

El parámetro stop_words_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, "stop_words.txt" si el recurso se registró con path="file/stop_words.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": "stop", # Specifies the filter type as stop
        "stop_words": ["of", "to", "_english_"], # Defines custom stop words and includes the English stop word list
    }],
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Collections.singletonList(
                new HashMap<String, Object>() {{
                    put("type", "stop");
                    put("stop_words", Arrays.asList("of", "to", "_english_"));
                }}
        )
);

// javascript

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "stop",
        "stop_words": []string{"of", "to", "_english_"},
    }}}

# restful

Verificación mediante run_analyzer

from pymilvus import (
    MilvusClient,
)

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

# Sample text to analyze
sample_text = "The stop filter allows control over common stop words for text processing."

# 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("The stop filter allows control over common stop words for text processing.");

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{"The stop filter allows control over common stop words for text processing."}
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

['The', 'stop', 'filter', 'allows', 'control', 'over', 'common', 'stop', 'words', 'text', 'processing']