Standard-Analysator

Der standard Analysator ist der Standard-Analysator in Milvus, der automatisch auf Textfelder angewendet wird, wenn kein Analysator angegeben ist. Er verwendet eine grammatikbasierte Tokenisierung und ist daher für die meisten Sprachen geeignet.

Definition

Der standard Analyzer besteht aus:

• Tokenisierer: Verwendet den standard Tokenizer, um Text auf der Grundlage von Grammatikregeln in diskrete Worteinheiten zu zerlegen. Weitere Informationen finden Sie unter Standard Tokenizer.

• Filter: Verwendet den lowercase Filter, um alle Token in Kleinbuchstaben umzuwandeln und so eine Suche ohne Berücksichtigung der Groß-/Kleinschreibung zu ermöglichen. Weitere Informationen finden Sie unter Kleinschreibung.

Die Funktionalität des standard Analyzers entspricht der folgenden benutzerdefinierten Analyzer-Konfiguration:

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

Konfiguration

Um den standard Analyzer auf ein Feld anzuwenden, setzen Sie einfach type auf standard in analyzer_params, und fügen Sie optionale Parameter nach Bedarf hinzu.

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

Der standard Analyzer akzeptiert die folgenden optionalen Parameter:

Parameter	Beschreibung
stop_words	Ein Array mit einer Liste von Stoppwörtern, die aus der Tokenisierung entfernt werden. Der Standardwert ist _english_, ein eingebauter Satz allgemeiner englischer Stoppwörter.

Beispielkonfiguration für benutzerdefinierte Stoppwörter:

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

Nachdem Sie analyzer_params definiert haben, können Sie sie bei der Definition eines Sammelschemas auf ein VARCHAR Feld anwenden. Dadurch kann Milvus den Text in diesem Feld unter Verwendung des angegebenen Analysators für eine effiziente Tokenisierung und Filterung verarbeiten. Weitere Informationen finden Sie unter Verwendung von Beispielen.

Beispiele

Bevor Sie die Analyzer-Konfiguration auf Ihr Sammelschema anwenden, überprüfen Sie das Verhalten mit der Methode run_analyzer.

Analyzer-Konfiguration

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

Überprüfung mit 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

Erwartete Ausgabe

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