Penganalisis Standar

Penganalisis standard adalah penganalisis standar di Milvus, yang secara otomatis diterapkan pada bidang teks jika tidak ada penganalisis yang ditentukan. Penganalisis ini menggunakan tokenisasi berbasis tata bahasa, sehingga efektif untuk sebagian besar bahasa.

Definisi

Penganalisis standard terdiri dari:

• Tokenizer: Menggunakan tokenizer standard untuk membagi teks menjadi unit kata terpisah berdasarkan aturan tata bahasa. Untuk informasi lebih lanjut, lihat Tokenizer Standar.

• Filter: Menggunakan filter lowercase untuk mengubah semua token menjadi huruf kecil, sehingga memungkinkan pencarian yang tidak peka huruf besar/kecil. Untuk informasi lebih lanjut, lihat Huruf Kecil.

Fungsionalitas penganalisis standard setara dengan konfigurasi penganalisis khusus berikut ini:

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

Konfigurasi

Untuk menerapkan penganalisis standard ke suatu bidang, cukup setel type ke standard di analyzer_params, dan sertakan parameter opsional sesuai kebutuhan.

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

Penganalisis standard menerima parameter opsional berikut ini:

Parameter	Deskripsi
stop_words	Larik yang berisi daftar kata berhenti, yang akan dihapus dari tokenisasi. Defaultnya adalah _english_, kumpulan kata henti bahasa Inggris yang umum.

Contoh konfigurasi kata henti khusus:

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

Setelah mendefinisikan analyzer_params, Anda dapat menerapkannya ke bidang VARCHAR saat mendefinisikan skema koleksi. Hal ini memungkinkan Milvus untuk memproses teks di dalam bidang tersebut menggunakan penganalisis yang ditentukan untuk tokenisasi dan pemfilteran yang efisien. Untuk informasi lebih lanjut, lihat Penggunaan contoh.

Contoh

Sebelum menerapkan konfigurasi penganalisis ke skema koleksi Anda, verifikasi perilakunya menggunakan metode run_analyzer.

Konfigurasi penganalisis

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

Verifikasi menggunakan 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

Keluaran yang diharapkan

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