Standard-Tokenizer

Der Tokenizer „ standard “ in Milvus gruppiert aufeinanderfolgende Unicode-Buchstaben und Ziffern zu Token und trennt diese an anderen Zeichen.

Tokenisierungsregeln

Der Tokenizer „ standard “ behält aufeinanderfolgende Zeichen, die zu den folgenden Mengen gehören, im selben Token bei:

• ASCII-Zeichen: Buchstaben A-Z und a-z sowie Ziffern 0-9.
• Nicht-ASCII-Zeichen: Zeichen mit der Unicode-Eigenschaft „ Alphabetic “ oder einer der numerischen allgemeinen Kategorien „ Nd “, „ Nl “ oder „ No “.

Unicode-Eigenschaft oder -Kategorie	Bedeutung	Beispiele für Zeichen, die in Tokens beibehalten werden
Alphabetic	Buchstaben verschiedener Schriftsysteme, einschließlich chinesischer Schriftzeichen und japanischer Kana, sowie einige Kombinationszeichen	中文测试, カタカナ
Nd (Decimal_Number)	Dezimalziffern	٣
Nl (Letter_Number)	Buchstabenähnliche Ziffern	Ⅷ
No (Other_Number)	Andere numerische Zeichen, wie z. B. eingekreiste Zahlen, hochgestellte Zeichen und Brüche	①²¾

Zeichen außerhalb dieser Mengen trennen Token voneinander und werden verworfen. Dazu gehören Leerzeichen, Satzzeichen, Unterstriche (_), Bindestriche (-), Apostrophe (') und Symbole wie +, $ und 😀. Aufeinanderfolgende Trennzeichen erzeugen keine leeren Token.

Die Zeichenklassifizierung folgt der von Rust char::is_alphanumeric(). Informationen zu Eigenschaftsdefinitionen finden Sie im Unicode-Standard-Anhang Nr. 44. Die vollständigen Unicode-17.0-Zeichenlisten sind verfügbar unter DerivedCoreProperties.txt unter Alphabetic sowie DerivedGeneralCategory.txt für Nd, Nl und No. Die Zugehörigkeit der Zeichen hängt von den Unicode-Daten ab, die von der bereitgestellten Version verwendet werden.

In den folgenden Beispielen wird „ {"tokenizer": "standard"} “ ohne Filter verwendet. Der Tokenizer behält die Groß- und Kleinschreibung bei und segmentiert zusammenhängenden chinesischen Text nicht in einzelne Wörter.

Eingabe	Ausgabe-Token
foo_bar-can't😀123	["foo", "bar", "can", "t", "123"]
中文测试	["中文测试"]
version①.¾	["version①", "¾"]
Hello,World!	["Hello", "World"]

Konfiguration

Um einen Analysator mit dem „ standard “-Tokenizer zu konfigurieren, setzen Sie „ tokenizer “ in „ analyzer_params “ auf „ standard “.

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

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

const analyzer_params = {
    "tokenizer": "standard",
};

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

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

Der Tokenizer „ standard “ kann in Verbindung mit einem oder mehreren Filtern verwendet werden. Der folgende Code definiert beispielsweise einen Analysator, der den Tokenizer „ standard “ und den Filter „ lowercase “ verwendet:

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

Nachdem Sie „ analyzer_params “ definiert haben, können Sie diese bei der Definition eines Sammlungsschemas auf ein „ VARCHAR “-Feld anwenden. Dadurch kann Milvus den Text in diesem Feld mithilfe des angegebenen Analysators verarbeiten, um eine effiziente Tokenisierung und Filterung zu gewährleisten. Weitere Informationen finden Sie unter „Anwendungsbeispiel“.

Beispiele

Bevor Sie die Analysator-Konfiguration auf Ihr Sammlungsschema anwenden, überprüfen Sie deren Verhalten mithilfe der Methode „ run_analyzer “.

Analysator-Konfiguration

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

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

// javascript

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

# restful

Ü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"
    "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

Erwartete Ausgabe

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