Stop

El filtro « stop » elimina las palabras vacías especificadas del texto tokenizado, lo que ayuda a descartar palabras comunes y de menor relevancia. Puedes configurar la lista de palabras vacías mediante el parámetro « stop_words ».

Configuración

El filtro « stop » acepta su lista de palabras vacías bien en línea, mediante el parámetro « stop_words », bien desde un recurso de archivo registrado, mediante el parámetro « stop_words_file ».

Lista de palabras vacías en línea

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

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 » admite los siguientes parámetros configurables.

Parámetro

Descripción

stop_words

Una lista de palabras que se deben eliminar de la tokenización. De forma predeterminada, el filtro utiliza el diccionario integrado « _english_ ». Puede sobrescribirlo o ampliarlo de tres formas: Diccionarios integrados: introduce uno de estos alias de idioma para utilizar un diccionario predefinido: "_arabic_", "_english_", "_danish_", "_dutch_", "_finnish_", "_french_", "_german_", "_hungarian_", "_italian_", "_norwegian_", "_portuguese_", "_russian_", "_spanish_", "_swedish_", "_thai_" Lista personalizada: pasa una matriz con tus propios términos, p. ej., ["foo", "bar", "baz"]. Lista mixta: combina alias y términos personalizados, p. ej., ["of", "to", "_english_"]. Para obtener más detalles sobre el contenido exacto de cada diccionario predefinido, consulta stop_words. Para consultar el diccionario de árabe o tailandés, consulta la lista de palabras vacías en árabe o la lista de palabras vacías en tailandés.

El filtro « stop » actúa sobre 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, consulta «Tokenizador estándar» y sus páginas relacionadas.

Una vez definidas las palabras vacías ( analyzer_params), puede aplicarlas a un campo de tipo « VARCHAR » al definir el esquema de una colección. Esto permite a Milvus procesar el texto de ese campo utilizando el analizador especificado para una tokenización y un filtrado eficientes. Para obtener más detalles, consulte «Ejemplo de uso».

Cargar palabras vacías desde un recurso de archivoCompatible with Milvus 3.0.x

En el caso de listas personalizadas de palabras de stop de gran tamaño —listas específicas de un idioma, vocabularios de dominio o listas que desee compartir entre varias colecciones—, almacene las palabras en un archivo y registre dicho archivo como un 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 » por sí solo o junto con « stop_words »; cuando ambos están configurados, el filtro fusiona las dos fuentes en una única lista de palabras de stop.

El archivo es texto sin formato en UTF‑8 con una palabra vacía por línea. Por ejemplo:

the
of
for

Sube el archivo al almacén de objetos que tu clúster de Milvus esté configurado para utilizar y, a continuación, regístralo:

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 mediante ` 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 ` admite un objeto con los siguientes campos:

Campo	Descripción
type	El tipo de recurso. Utiliza ` "remote" ` para un archivo registrado mediante ` add_file_resource`. Para la variante ` "local" ` utilizada en implementaciones autohospedadas, consulta «Gestionar recursos de archivos».
resource_name	El nombre utilizado al registrar 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ó en path="file/stop_words.txt").

Ejemplos

Antes de aplicar la configuración del analizador al esquema de su colección, compruebe su comportamiento mediante 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

Resultado esperado

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