Jieba

Il tokenizer jieba elabora il testo cinese scomponendolo nelle parole che lo compongono.

Configurazione

Milvus supporta due approcci di configurazione per il tokenizer jieba: una configurazione semplice e una configurazione personalizzata.

Configurazione semplice

Con la configurazione semplice, è sufficiente impostare il tokenizer su "jieba". Ad esempio:

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

Questa configurazione semplice è equivalente alla seguente configurazione personalizzata:

# 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

Per i dettagli sui parametri, consultare la sezione Configurazione personalizzata.

Configurazione personalizzata

Per un maggiore controllo, è possibile fornire una configurazione personalizzata che consente di specificare un dizionario personalizzato, selezionare la modalità di segmentazione e attivare o disattivare il modello di Markov nascosto (HMM). Ad esempio:

# 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

Parametro	Descrizione	Valore predefinito
type	Il tipo di tokenizer. È fissato a "jieba".	"jieba"
dict	Un elenco di dizionari che l'analizzatore caricherà come fonte di vocabolario. Opzioni integrate: "_default_": Carica il dizionario integrato del motore in cinese semplificato. Per i dettagli, fare riferimento a dict.txt. "_extend_default_": Carica tutto quello che c'è in "_default_" più un supplemento di cinese tradizionale. Per i dettagli, fare riferimento a dict.txt.big. È anche possibile combinare il dizionario integrato con un numero qualsiasi di dizionari personalizzati. Esempio: ["_default_", "结巴分词器"].	["_default_"]
mode	La modalità di segmentazione. Valori possibili: "exact": Cerca di segmentare la frase nel modo più preciso, il che la rende ideale per l'analisi del testo. "search": Si basa sulla modalità esatta, suddividendo ulteriormente le parole lunghe per migliorare il richiamo, rendendola adatta alla tokenizzazione dei motori di ricerca. Per ulteriori informazioni, consultare il progetto GitHub di Jieba.	"search"
hmm	Un flag booleano che indica se abilitare il modello Hidden Markov (HMM) per la segmentazione probabilistica delle parole non presenti nel dizionario.	true

Dopo aver definito analyzer_params, è possibile applicarle a un campo VARCHAR quando si definisce uno schema di raccolta. Questo permette a Milvus di elaborare il testo in quel campo usando l'analizzatore specificato per una tokenizzazione e un filtraggio efficienti. Per i dettagli, si veda l'esempio di utilizzo.

Esempi

Prima di applicare la configurazione dell'analizzatore allo schema di raccolta, verificarne il comportamento con il metodo run_analyzer.

Configurazione dell'analizzatore

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

Verifica con run_analyzerCompatible with Milvus 2.5.11+

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

Risultato atteso

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