Stopp
Der Filter „ stop “ entfernt bestimmte Stoppwörter aus dem tokenisierten Text und hilft so dabei, häufig vorkommende, weniger aussagekräftige Wörter auszuschließen. Sie können die Liste der Stoppwörter mithilfe des Parameters „ stop_words “ konfigurieren.
Konfiguration
Der Filter „ stop “ akzeptiert seine Stoppwortliste entweder inline über den Parameter „ stop_words “ oder aus einer registrierten Dateiressource über den Parameter „ stop_words_file “.
Inline-Stoppwortliste
Um den Filter „ stop “ mit einer Inline-Liste zu verwenden, geben Sie in der Filterkonfiguration den Parameter „ "type": "stop" “ an, zusammen mit einem „ stop_words “-Parameter, der die Liste der Stoppwörter bereitstellt.
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_"
]
}
]
}'
Der Filter „ stop “ akzeptiert die folgenden konfigurierbaren Parameter.
Parameter |
Beschreibung |
|---|---|
|
Eine Liste von Wörtern, die bei der Tokenisierung entfernt werden sollen. Standardmäßig verwendet der Filter das integrierte „
|
Der Filter „ stop “ wirkt auf die vom Tokenizer generierten Terme ein und muss daher in Kombination mit einem Tokenizer verwendet werden. Eine Liste der in Milvus verfügbaren Tokenizer finden Sie unter „Standard-Tokenizer“ und den zugehörigen Seiten.
Nachdem Sie „ analyzer_params “ definiert haben, können Sie diese bei der Definition eines Sammlungsschemas auf ein „ VARCHAR “-Feld anwenden. Dadurch kann Milvus den Text in diesem Feld mit dem angegebenen Analysator verarbeiten, um eine effiziente Tokenisierung und Filterung zu gewährleisten. Weitere Informationen finden Sie unter „Anwendungsbeispiel“.
Stoppwörter aus einer Dateiressource ladenCompatible with Milvus 3.0.x
Bei umfangreichen benutzerdefinierten Stoppwortlisten – sprachspezifische Listen, Fachvokabulare oder Listen, die Sie für mehrere Sammlungen gemeinsam nutzen möchten – speichern Sie die Wörter in einer Datei und registrieren Sie die Datei als Remote-Dateiressource; verweisen Sie dann im Filter über den Parameter „ stop_words_file “ darauf. Sie können „ stop_words_file “ allein oder zusammen mit dem Inline- stop_words “ verwenden; wenn beide festgelegt sind, führt der Filter die beiden Quellen zu einer einzigen Stoppwortliste zusammen.
Die Datei besteht aus einfachem UTF-8-Text mit einem Stoppwort pro Zeile. Beispiel:
the
of
for
Laden Sie die Datei in den Objektspeicher hoch, für dessen Verwendung Ihr Milvus-Cluster konfiguriert ist, und registrieren Sie sie anschließend:
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
)
Verweisen Sie im Filter über ` stop_words_file` auf die registrierte Ressource:
analyzer_params = {
"tokenizer": "standard",
"filter": [{
"type": "stop",
"stop_words_file": {
"type": "remote",
"resource_name": "en_stop_words",
"file_name": "stop_words.txt",
},
}],
}
Der Parameter „ stop_words_file “ akzeptiert ein Objekt mit den folgenden Feldern:
Feld |
Beschreibung |
|---|---|
|
Der Ressourcentyp. Verwenden Sie „ |
|
Der Name, der bei der Registrierung der Datei unter |
|
Der Dateinamensteil des Objekt-Speicherpfads der registrierten Ressource (z. B. |
Beispiele
Bevor Sie die Analyzer-Konfiguration auf Ihr Sammlungsschema anwenden, überprüfen Sie deren Verhalten mithilfe der Methode „ run_analyzer “.
Analysator-Konfiguration
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
Überprüfung mit 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
Erwartete Ausgabe
['The', 'stop', 'filter', 'allows', 'control', 'over', 'common', 'stop', 'words', 'text', 'processing']
