Jieba

El tokenizador jieba procesa el texto chino descomponiéndolo en las palabras que lo componen.

Configuración

Milvus admite dos enfoques de configuración para el tokenizador jieba: una configuración simple y una configuración personalizada.

Configuración simple

Con la configuración simple, sólo necesita configurar el tokenizador en "jieba". Por ejemplo

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

Esta configuración simple es equivalente a la siguiente configuración personalizada:

# 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

Para obtener más información sobre los parámetros, consulte Configuración personalizada.

Configuración personalizada

Para un mayor control, puede proporcionar una configuración personalizada que le permita especificar un diccionario personalizado, seleccionar el modo de segmentación y activar o desactivar el modelo oculto de Markov (HMM). Por ejemplo

# 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

Parámetro	Descripción	Valor por defecto
type	El tipo de tokenizador. Está fijado en "jieba".	"jieba"
dict	Una lista de diccionarios que el analizador cargará como fuente de vocabulario. Opciones incorporadas: "_default_": Carga el diccionario de chino simplificado integrado en el motor. Para más detalles, consulte dict.txt. "_extend_default_": Carga todo lo que hay en "_default_" más un suplemento adicional de chino tradicional. Para más detalles, consulta dict.txt.big. También puedes combinar el diccionario incorporado con cualquier número de diccionarios personalizados. Ejemplo: ["_default_", "结巴分词器"].	["_default_"]
mode	El modo de segmentación. Valores posibles: "exact": Intenta segmentar la frase de la manera más precisa, por lo que es ideal para el análisis de texto. "search": Se basa en el modo exacto al dividir aún más las palabras largas para mejorar la recuperación, por lo que es adecuado para la tokenización en motores de búsqueda. Para más información, consulte el proyecto GitHub de Jieba.	"search"
hmm	Un indicador booleano que indica si se activa el modelo oculto de Markov (HMM) para la segmentación probabilística de palabras que no se encuentran en el diccionario.	true

Para cargar un vocabulario personalizado de gran tamaño desde un archivo externo en lugar de inluirlo a través de dict, consulte Configuración personalizada con un archivo de diccionario a continuación.

Después de definir analyzer_params, puede aplicarlos a un campo VARCHAR al definir un esquema de colección. Esto permite a Milvus procesar el texto de ese campo utilizando el analizador especificado para una tokenización y filtrado eficientes. Para más detalles, consulte Ejemplo de uso.

Configuración personalizada con un archivo de diccionarioCompatible with Milvus 3.0.x

Para vocabularios personalizados de gran tamaño (glosarios de dominios, terminología de productos o listas de nombres propios), almacene las palabras en un archivo y regístrelo como recurso de archivo remoto; a continuación, haga referencia a él desde el tokenizador mediante el parámetro extra_dict_file. El analizador carga estas palabras en su vocabulario sobre el diccionario incorporado.

El archivo es texto plano UTF-8 con un término por línea. Por ejemplo:

结巴分词器
向量数据库

Cargue el archivo en el almacén de objetos que su clúster Milvus está configurado para usar, luego regístrelo:

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

Haga referencia al recurso registrado en el tokenizador a través de 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

El parámetro extra_dict_file acepta un objeto con los siguientes campos:

Campo	Descripción
type	El tipo de recurso. Utilice "remote" para un archivo registrado a través de add_file_resource. Para la variante "local" utilizada en despliegues autoalojados, consulte Gestionar recursos de archivos.
resource_name	El nombre utilizado cuando se registró el archivo en add_file_resource.
file_name	La parte del nombre de archivo de la ruta del almacén de objetos del recurso registrado (por ejemplo, "zh_terms.txt" si el recurso se registró con path="file/zh_terms.txt").

Las palabras añadidas a través de extra_dict_file se fusionan con el diccionario incorporado, por lo que el algoritmo de segmentación de jieba las ve junto a las entradas existentes. El que un término específico aparezca como un token independiente depende de la selección DAG ponderada por probabilidad de jieba: un término personalizado largo como 向量数据库 puede dividirse en 向量 + 数据库 si esas entradas más cortas tienen frecuencias más altas en el diccionario incorporado.

Ejemplos

Antes de aplicar la configuración del analizador al esquema de su colección, verifique su comportamiento utilizando el método run_analyzer.

Configuración del analizador

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

Verificación mediante 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

Salida esperada

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