Jieba

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

Configurazione

Milvus supporta due approcci di configurazione per il tokenizzatore 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

Per caricare un vocabolario personalizzato di grandi dimensioni da un file esterno, invece di inlining tramite dict, vedere Configurazione personalizzata con un file dizionario qui sotto.

Dopo aver definito analyzer_params, è possibile applicarli 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, vedere Esempio di utilizzo.

Configurazione personalizzata con un file dizionarioCompatible with Milvus 3.0.x

Per i vocabolari personalizzati di grandi dimensioni (glossari di domini, terminologia di prodotti o elenchi di nomi propri), è possibile memorizzare le parole in un file e registrarlo come risorsa di file remota, per poi fare riferimento ad esso dal tokenizer tramite il parametro extra_dict_file. L'analizzatore carica queste parole nel suo vocabolario, oltre al dizionario incorporato.

Il file è un semplice testo UTF-8 con un termine per riga. Ad esempio:

结巴分词器
向量数据库

Caricare il file nell'archivio di oggetti che il cluster Milvus è configurato per utilizzare, quindi registrarlo:

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

Fare riferimento alla risorsa registrata nel tokenizer tramite 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

Il parametro extra_dict_file accetta un oggetto con i seguenti campi:

Campo	Descrizione
type	Il tipo di risorsa. Utilizzare "remote" per un file registrato tramite add_file_resource. Per la variante "local" usata nelle distribuzioni self-hosted, fare riferimento a Gestire le risorse dei file.
resource_name	Il nome usato quando il file è stato registrato con add_file_resource.
file_name	La parte del nome del file del percorso del deposito oggetti della risorsa registrata (ad esempio, "zh_terms.txt" se la risorsa è stata registrata con path="file/zh_terms.txt").

Le parole aggiunte tramite extra_dict_file vengono unite al dizionario incorporato, quindi l'algoritmo di segmentazione di jieba le vede insieme alle voci esistenti. La presenza di un termine specifico come token a sé stante dipende dalla selezione del DAG ponderata per la probabilità di jieba: un termine personalizzato lungo, come 向量数据库, può essere suddiviso in 向量 + 数据库 se le voci più brevi hanno frequenze più alte nel dizionario incorporato.

Esempi

Prima di applicare la configurazione dell'analizzatore al proprio 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_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

Risultato atteso

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