Dekompounder

Der Filter decompounder zerlegt zusammengesetzte Wörter auf der Grundlage eines angegebenen Wörterbuchs in einzelne Komponenten, um die Suche nach Teilen zusammengesetzter Begriffe zu erleichtern. Dieser Filter ist besonders nützlich für Sprachen, die häufig zusammengesetzte Wörter verwenden, wie z. B. Deutsch. Das Komponentenwörterbuch kann über den Parameter word_list inline bereitgestellt oder über den Parameter word_list_file aus einer registrierten Dateiressource geladen werden.

Konfiguration

Der Filter decompounder akzeptiert sein Komponentenwörterbuch entweder inline über den Parameter word_list oder aus einer registrierten Dateiressource über den Parameter word_list_file.

Inline-Wortliste

Der decompounder Filter ist ein benutzerdefinierter Filter in Milvus. Um ihn zu verwenden, geben Sie "type": "decompounder" in der Filterkonfiguration an, zusammen mit einem word_list Parameter, der das Wörterbuch der zu erkennenden Wortkomponenten bereitstellt.

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

Der Filter decompounder akzeptiert die folgenden konfigurierbaren Parameter.

Parameter	Beschreibung
word_list	Eine Liste von Wortkomponenten, die zur Aufteilung zusammengesetzter Begriffe verwendet werden. Dieses Wörterbuch bestimmt, wie zusammengesetzte Wörter in einzelne Begriffe zerlegt werden.

Der Filter decompounder arbeitet mit den vom Tokenizer erzeugten Begriffen, muss also 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 sie auf ein VARCHAR Feld anwenden, wenn Sie ein Sammelschema definieren. Dies ermöglicht es Milvus, den Text in diesem Feld mit dem angegebenen Analysator für eine effiziente Tokenisierung und Filterung zu verarbeiten. Details finden Sie unter Beispielanwendung.

Laden von Wortkomponenten aus einer DateiressourceCompatible with Milvus 3.0.x

Für große Komponentenwörterbücher - insbesondere für vollsprachige Wortlisten - speichern Sie die Komponenten in einer Datei und registrieren Sie die Datei als entfernte Dateiressource, auf die Sie dann im Filter über den Parameter word_list_file verweisen. Sie können word_list_file allein oder zusammen mit dem Inline-Parameter word_list verwenden; wenn beide Parameter gesetzt sind, fügt der Filter die beiden Quellen zu einer einzigen Komponentenliste zusammen.

Die Datei ist ein einfacher UTF-8-Text mit einem Komponentenwort pro Zeile. Ein Beispiel:

dampf
schiff
fahrt
brot
backen
automat

Laden Sie die Datei in den Objektspeicher hoch, für den Ihr Milvus-Cluster konfiguriert ist, und registrieren Sie sie dann:

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
)

Verweisen Sie auf die registrierte Ressource im Filter über word_list_file:

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

Der Parameter word_list_file nimmt ein Objekt mit den folgenden Feldern entgegen:

Feld	Beschreibung
type	Der Ressourcentyp. Verwenden Sie "remote" für eine über add_file_resource registrierte Datei. Informationen zur Variante "local", die in selbst gehosteten Bereitstellungen verwendet wird, finden Sie unter Verwalten von Dateiressourcen.
resource_name	Der Name, der verwendet wurde, als die Datei mit add_file_resource registriert wurde.
file_name	Der Teil des Dateinamens des Objektspeicherpfads der registrierten Ressource (z. B. "decompounder.txt", wenn die Ressource mit path="file/decompounder.txt" registriert wurde).

Beispiele

Bevor Sie die Analyzer-Konfiguration auf Ihr Auflistungsschema anwenden, überprüfen Sie ihr Verhalten mit der Methode run_analyzer.

Analyzer-Konfiguration

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

Überprüfung mit 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

Erwartete Ausgabe

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