Décomposeur

Le filtre « decompounder » divise les mots composés en leurs différents composants à l’aide 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 directement via le paramètre « word_list » ou chargé à partir d’une ressource de fichier enregistrée 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’une ressource de fichier enregistrée via le paramètre « word_list_file ».

Liste de mots intégrée

Le filtre « decompounder » est un filtre personnalisé de Milvus. Pour l’utiliser, spécifiez « "type": "decompounder" » dans la configuration du filtre, ainsi qu’un paramètre « word_list » fournissant 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"],
    }],
}

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

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"));
                }}
        )
);

analyzerParams := map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "decompounder",
        "word_list": []string{"dampf", "schiff", "fahrt", "brot", "backen", "automat"},
    }}}

let analyzer_params = serde_json::json!({
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"]
    }]
});

nlohmann::json analyzer_params = {
    {"tokenizer", "standard"},
    {"filter", {
        {
            {"type", "decompounder"},
            {"word_list", {"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"],
    }],
};

using System.Collections.Generic;

var analyzerParams = new Dictionary<string, object>
{
    ["tokenizer"] = "standard",
    ["filter"] = new object[]
    {
        new Dictionary<string, object>
        {
            ["type"] = "decompounder", // Specifies the filter type as decompounder
            ["word_list"] = new[] { "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	Liste des composants de mots utilisés pour décomposer les termes composés. Ce dictionnaire détermine comment les mots composés sont décomposés en termes individuels.

Le filtre « decompounder » opère 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, consultez la page « Standard Tokenizer » et les pages associées.

Après avoir défini les paramètres d’ 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 ».

Chargement des composants de mots à partir d’une ressource de fichierCompatible with Milvus 3.0.x

Pour les dictionnaires de composants volumineux — en particulier les listes de mots couvrant une langue entière —, stockez les composants dans un fichier et enregistrez ce dernier en tant que ressource de fichier distante, puis référencez-le depuis le filtre via le paramètre « word_list_file ». Vous pouvez utiliser « word_list_file » seul ou en complément de l’ word_list intégré ; lorsque les deux sont définis, le filtre fusionne les deux sources en une seule liste de composants.

Le fichier est un texte brut au format UTF-8 contenant un mot composant par ligne. Par 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
)

Faites référence à 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 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, "decompounder.txt" si la ressource a été enregistrée via path="file/decompounder.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": "decompounder", # Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
}

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

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"));
                }}
        )
);

analyzerParams := map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "decompounder",
        "word_list": []string{"dampf", "schiff", "fahrt", "brot", "backen", "automat"},
    }}}

let analyzer_params = serde_json::json!({
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"]
    }]
});

nlohmann::json analyzer_params = {
    {"tokenizer", "standard"},
    {"filter", {
        {
            {"type", "decompounder"},
            {"word_list", {"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"],
    }],
};

using System.Collections.Generic;

var analyzerParams = new Dictionary<string, object>
{
    ["tokenizer"] = "standard",
    ["filter"] = new object[]
    {
        new Dictionary<string, object>
        {
            ["type"] = "decompounder", // Specifies the filter type as decompounder
            ["word_list"] = new[] { "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", token="root:Milvus")

# Sample text to analyze
sample_text = "dampfschifffahrt brotbackautomat"

# Run the analyzer with the defined configuration
result = client.run_analyzer(sample_text, analyzer_params)
print("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;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

ConnectConfig config = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .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();

import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://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...).
    WithAnalyzerParamsStr(string(bs))

result, err := client.RunAnalyzer(ctx, option)
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println(result)

use milvus::v2::error::Result;
use milvus::v2::prelude::*;
use serde_json::json;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let analyzer_params = json!({
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"]
    }]
});

let result = client.run_analyzer(
    RunAnalyzerRequest::builder()
        .texts(["dampfschifffahrt brotbackautomat".to_string()])
        .analyzer_params(analyzer_params)
        .build()?,
).await?;
println!("{:?}", result.results());

#include "milvus/MilvusClientV2.h"
#include <iostream>
#include <string>

auto client = milvus::MilvusClientV2::Create();

milvus::ConnectParam connect_param{"http://localhost:19530", "root:Milvus"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

std::string text = "dampfschifffahrt brotbackautomat";
auto request = milvus::RunAnalyzerRequest()
                       .AddText(text)
                       .WithAnalyzerParams(analyzer_params);

milvus::RunAnalyzerResponse response;
status = client->RunAnalyzer(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

for (const auto& result : response.Results()) {
    for (const auto& token : result.Tokens()) {
        std::cout << token.token_ << " ";
    }
    std::cout << std::endl;
}

import { MilvusClient } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'http://localhost:19530',
  token: 'root:Milvus'
});

const res = await client.runAnalyzer({
  text: 'dampfschifffahrt brotbackautomat',
  analyzer_params: analyzer_params
});

console.log(res);

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Utility;
using Milvus.Client.V2.Types;

using var client = new MilvusClientV2(new ConnectConfig { Uri = "http://localhost:19530", ApiKey = "root:Milvus" });
await client.ConnectAsync();

// Sample text to analyze
var sampleText = "dampfschifffahrt brotbackautomat";

var result = await client.RunAnalyzerAsync(new RunAnalyzerReq
{
    AnalyzerParams = analyzerParams,
    Texts = new[] { sampleText }
});
foreach (var r in result.Results)
{
    Console.WriteLine("Analyzer output: " + string.Join(", ", r.Tokens.Select(t => t.Token)));
}

# restful
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
  --url "${CLUSTER_ENDPOINT}/v2/vectordb/common/run_analyzer" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{
    "analyzerParams": "{\"tokenizer\":\"standard\",\"filter\":[{\"type\":\"decompounder\",\"word_list\":[\"dampf\",\"schiff\",\"fahrt\",\"brot\",\"backen\",\"automat\"]}]}",
    "text": ["dampfschifffahrt brotbackautomat"]
  }'

Résultat attendu

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