Descompactador

O filtro decompounder divide as palavras compostas em componentes individuais com base num dicionário especificado, facilitando a pesquisa de partes de termos compostos. Este filtro é particularmente útil para línguas que utilizam frequentemente palavras compostas, como o alemão. O dicionário de componentes pode ser fornecido em linha através do parâmetro word_list ou carregado a partir de um recurso de ficheiro registado através do parâmetro word_list_file.

Configuração

O filtro decompounder aceita o seu dicionário de componentes em linha através do parâmetro word_list ou a partir de um recurso de ficheiro registado através do parâmetro word_list_file.

Lista de palavras em linha

O filtro decompounder é um filtro personalizado no Milvus. Para o utilizar, especifique "type": "decompounder" na configuração do filtro, juntamente com um parâmetro word_list que fornece o dicionário de componentes de palavras a reconhecer.

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

O filtro decompounder aceita os seguintes parâmetros configuráveis.

Parâmetro	Descrição
word_list	Uma lista de componentes de palavras usadas para dividir termos compostos. Este dicionário determina como as palavras compostas são decompostas em termos individuais.

O filtro decompounder opera nos termos gerados pelo tokenizador, portanto deve ser usado em combinação com um tokenizador. Para obter uma lista de tokenizadores disponíveis no Milvus, consulte Tokenizador padrão e suas páginas irmãs.

Depois de definir analyzer_params, pode aplicá-los a um campo VARCHAR ao definir um esquema de coleção. Isto permite que o Milvus processe o texto nesse campo utilizando o analisador especificado para uma tokenização e filtragem eficientes. Para mais pormenores, consulte Exemplo de utilização.

Carregar componentes de palavras a partir de um recurso de ficheiroCompatible with Milvus 3.0.x

Para grandes dicionários de componentes - especialmente listas completas de palavras - armazene os componentes num ficheiro e registe o ficheiro como um recurso de ficheiro remoto, referenciando-o depois a partir do filtro através do parâmetro word_list_file. Pode utilizar word_list_file por si só ou juntamente com word_list em linha; quando ambos estão definidos, o filtro funde as duas fontes numa única lista de componentes.

O ficheiro é um texto UTF-8 simples com uma palavra componente por linha. Por exemplo:

dampf
schiff
fahrt
brot
backen
automat

Carregue o ficheiro para o armazenamento de objectos que o seu cluster Milvus está configurado para utilizar e, em seguida, registe-o:

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
)

Referenciar o recurso registado no filtro através de word_list_file:

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

O parâmetro word_list_file aceita um objeto com os seguintes campos:

Campo	Descrição
type	O tipo de recurso. Utilize "remote" para um ficheiro registado através de add_file_resource. Para a variante "local" utilizada em implementações auto-hospedadas, consulte Gerir Recursos de Ficheiros.
resource_name	O nome utilizado quando o ficheiro foi registado em add_file_resource.
file_name	A parte do nome de ficheiro do caminho do armazenamento de objectos do recurso registado (por exemplo, "decompounder.txt" se o recurso tiver sido registado com path="file/decompounder.txt").

Exemplos

Antes de aplicar a configuração do analisador ao esquema de coleção, verifique o seu comportamento utilizando o método run_analyzer.

Configuração do analisador

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

Verificação usando 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

Saída esperada

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