Stop

Le filtre « stop » supprime les mots vides spécifiés du texte tokenisé, ce qui permet d’éliminer les mots courants et peu significatifs. Vous pouvez configurer la liste des mots vides à l’aide du paramètre « stop_words ».

Configuration

Le filtre « stop » accepte sa liste de mots vides soit en ligne via le paramètre « stop_words », soit à partir d’une ressource de fichier enregistrée via le paramètre « stop_words_file ».

Liste de mots vides intégrée

Pour utiliser le filtre stop avec une liste intégrée, spécifiez "type": "stop" dans la configuration du filtre, ainsi qu’un paramètre stop_words fournissant la liste des mots vides.

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_"
      ]
    }
  ]
}'

Le filtre « stop » accepte les paramètres configurables suivants.

Paramètre

Description

stop_words

Liste des mots à exclure de la tokenisation. Par défaut, le filtre utilise le dictionnaire intégré « _english_ ». Vous pouvez le remplacer ou l’étendre de trois façons : Dictionnaires intégrés – indiquez l’un de ces alias de langage pour utiliser un dictionnaire prédéfini : "_arabic_", "_english_", "_danish_", "_dutch_", "_finnish_", "_french_", "_german_", "_hungarian_", "_italian_", "_norwegian_", "_portuguese_", "_russian_", "_spanish_", "_swedish_", "_thai_" Liste personnalisée – transmettez un tableau contenant vos propres termes, par exemple ["foo", "bar", "baz"]. Liste mixte – combinez des alias et des termes personnalisés, par exemple : ["of", "to", "_english_"]. Pour plus de détails sur le contenu exact de chaque dictionnaire prédéfini, consultez la section stop_words. Pour consulter le dictionnaire arabe ou thaï, reportez-vous à la liste des mots vides en arabe ou à la liste des mots vides en thaï.

Le filtre « stop » agit sur les termes générés par le tokeniseur ; il doit donc être utilisé en combinaison avec un tokeniseur. Pour obtenir la liste des tokeniseurs disponibles dans Milvus, consultez la page « Standard Tokenizer » et les pages associées.

Une fois les mots vides définis ( analyzer_params), vous pouvez les appliquer à un champ « VARCHAR » lors de la définition d’un schéma de collection. Cela permet à Milvus de traiter le texte de ce champ à l’aide de l’analyseur spécifié, pour une tokenisation et un filtrage efficaces. Pour plus de détails, consultez la section «Exemple d’utilisation».

Charger des mots vides à partir d’une ressource de fichierCompatible with Milvus 3.0.x

Pour les listes personnalisées de mots vides volumineuses (listes spécifiques à une langue, vocabulaires de domaine ou listes que vous souhaitez partager entre plusieurs collections), stockez les mots dans un fichier et enregistrez ce dernier en tant que ressource de fichier distant, puis référencez-le depuis le filtre via le paramètre « stop_words_file ». Vous pouvez utiliser « stop_words_file » seul ou en complément de « inline stop_words » ; lorsque les deux sont définis, le filtre fusionne les deux sources en une seule liste de mots vides.

Le fichier est un texte brut au format UTF-8 contenant un mot vide par ligne. Par exemple :

the
of
for

Téléchargez le fichier dans le magasin d’objets que votre cluster Milvus est configuré pour utiliser, puis enregistrez-le :

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
)

Faites référence à la ressource enregistrée dans le filtre via ` 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",
        },
    }],
}

Le paramètre ` stop_words_file ` accepte un objet comportant les champs suivants :

Champ	Description
type	Le type de ressource. Utilisez "remote" pour un fichier enregistré via add_file_resource. Pour la variante "local" utilisée dans les déploiements auto-hébergés, reportez-vous à la section Gérer les ressources de fichiers.
resource_name	Le nom utilisé lors de l'enregistrement du fichier sur add_file_resource.
file_name	La partie « nom de fichier » du chemin d’accès au magasin d’objets de la ressource enregistrée (par exemple, "stop_words.txt" si la ressource a été enregistrée via path="file/stop_words.txt").

Exemples

Avant d’appliquer la configuration de l’analyseur à votre schéma de collection, vérifiez son comportement à l’aide de la méthode run_analyzer.

Configuration de l’analyseur

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

Vérification à l’aide de 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

Résultat attendu

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