Décompacteur

Le filtre decompounder divise les mots composés en composants individuels sur la base d'un dictionnaire spécifié, ce qui facilite la recherche de parties de termes composés. Ce filtre est particulièrement utile pour les langues qui utilisent fréquemment des mots composés, comme l'allemand. Le dictionnaire des composants peut être fourni en ligne via le paramètre word_list ou chargé à partir d'un fichier enregistré via le paramètre word_list_file.

Configuration

Le filtre decompounder accepte son dictionnaire de composants soit en ligne via le paramètre word_list, soit à partir d'un fichier enregistré via le paramètre word_list_file.

Liste de mots en ligne

Le filtre decompounder est un filtre personnalisé dans Milvus. Pour l'utiliser, spécifiez "type": "decompounder" dans la configuration du filtre, ainsi qu'un paramètre word_list qui fournit le dictionnaire des composants de mots à reconnaître.

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

Le filtre decompounder accepte les paramètres configurables suivants.

Paramètre	Description
word_list	Une liste de composants de mots utilisés pour diviser les termes composés. Ce dictionnaire détermine comment les mots composés sont décomposés en termes individuels.

Le filtre decompounder fonctionne sur les termes générés par le tokenizer, il doit donc être utilisé en combinaison avec un tokenizer. Pour obtenir la liste des tokenizers disponibles dans Milvus, reportez-vous à la page Tokenizer standard et à ses pages apparentées.

Après avoir défini 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, voir Exemple d'utilisation.

Charger des composants de mots à partir d'un fichierCompatible with Milvus 3.0.x

Pour les dictionnaires de composants volumineux - en particulier les listes de mots dans une langue complète - stockez les composants dans un fichier et enregistrez le fichier en tant que ressource de fichier distante, puis faites-y référence à partir du filtre via le paramètre word_list_file. Vous pouvez utiliser word_list_file seul ou avec word_list en ligne ; lorsque les deux sont définis, le filtre fusionne les deux sources en une seule liste de composants.

Le fichier est du texte UTF-8 brut avec un mot composant par ligne. Voici un exemple :

dampf
schiff
fahrt
brot
backen
automat

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

Référencer la ressource enregistrée dans le filtre via word_list_file:

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

Le paramètre word_list_file accepte un objet avec 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é lorsque le fichier a été enregistré 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, "decompounder.txt" si la ressource a été enregistrée avec path="file/decompounder.txt").

Exemples

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

Configuration de l'analyseur

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

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

Résultat attendu

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