Espaces

Le tokeniseur whitespace divise le texte en fonction de cinq caractères d'espacement ASCII : tabulation, saut de ligne, saut de page, retour chariot et espace.

Règles de segmentation

Le tokeniseur d'whitespace s découpe le texte uniquement au niveau des cinq caractères d'espacement ASCII suivants :

Caractère	Nom	Point de code Unicode
\t	Tabulation horizontale	U+0009
\n	Saut de ligne	U+000A
\x0C ou \f	Saut de page	U+000C
\r	Retour chariot	U+000D
' '	Espace	U+0020

Ces séparateurs sont ignorés, et des séparateurs consécutifs ne produisent pas de tokens vides. La ponctuation et les autres caractères restent dans les tokens. En particulier, la tabulation verticale (\x0B, U+000B), l'espace insécable (\u00A0) et l'espace idéographique (\u3000) ne déclenchent pas de fractionnement.

Cet ensemble suit celui de Rust char::is_ascii_whitespace(), qui exclut les autres caractères d’espacement Unicode.

Les exemples suivants utilisent {"tokenizer": "whitespace"} sans aucun filtre. Les entrées et sorties utilisent la notation de chaîne Python : les séquences d'échappement telles que \t et \u00A0 représentent les caractères réels.

Entrée	Tokens en sortie
"a\tb\nc\x0Cd\re f"	["a", "b", "c", "d", "e", "f"]
"Hello,World! foo_bar"	["Hello,World!", "foo_bar"]
"a\x0Bb"	["a\x0Bb"]
"a\u00A0b"	["a\u00A0b"]
"a\u3000b"	["a\u3000b"]
" a b "	["a", "b"]

Configuration

Pour configurer un analyseur à l’aide du tokenizer « whitespace », définissez « tokenizer » sur « whitespace » dans analyzer_params.

analyzer_params = {
    "tokenizer": "whitespace",
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "whitespace");

const analyzer_params = {
    "tokenizer": "whitespace"
};

analyzerParams = map[string]any{"tokenizer": "whitespace"}

# restful
analyzerParams='{
  "tokenizer": "whitespace"
}'

Le tokenizer « whitespace » peut fonctionner en association avec un ou plusieurs filtres. Par exemple, le code suivant définit un analyseur qui utilise le tokenizer « whitespace » et le filtre « lowercase »:

analyzer_params = {
    "tokenizer": "whitespace",
    "filter": ["lowercase"]
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "whitespace");
analyzerParams.put("filter", Collections.singletonList("lowercase"));

const analyzer_params = {
    "tokenizer": "whitespace",
    "filter": ["lowercase"]
};

analyzerParams = map[string]any{"tokenizer": "whitespace", "filter": []any{"lowercase"}}

# restful
analyzerParams='{
  "tokenizer": "whitespace",
  "filter": [
    "lowercase"
  ]
}'

Une fois les paramètres analyzer_params définis, 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, reportez-vous à la section Exemple d’utilisation.

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": "whitespace",
    "filter": ["lowercase"]
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "whitespace");
analyzerParams.put("filter", Collections.singletonList("lowercase"));

// javascript

analyzerParams = map[string]any{"tokenizer": "whitespace", "filter": []any{"lowercase"}}

# restful

Vérification à l’aide de run_analyzerCompatible with Milvus 2.5.11+

from pymilvus import (
    MilvusClient,
)

client = MilvusClient(uri="http://localhost:19530")

# Sample text to analyze
sample_text = "The Milvus vector database is built for scale!"

# Run the whitespace analyzer with the defined configuration
result = client.run_analyzer(sample_text, analyzer_params)
print("Whitespace 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 Milvus vector database is built for scale!");

RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
        .texts(texts)
        .analyzerParams(analyzerParams)
        .build());
List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();

// javascript

import (
    "context"
    "fmt"

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

ctx := context.Background()
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

texts := []string{"The Milvus vector database is built for scale!"}
option := milvusclient.NewRunAnalyzerOption(texts...).
    WithAnalyzerParams(analyzerParams)

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

# restful

Résultat attendu

['the', 'milvus', 'vector', 'database', 'is', 'built', 'for', 'scale!']