Jieba

Tokenizer jieba memproses teks bahasa Mandarin dengan memecahnya menjadi beberapa komponen kata.

Konfigurasi

Milvus mendukung dua pendekatan konfigurasi untuk tokenizer jieba: konfigurasi sederhana dan konfigurasi khusus.

Konfigurasi sederhana

Dengan konfigurasi sederhana, Anda hanya perlu mengatur tokenizer ke "jieba". Sebagai contoh:

# Simple configuration: only specifying the tokenizer name
analyzer_params = {
    "tokenizer": "jieba",  # Use the default settings: dict=["_default_"], mode="search", hmm=True
}

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

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

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

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

Konfigurasi sederhana ini setara dengan konfigurasi kustom berikut ini:

# Custom configuration equivalent to the simple configuration above
analyzer_params = {
    "type": "jieba",          # Tokenizer type, fixed as "jieba"
    "dict": ["_default_"],     # Use the default dictionary
    "mode": "search",          # Use search mode for improved recall (see mode details below)
    "hmm": True                # Enable HMM for probabilistic segmentation
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("type", "jieba");
analyzerParams.put("dict", Collections.singletonList("_default_"));
analyzerParams.put("mode", "search");
analyzerParams.put("hmm", true);

// javascript

analyzerParams = map[string]any{"type": "jieba", "dict": []any{"_default_"}, "mode": "search", "hmm": true}

# restful

Untuk detail tentang parameter, lihat Konfigurasi khusus.

Konfigurasi khusus

Untuk kontrol lebih lanjut, Anda dapat menyediakan konfigurasi khusus yang memungkinkan Anda menentukan kamus khusus, memilih mode segmentasi, dan mengaktifkan atau menonaktifkan Model Markov Tersembunyi (Hidden Markov Model, HMM). Sebagai contoh:

# Custom configuration with user-defined settings
analyzer_params = {
    "tokenizer": {
        "type": "jieba",           # Fixed tokenizer type
        "dict": ["customDictionary"],  # Custom dictionary list; replace with your own terms
        "mode": "exact",           # Use exact mode (non-overlapping tokens)
        "hmm": False               # Disable HMM; unmatched text will be split into individual characters
    }
}

Map<String, Object> analyzerParams = new HashMap<>();                                                                          
analyzerParams.put("tokenizer", new HashMap<String, Object>() {{
  put("type", "jieba");                                                                                                      
  put("dict", Arrays.asList("customDictionary"));             
  put("mode", "exact");
  put("hmm", false);
}});

// javascript

analyzerParams := map[string]interface{}{
  "tokenizer": map[string]interface{}{
      "type": "jieba",
      "dict": []string{"customDictionary"},
      "mode": "exact",
      "hmm":  false,
  },
}

# restful

Parameter	Deskripsi	Nilai Default
type	Jenis tokenizer. Ini ditetapkan ke "jieba".	"jieba"
dict	Daftar kamus yang akan dimuat oleh penganalisis sebagai sumber kosakata. Opsi bawaan: "_default_": Memuat kamus bahasa Mandarin Sederhana bawaan mesin. Untuk detailnya, lihat dict.txt. "_extend_default_": Memuat semua yang ada di "_default_" ditambah dengan tambahan suplemen Bahasa Mandarin Tradisional. Untuk detailnya, lihat dict.txt.big. Anda juga dapat menggabungkan kamus bawaan dengan sejumlah kamus khusus. Contoh: ["_default_", "结巴分词器"].	["_default_"]
mode	Mode segmentasi. Nilai-nilai yang mungkin: "exact": Mencoba menyegmentasikan kalimat dengan cara yang paling tepat, sehingga ideal untuk analisis teks. "search": Dibangun di atas mode eksak dengan memecah lebih lanjut kata-kata yang panjang untuk meningkatkan daya ingat, sehingga cocok untuk tokenisasi mesin pencari. Untuk informasi lebih lanjut, lihat Proyek Jieba GitHub.	"search"
hmm	Bendera boolean yang menunjukkan apakah akan mengaktifkan Hidden Markov Model (HMM) untuk segmentasi probabilistik kata-kata yang tidak ditemukan dalam kamus.	true

Untuk memuat kosakata khusus yang besar dari file eksternal alih-alih memasukkannya melalui dict, lihat Konfigurasi khusus dengan file kamus di bawah ini.

Setelah mendefinisikan analyzer_params, Anda dapat menerapkannya ke bidang VARCHAR ketika mendefinisikan skema koleksi. Hal ini memungkinkan Milvus untuk memproses teks dalam bidang tersebut menggunakan penganalisis yang ditentukan untuk tokenisasi dan pemfilteran yang efisien. Untuk detailnya, lihat Contoh penggunaan.

Konfigurasi khusus dengan file kamusCompatible with Milvus 3.0.x

Untuk kosakata khusus yang besar - glosarium domain, terminologi produk, atau daftar kata benda yang tepat - simpan kata-kata tersebut dalam sebuah file dan daftarkan file tersebut sebagai sumber daya file jarak jauh, lalu rujuk dari tokenisasi melalui parameter extra_dict_file. Penganalisis memuat kata-kata ini ke dalam kosakata di atas kamus bawaan.

File tersebut berupa teks UTF-8 biasa dengan satu istilah per baris. Sebagai contoh:

结巴分词器
向量数据库

Unggah berkas ke penyimpanan objek yang dikonfigurasikan untuk digunakan oleh klaster Milvus Anda, lalu daftarkan:

from pymilvus import MilvusClient

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

# Register the uploaded file under a name you'll reference from analyzer configs.
client.add_file_resource(
    name="zh_terms",
    path="file/zh_terms.txt",    # full S3 object key, including the rootPath prefix
)

// java

// nodejs

// go

# restful

Rujuk sumber daya yang didaftarkan di tokenizer melalui extra_dict_file:

analyzer_params = {
    "tokenizer": {
        "type": "jieba",
        "dict": ["_default_"],             # keep the built-in dictionary
        "mode": "exact",
        "hmm": False,
        "extra_dict_file": {
            "type": "remote",
            "resource_name": "zh_terms",
            "file_name": "zh_terms.txt",
        },
    },
}

client.run_analyzer(["milvus结巴分词器中文测试"], analyzer_params)
# → [['milvus', '结巴', '分词器', '中文', '测试']]

// java

// nodejs

// go

# restful

Parameter extra_dict_file menerima objek dengan bidang-bidang berikut:

Bidang	Deskripsi
type	Jenis sumber daya. Gunakan "remote" untuk berkas yang didaftarkan melalui add_file_resource. Untuk varian "local" yang digunakan dalam penerapan yang dihosting sendiri, lihat Mengelola Sumber Daya File.
resource_name	Nama yang digunakan saat file didaftarkan dengan add_file_resource.
file_name	Bagian nama file dari jalur penyimpanan objek sumber daya yang terdaftar (misalnya, "zh_terms.txt" jika sumber daya terdaftar dengan path="file/zh_terms.txt").

Kata-kata yang ditambahkan melalui extra_dict_file digabungkan dengan kamus bawaan, sehingga algoritme segmentasi jieba melihatnya di samping entri yang sudah ada. Apakah ada istilah tertentu yang muncul sebagai token mandiri tergantung pada pemilihan DAG berbobot probabilitas jieba - istilah khusus yang panjang seperti 向量数据库 masih dapat dipecah menjadi 向量 + 数据库 jika entri yang lebih pendek tersebut memiliki frekuensi yang lebih tinggi dalam kamus bawaan.

Contoh

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

Konfigurasi penganalisis

analyzer_params = {
    "tokenizer": {
        "type": "jieba",
        "dict": ["结巴分词器"],
        "mode": "exact",
        "hmm": False
    }
}

Map<String, Object> analyzerParams = new HashMap<>();                                                                          
analyzerParams.put("tokenizer", new HashMap<String, Object>() {{
  put("type", "jieba");                                                                                                      
  put("dict", Arrays.asList("结巴分词器"));                   
  put("mode", "exact");
  put("hmm", false);
}});

// javascript

analyzerParams := map[string]interface{}{
  "tokenizer": map[string]interface{}{
      "type": "jieba",
      "dict": []string{"结巴分词器"},
      "mode": "exact",
      "hmm":  false,
  },
}

# restful

Verifikasi menggunakan run_analyzer

from pymilvus import (
    MilvusClient,
)

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Sample text to analyze
sample_text = "milvus结巴分词器中文测试"

# 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("milvus结巴分词器中文测试");

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{"milvus结巴分词器中文测试"}
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

['milvus', '结巴分词器', '中', '文', '测', '试']