Jieba

Le tokenizer jieba traite le texte chinois en le décomposant en ses mots constitutifs.

Configuration

Milvus prend en charge deux approches de configuration pour le tokenizer jieba: une configuration simple et une configuration personnalisée.

Configuration simple

Avec la configuration simple, il suffit de définir le tokenizer sur "jieba". Par exemple :

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

Cette configuration simple est équivalente à la configuration personnalisée suivante :

# 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

Pour plus de détails sur les paramètres, voir Configuration personnalisée.

Configuration personnalisée

Pour plus de contrôle, vous pouvez fournir une configuration personnalisée qui vous permet de spécifier un dictionnaire personnalisé, de sélectionner le mode de segmentation et d'activer ou de désactiver le modèle de Markov caché (HMM). Par exemple :

# 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

Paramètre	Paramètre Description	Valeur par défaut
type	Le type de tokenizer. Cette valeur est fixée à "jieba".	"jieba"
dict	Une liste de dictionnaires que l'analyseur chargera comme source de vocabulaire. Options intégrées : "_default_": Charge le dictionnaire chinois simplifié intégré au moteur. Pour plus de détails, voir dict.txt. "_extend_default_": Charge tout ce qui se trouve à l'adresse "_default_", ainsi qu'un supplément en chinois traditionnel. Pour plus de détails, voir dict.txt.big. Vous pouvez également combiner le dictionnaire intégré avec un nombre quelconque de dictionnaires personnalisés. Exemple : ["_default_", "结巴分词器"].	["_default_"]
mode	Le mode de segmentation. Valeurs possibles : "exact": Tente de segmenter la phrase de la manière la plus précise, ce qui est idéal pour l'analyse de texte. "search": S'appuie sur le mode exact en décomposant davantage les mots longs afin d'améliorer le rappel, ce qui le rend adapté à la tokenisation des moteurs de recherche. Pour plus d'informations, consultez le projet Jieba sur GitHub.	"search"
hmm	Un drapeau booléen indiquant s'il faut activer le modèle de Markov caché (HMM) pour la segmentation probabiliste des mots non trouvés dans le dictionnaire.	true

Pour charger un grand vocabulaire personnalisé à partir d'un fichier externe au lieu de l'intégrer via dict, voir Configuration personnalisée avec un fichier de dictionnaire ci-dessous.

Après avoir défini analyzer_params, vous pouvez les appliquer à un champ VARCHAR lors de la définition d'un schéma de collecte. Cela permet à Milvus de traiter le texte de ce champ à l'aide de l'analyseur spécifié pour une tokenisation et un filtrage efficaces. Pour plus de détails, voir Exemple d'utilisation.

Configuration personnalisée avec un fichier de dictionnaireCompatible with Milvus 3.0.x

Pour les vocabulaires personnalisés volumineux - glossaires de domaines, terminologie de produits ou listes de noms propres -, stockez les mots dans un fichier et enregistrez le fichier en tant que ressource de fichier distante, puis faites-y référence à partir de l'analyseur de tokenisation via le paramètre extra_dict_file. L'analyseur charge ces mots dans son vocabulaire en plus du dictionnaire intégré.

Le fichier est un texte UTF-8 simple avec un terme par ligne. Par exemple :

结巴分词器
向量数据库

Téléchargez le fichier dans le magasin d'objets que votre cluster Milvus est configuré pour utiliser, puis enregistrez-le :

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

Référencer la ressource enregistrée dans le tokenizer via 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

Le paramètre extra_dict_file accepte un objet avec les champs suivants :

Champ	Description
type	Le type de ressource. Utilisez "remote" pour un fichier enregistré via add_file_resource. Pour la variante "local" utilisée dans les déploiements auto-hébergés, reportez-vous à la section Gérer les ressources de fichiers.
resource_name	Le nom utilisé lorsque le fichier a été enregistré sur add_file_resource.
file_name	La partie "nom de fichier" du chemin d'accès au magasin d'objets de la ressource enregistrée (par exemple, "zh_terms.txt" si la ressource a été enregistrée avec path="file/zh_terms.txt").

Les mots ajoutés via extra_dict_file sont fusionnés avec le dictionnaire intégré, de sorte que l'algorithme de segmentation de jieba les voit à côté des entrées existantes. L'apparition d'un terme spécifique en tant que jeton autonome dépend de la sélection DAG pondérée par les probabilités de jieba - un long terme personnalisé tel que 向量数据库 peut toujours être divisé en 向量 + 数据库 si ces entrées plus courtes ont des fréquences plus élevées dans le dictionnaire intégré.

Exemples

Avant d'appliquer la configuration de l'analyseur à votre schéma de collection, vérifiez son comportement en utilisant la méthode run_analyzer.

Configuration de l'analyseur

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

Vérification à l'aide de 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

Résultat attendu

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