Analyseur standard

L'analyseur standard est l'analyseur par défaut de Milvus, qui est automatiquement appliqué aux champs de texte si aucun analyseur n'est spécifié. Il utilise une tokenisation basée sur la grammaire, ce qui le rend efficace pour la plupart des langues.

Définition

L'analyseur standard se compose des éléments suivants

• Untokenizer: Utilise le tokenizer standard pour diviser le texte en unités de mots discrètes basées sur des règles de grammaire. Pour plus d'informations, voir Tokenizer standard.

• Filtre: Utilise le filtre lowercase pour convertir tous les tokens en minuscules, ce qui permet d'effectuer des recherches insensibles à la casse. Pour plus d'informations, voir Minuscules.

Les fonctionnalités de l'analyseur standard sont équivalentes à la configuration personnalisée suivante de l'analyseur :

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

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

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

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

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

Configuration de l'analyseur

Pour appliquer l'analyseur standard à un champ, il suffit de définir type sur standard dans analyzer_params, et d'inclure des paramètres facultatifs si nécessaire.

analyzer_params = {
    "type": "standard", # Specifies the standard analyzer type
}

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

const analyzer_params = {
    "type": "standard", // Specifies the standard analyzer type
}

analyzerParams = map[string]any{"type": "standard"}

# restful
analyzerParams='{
  "type": "standard"
}'

L'analyseur standard accepte les paramètres facultatifs suivants :

Paramètre	Description
stop_words	Un tableau contenant une liste de mots vides, qui seront supprimés de la tokenisation. La valeur par défaut est _english_, un ensemble intégré de mots d'arrêt anglais courants.

Exemple de configuration de mots vides personnalisés :

analyzer_params = {
    "type": "standard", # Specifies the standard analyzer type
    "stop_words", ["of"] # Optional: List of words to exclude from tokenization
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("type", "standard");
analyzerParams.put("stop_words", Collections.singletonList("of"));

analyzer_params = {
    "type": "standard", // Specifies the standard analyzer type
    "stop_words", ["of"] // Optional: List of words to exclude from tokenization
}

analyzerParams = map[string]any{"type": "standard", "stop_words": []string{"of"}}

# restful

Après avoir défini analyzer_params, vous pouvez les appliquer à un champ VARCHAR lors de la définition d'un schéma de collecte. 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 d'informations, reportez-vous à la section Exemple d'utilisation.

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 = {
    "type": "standard",  # Standard analyzer configuration
    "stop_words": ["for"] # Optional: Custom stop words parameter
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("type", "standard");
analyzerParams.put("stop_words", Collections.singletonList("for"));

// javascript

analyzerParams = map[string]any{"type": "standard", "stop_words": []string{"for"}}

# restful
analyzerParams='{
  "type": "standard",
  "stop_words": [
    "of"
  ]
}'

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 = "The Milvus vector database is built for scale!"

# 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")
        .token("root:Milvus")
        .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"
    "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{"The Milvus vector database is built for scale!"}
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

Standard analyzer output: ['the', 'milvus', 'vector', 'database', 'is', 'built', 'scale']