Milvus
Zilliz
Bintang44.3KPesan DemoMulai
Beranda
  • Home
  • Docs

  • Panduan Pengguna

  • Bidang Skema & Data

  • Penganalisis

  • Penganalisis Multi-bahasa

Penganalisis Multi-bahasaCompatible with Milvus 2.5.11+

Ketika Milvus melakukan analisis teks, biasanya Milvus menggunakan satu penganalisis di seluruh bidang teks dalam koleksi. Jika penganalisis tersebut dioptimalkan untuk bahasa Inggris, maka ia akan kesulitan dengan aturan tokenisasi dan stemming yang sangat berbeda yang diperlukan oleh bahasa lain, seperti bahasa Mandarin, Spanyol, atau Prancis, yang menghasilkan tingkat penarikan yang lebih rendah. Misalnya, pencarian untuk kata Spanyol "teléfono" (yang berarti "telepon") akan menyulitkan penganalisis yang berfokus pada bahasa Inggris: ia mungkin menghilangkan aksen dan tidak menerapkan stemming khusus bahasa Spanyol, sehingga hasil yang relevan terlewatkan.

Penganalisis multibahasa mengatasi masalah ini dengan memungkinkan Anda mengonfigurasi beberapa penganalisis untuk bidang teks dalam satu koleksi. Dengan cara ini, Anda dapat menyimpan dokumen multibahasa dalam sebuah bidang teks, dan Milvus menganalisis teks menurut aturan bahasa yang sesuai untuk setiap dokumen.

Batasan

  • Fitur ini hanya bekerja dengan pengambilan teks berbasis BM25 dan vektor jarang. Untuk informasi lebih lanjut, lihat Pencarian Teks Lengkap.

  • Setiap dokumen dalam satu koleksi hanya dapat menggunakan satu penganalisis, yang ditentukan oleh nilai bidang pengenal bahasanya.

  • Kinerja dapat bervariasi, tergantung pada kompleksitas penganalisis dan ukuran data teks Anda.

Gambaran Umum

Diagram berikut ini menunjukkan alur kerja untuk mengonfigurasi dan menggunakan penganalisis multi-bahasa di Milvus:

Multi Language Analyzers Workflow Alur Kerja Penganalisis Multi Bahasa

  1. Mengonfigurasi Penganalisis Multi-bahasa:

    • Siapkan beberapa penganalisis khusus bahasa dengan menggunakan format: <analyzer_name>: <analyzer_config>, di mana setiap analyzer_config mengikuti konfigurasi analyzer_params standar seperti yang dijelaskan dalam Tinjauan Penganalisis.

    • Tentukan bidang pengenal khusus yang akan menentukan pemilihan penganalisis untuk setiap dokumen.

    • Konfigurasikan penganalisis default untuk menangani bahasa yang tidak dikenal.

  2. Membuat Koleksi:

    • Tentukan skema dengan bidang-bidang penting:

      • primary_key: Pengenal dokumen yang unik.

      • text_field: Menyimpan konten teks asli.

      • identifier_field: Menunjukkan penganalisis mana yang digunakan untuk setiap dokumen.

      • vector_field: Menyimpan sematan jarang yang akan dihasilkan oleh fungsi BM25.

    • Mengonfigurasi fungsi BM25 dan parameter pengindeksan.

  3. Menyisipkan Data dengan Pengenal Bahasa:

    • Menambahkan dokumen yang berisi teks dalam berbagai bahasa, di mana setiap dokumen menyertakan nilai pengenal yang menentukan penganalisis mana yang akan digunakan.

    • Milvus memilih penganalisis yang sesuai berdasarkan bidang pengenal, dan dokumen dengan pengenal yang tidak diketahui menggunakan penganalisis default.

  4. Mencari dengan Penganalisis Khusus Bahasa:

    • Sediakan teks kueri dengan nama penganalisis yang ditentukan, dan Milvus memproses kueri menggunakan penganalisis yang ditentukan.

    • Tokenisasi terjadi sesuai dengan aturan khusus bahasa, dan pencarian mengembalikan hasil yang sesuai dengan bahasa berdasarkan kemiripan.

Langkah 1: Mengonfigurasi multi_analyzer_params

multi_analyzer_params adalah objek JSON tunggal yang menentukan bagaimana Milvus memilih penganalisis yang sesuai untuk setiap entitas:

Python Java NodeJS Go cURL
multi_analyzer_params = {
  # Define language-specific analyzers
  # Each analyzer follows this format: <analyzer_name>: <analyzer_params>
  "analyzers": {
    "english": {"type": "english"},          # English-optimized analyzer
    "chinese": {"type": "chinese"},          # Chinese-optimized analyzer
    "default": {"tokenizer": "icu"}          # Required fallback analyzer
  },
  "by_field": "language",                    # Field determining analyzer selection
  "alias": {
    "cn": "chinese",                         # Use "cn" as shorthand for Chinese
    "en": "english"                          # Use "en" as shorthand for English
  }
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("analyzers", new HashMap<String, Object>() {{
    put("english", new HashMap<String, Object>() {{
        put("type", "english");
    }});
    put("chinese", new HashMap<String, Object>() {{
        put("type", "chinese");
    }});
    put("default", new HashMap<String, Object>() {{
        put("tokenizer", "icu");
    }});
}});
analyzerParams.put("by_field", "language");
analyzerParams.put("alias", new HashMap<String, Object>() {{
    put("cn", "chinese");
    put("en", "english");
}});

const multi_analyzer_params = {
  // Define language-specific analyzers
  // Each analyzer follows this format: <analyzer_name>: <analyzer_params>
  "analyzers": {
    "english": {"type": "english"},          # English-optimized analyzer
    "chinese": {"type": "chinese"},          # Chinese-optimized analyzer
    "default": {"tokenizer": "icu"}          # Required fallback analyzer
  },
  "by_field": "language",                    # Field determining analyzer selection
  "alias": {
    "cn": "chinese",                         # Use "cn" as shorthand for Chinese
    "en": "english"                          # Use "en" as shorthand for English
  }
}

multiAnalyzerParams := map[string]any{
    "analyzers": map[string]any{
        "english": map[string]string{"type": "english"},
        "chinese": map[string]string{"type": "chinese"},
        "default": map[string]string{"tokenizer": "icu"},
    },
    "by_field": "language",
    "alias": map[string]string{
        "cn": "chinese",
        "en": "english",
    },
}

# restful
export multi_analyzer_params='{
  "analyzers": {
    "english": {
      "type": "english"
    },
    "chinese": {
      "type": "chinese"
    },
    "default": {
      "tokenizer": "icu"
    }
  },
  "by_field": "language",
  "alias": {
    "cn": "chinese",
    "en": "english"
  }
}'

Parameter

Diperlukan?

Deskripsi

Aturan

analyzers

Ya

Mencantumkan setiap penganalisis khusus bahasa yang dapat digunakan Milvus untuk memproses teks. Setiap penganalisis di analyzers mengikuti format berikut: <analyzer_name>: <analyzer_params>.
  • Tentukan setiap penganalisis dengan sintaks standar analyzer_params (lihat Ikhtisar Penganalisis).
  • Tambahkan entri yang kuncinya adalah default; Milvus akan kembali ke penganalisis ini setiap kali nilai yang disimpan di by_field tidak cocok dengan nama penganalisis lainnya.

by_field

Ya

Nama bidang yang menyimpan, untuk setiap dokumen, bahasa (yaitu, nama penganalisis) yang harus diterapkan Milvus.

  • Harus berupa bidang VARCHAR yang didefinisikan dalam koleksi.

  • Nilai di setiap baris harus sama persis dengan salah satu nama penganalisis (atau alias) yang terdaftar di analyzers.

  • Jika nilai suatu baris tidak ada atau tidak ditemukan, Milvus akan secara otomatis menggunakan penganalisis default.

alias

Tidak

Membuat pintasan atau nama alternatif untuk penganalisis Anda, membuatnya lebih mudah untuk dirujuk dalam kode Anda. Setiap penganalisis dapat memiliki satu atau lebih alias.

Setiap alias harus dipetakan ke kunci penganalisis yang ada.

Langkah 2: Membuat koleksi

Membuat koleksi dengan dukungan multi-bahasa memerlukan konfigurasi bidang dan indeks tertentu:

Menambahkan bidang

Pada langkah ini, tentukan skema koleksi dengan empat bidang penting:

  • Bidang Kunci Utama (id): Pengenal unik untuk setiap entitas dalam koleksi. Dengan mengatur auto_id=True, Milvus dapat secara otomatis menghasilkan ID ini.

  • Bidang Indikator Bahasa (language): Bidang VARIABEL ini sesuai dengan by_field yang ditentukan dalam multi_analyzer_params Anda. Field ini menyimpan pengenal bahasa untuk setiap entitas, yang memberi tahu Milvus penganalisis mana yang akan digunakan.

  • Bidang Konten Teks (text): Bidang VARCHAR ini menyimpan data teks aktual yang ingin Anda analisis dan cari. Pengaturan enable_analyzer=True sangat penting karena mengaktifkan kemampuan analisis teks untuk bidang ini. Konfigurasi multi_analyzer_params dilampirkan secara langsung ke bidang ini, membangun hubungan antara data teks Anda dan penganalisis khusus bahasa.

  • Bidang Vektor (sparse): Bidang ini akan menyimpan vektor-vektor jarang yang dihasilkan oleh fungsi BM25. Vektor-vektor ini mewakili bentuk data teks Anda yang dapat dianalisis dan merupakan apa yang sebenarnya dicari oleh Milvus.

Python Java NodeJS Go cURL
# Import required modules
from pymilvus import MilvusClient, DataType, Function, FunctionType

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

# Initialize a new schema
schema = client.create_schema()

# Step 2.1: Add a primary key field for unique document identification
schema.add_field(
    field_name="id",                  # Field name
    datatype=DataType.INT64,          # Integer data type
    is_primary=True,                  # Designate as primary key
    auto_id=True                      # Auto-generate IDs (recommended)
)

# Step 2.2: Add language identifier field
# This MUST match the "by_field" value in language_analyzer_config
schema.add_field(
    field_name="language",       # Field name
    datatype=DataType.VARCHAR,   # String data type
    max_length=255               # Maximum length (adjust as needed)
)

# Step 2.3: Add text content field with multi-language analysis capability
schema.add_field(
    field_name="text",                           # Field name
    datatype=DataType.VARCHAR,                   # String data type
    max_length=8192,                             # Maximum length (adjust based on expected text size)
    enable_analyzer=True,                        # Enable text analysis
    multi_analyzer_params=multi_analyzer_params  # Connect with our language analyzers
)

# Step 2.4: Add sparse vector field to store the BM25 output
schema.add_field(
    field_name="sparse",                   # Field name
    datatype=DataType.SPARSE_FLOAT_VECTOR  # Sparse vector data type
)

import com.google.gson.JsonObject;
import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import io.milvus.v2.service.collection.request.DropCollectionReq;
import io.milvus.v2.service.utility.request.FlushReq;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.EmbeddedText;
import io.milvus.v2.service.vector.response.SearchResp;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());
        
CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
        .build();
        
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(true)
        .build());
        
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("language")
        .dataType(DataType.VarChar)
        .maxLength(255)
        .build());

collectionSchema.addField(AddFieldReq.builder()
        .fieldName("text")
        .dataType(DataType.VarChar)
        .maxLength(8192)
        .enableAnalyzer(true)
        .multiAnalyzerParams(analyzerParams)
        .build());
        
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("sparse")
        .dataType(DataType.SparseFloatVector)
        .build());

import { MilvusClient, DataType, FunctionType } from "@zilliz/milvus2-sdk-node";

// Initialize client
const client = new MilvusClient({
  address: "http://localhost:19530",
});

// Initialize schema array
const schema = [
  {
    name: "id",
    data_type: DataType.Int64,
    is_primary_key: true,
    auto_id: true,
  },
  {
    name: "language",
    data_type: DataType.VarChar,
    max_length: 255,
  },
  {
    name: "text",
    data_type: DataType.VarChar,
    max_length: 8192,
    enable_analyzer: true,
    analyzer_params: multi_analyzer_params,
  },
  {
    name: "sparse",
    data_type: DataType.SparseFloatVector,
  },
];


import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/index"
    "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
}

schema := entity.NewSchema()

schema.WithField(entity.NewField().
    WithName("id").
    WithDataType(entity.FieldTypeInt64).
    WithIsPrimaryKey(true).
    WithIsAutoID(true),
).WithField(entity.NewField().
    WithName("language").
    WithDataType(entity.FieldTypeVarChar).
    WithMaxLength(255),
).WithField(entity.NewField().
    WithName("text").
    WithDataType(entity.FieldTypeVarChar).
    WithMaxLength(8192).
    WithEnableAnalyzer(true).
    WithMultiAnalyzerParams(multiAnalyzerParams),
).WithField(entity.NewField().
    WithName("sparse").
    WithDataType(entity.FieldTypeSparseVector),
)

# restful
export TOKEN="root:Milvus"
export CLUSTER_ENDPOINT="http://localhost:19530"

export idField='{
  "fieldName": "id",
  "dataType": "Int64",
  "isPrimary": true,
  "autoID": true
}'

export languageField='{
  "fieldName": "language",
  "dataType": "VarChar",
  "elementTypeParams": {
    "max_length": 255
  }
}'

export textField='{
  "fieldName": "text",
  "dataType": "VarChar",
  "elementTypeParams": {
    "max_length": 8192,
    "enable_analyzer": true，
    "multiAnalyzerParam": '"$multi_analyzer_params"'
  },
}'

export sparseField='{
  "fieldName": "sparse",
  "dataType": "SparseFloatVector"
}'

Mendefinisikan fungsi BM25

Definisikan fungsi BM25 untuk menghasilkan representasi vektor yang jarang dari data teks mentah Anda:

Python Java NodeJS Go cURL
# Create the BM25 function
bm25_function = Function(
    name="text_to_vector",            # Descriptive function name
    function_type=FunctionType.BM25,  # Use BM25 algorithm
    input_field_names=["text"],       # Process text from this field
    output_field_names=["sparse"]     # Store vectors in this field
)

# Add the function to our schema
schema.add_function(bm25_function)

CreateCollectionReq.Function function = CreateCollectionReq.Function.builder()
        .functionType(FunctionType.BM25)
        .name("text_to_vector")
        .inputFieldNames(Collections.singletonList("text"))
        .outputFieldNames(Collections.singletonList("sparse"))
        .build();
collectionSchema.addFunction(function);

const functions = [
  {
    name: "text_bm25_emb",
    description: "bm25 function",
    type: FunctionType.BM25,
    input_field_names: ["text"],
    output_field_names: ["sparse"],
    params: {},
  },
];

function := entity.NewFunction()
schema.WithFunction(function.WithName("text_to_vector").
    WithType(entity.FunctionTypeBM25).
    WithInputFields("text").
    WithOutputFields("sparse"))

# restful
export function='{
  "name": "text_to_vector",
  "type": "BM25",
  "inputFieldNames": ["text"],
  "outputFieldNames": ["sparse"]
}'

export schema="{
  \"autoID\": true,
  \"fields\": [
    $idField,
    $languageField,
    $textField,
    $sparseField
  ],
  \"functions\": [
    $function
  ]
}"

Fungsi ini secara otomatis menerapkan penganalisis yang sesuai untuk setiap entri teks berdasarkan pengenal bahasanya. Untuk informasi lebih lanjut tentang pengambilan teks berbasis BM25, lihat Pencarian Teks Lengkap.

Mengonfigurasi parameter indeks

Untuk memungkinkan pencarian yang efisien, buat indeks pada bidang vektor yang jarang:

Python Java NodeJS Go cURL
# Configure index parameters
index_params = client.prepare_index_params()

# Add index for sparse vector field
index_params.add_index(
    field_name="sparse",        # Field to index (our vector field)
    index_type="AUTOINDEX",     # Let Milvus choose optimal index type
    metric_type="BM25"          # Must be BM25 for this feature
)

List<IndexParam> indexes = new ArrayList<>();
indexes.add(IndexParam.builder()
        .fieldName("sparse")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.BM25)
        .build());

const index_params = [{
    field_name: "sparse",
    index_type: "AUTOINDEX",
    metric_type: "BM25"
}];

idx := index.NewAutoIndex(index.MetricType(entity.BM25))
indexOption := milvusclient.NewCreateIndexOption("multilingual_documents", "sparse", idx)

# restful
export IndexParams='[
  {
    "fieldName": "sparse",
    "indexType": "AUTOINDEX",
    "metricType": "BM25",
    "params": {}
  }
]'

Indeks meningkatkan kinerja pencarian dengan mengatur vektor yang jarang untuk penghitungan kemiripan BM25 yang efisien.

Membuat koleksi

Langkah pembuatan terakhir ini menyatukan semua konfigurasi Anda sebelumnya:

  • collection_name="multilang_demo" menamai koleksi Anda untuk referensi di masa mendatang.

  • schema=schema menerapkan struktur dan fungsi bidang yang telah Anda tetapkan.

  • index_params=index_params menerapkan strategi pengindeksan untuk pencarian yang efisien.

Python Java NodeJS Go cURL
# Create collection
COLLECTION_NAME = "multilingual_documents"

# Check if collection already exists
if client.has_collection(COLLECTION_NAME):
    client.drop_collection(COLLECTION_NAME)  # Remove it for this example
    print(f"Dropped existing collection: {COLLECTION_NAME}")

# Create the collection
client.create_collection(
    collection_name=COLLECTION_NAME,       # Collection name
    schema=schema,                         # Our multilingual schema
    index_params=index_params              # Our search index configuration
)

client.dropCollection(DropCollectionReq.builder()
        .collectionName("multilingual_documents")
        .build());
        
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("multilingual_documents")
        .collectionSchema(collectionSchema)
        .indexParams(indexes)
        .build();
client.createCollection(requestCreate);

const COLLECTION_NAME = "multilingual_documents";

// Create the collection
await client.createCollection({
  collection_name: COLLECTION_NAME,
  schema: schema,
  index_params: index_params,
  functions: functions
});


err = client.CreateCollection(ctx,
    milvusclient.NewCreateCollectionOption("multilingual_documents", schema).
        WithIndexOptions(indexOption))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

# restful
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data "{
  \"collectionName\": \"multilingual_documents\",
  \"schema\": $schema,
  \"indexParams\": $IndexParams
}"

Pada titik ini, Milvus membuat koleksi kosong dengan dukungan penganalisis multi-bahasa, yang siap menerima data.

Langkah 3: Memasukkan data contoh

Ketika menambahkan dokumen ke koleksi multi-bahasa Anda, setiap dokumen harus menyertakan konten teks dan pengenal bahasa:

Python Java NodeJS Go cURL
# Prepare multilingual documents
documents = [
    # English documents
    {
        "text": "Artificial intelligence is transforming technology",
        "language": "english",  # Using full language name
    },
    {
        "text": "Machine learning models require large datasets",
        "language": "en",  # Using our defined alias
    },
    # Chinese documents
    {
        "text": "人工智能正在改变技术领域",
        "language": "chinese",  # Using full language name
    },
    {
        "text": "机器学习模型需要大型数据集",
        "language": "cn",  # Using our defined alias
    },
]

# Insert the documents
result = client.insert(COLLECTION_NAME, documents)

# Print results
inserted = result["insert_count"]            
print(f"Successfully inserted {inserted} documents")
print("Documents by language: 2 English, 2 Chinese")

# Expected output:
# Successfully inserted 4 documents
# Documents by language: 2 English, 2 Chinese

List<String> texts = Arrays.asList(
        "Artificial intelligence is transforming technology",
        "Machine learning models require large datasets",
        "人工智能正在改变技术领域",
        "机器学习模型需要大型数据集"
);
List<String> languages = Arrays.asList(
        "english", "en", "chinese", "cn"
);

List<JsonObject> rows = new ArrayList<>();
for (int i = 0; i < texts.size(); i++) {
    JsonObject row = new JsonObject();
    row.addProperty("text", texts.get(i));
    row.addProperty("language", languages.get(i));
    rows.add(row);
}
client.insert(InsertReq.builder()
        .collectionName("multilingual_documents")
        .data(rows)
        .build());

// Prepare multilingual documents
const documents = [
  // English documents
  {
    text: "Artificial intelligence is transforming technology",
    language: "english",
  },
  {
    text: "Machine learning models require large datasets",
    language: "en",
  },
  // Chinese documents
  {
    text: "人工智能正在改变技术领域",
    language: "chinese",
  },
  {
    text: "机器学习模型需要大型数据集",
    language: "cn",
  },
];

// Insert the documents
const result = await client.insert({
  collection_name: COLLECTION_NAME,
  data: documents,
});

// Print results
const inserted = result.insert_count;
console.log(`Successfully inserted ${inserted} documents`);
console.log("Documents by language: 2 English, 2 Chinese");

// Expected output:
// Successfully inserted 4 documents
// Documents by language: 2 English, 2 Chinese


column1 := column.NewColumnVarChar("text",
    []string{
        "Artificial intelligence is transforming technology",
        "Machine learning models require large datasets",
        "人工智能正在改变技术领域",
        "机器学习模型需要大型数据集",
    })
column2 := column.NewColumnVarChar("language",
    []string{"english", "en", "chinese", "cn"})

_, err = client.Insert(ctx, milvusclient.NewColumnBasedInsertOption("multilingual_documents").
    WithColumns(column1, column2),
)
if err != nil {
    fmt.Println(err.Error())
    // handle err
}

# restful
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data '{
  "collectionName": "multilingual_documents",
  "data": [
    {
      "text": "Artificial intelligence is transforming technology",
      "language": "english"
    },
    {
      "text": "Machine learning models require large datasets",
      "language": "en"
    },
    {
      "text": "人工智能正在改变技术领域",
      "language": "chinese"
    },
    {
      "text": "机器学习模型需要大型数据集",
      "language": "cn"
    }
  ]
}'

Selama penyisipan, Milvus:

  1. Membaca bidang language setiap dokumen

  2. Menerapkan penganalisis yang sesuai ke bidang text

  3. Menghasilkan representasi vektor jarang melalui fungsi BM25

  4. Menyimpan teks asli dan vektor jarang yang dihasilkan

Anda tidak perlu menyediakan vektor jarang secara langsung; fungsi BM25 menghasilkannya secara otomatis berdasarkan teks Anda dan penganalisis yang ditentukan.

Langkah 4: Lakukan operasi pencarian

Gunakan penganalisis bahasa Inggris

Ketika mencari dengan penganalisis multi-bahasa, search_params berisi konfigurasi penting:

  • metric_type="BM25" harus sesuai dengan konfigurasi indeks Anda.

  • analyzer_name="english" menentukan penganalisis mana yang akan diterapkan pada teks kueri Anda. Ini tidak bergantung pada penganalisis yang digunakan pada dokumen yang disimpan.

  • params={"drop_ratio_search": "0"} mengontrol perilaku khusus BM25; di sini, ia mempertahankan semua istilah dalam pencarian. Untuk informasi lebih lanjut, lihat Vektor Jarang.

Python Java NodeJS Go cURL
search_params = {
    "metric_type": "BM25",            # Must match index configuration
    "analyzer_name": "english",  # Analyzer that matches the query language
    "drop_ratio_search": "0",     # Keep all terms in search (tweak as needed)
}

# Execute the search
english_results = client.search(
    collection_name=COLLECTION_NAME,  # Collection to search
    data=["artificial intelligence"],                # Query text
    anns_field="sparse",              # Field to search against
    search_params=search_params,      # Search configuration
    limit=3,                      # Max results to return
    output_fields=["text", "language"],  # Fields to include in the output
    consistency_level="Bounded",       # Data‑consistency guarantee
)

# Display English search results
print("\n=== English Search Results ===")
for i, hit in enumerate(english_results[0]):
    print(f"{i+1}. [{hit.score:.4f}] {hit.entity.get('text')} "
          f"(Language: {hit.entity.get('language')})")

# Expected output:
# === English Search Results ===
# 1. [2.7881] Artificial intelligence is transforming technology (Language: english)

Map<String,Object> searchParams = new HashMap<>();
searchParams.put("metric_type", "BM25");
searchParams.put("analyzer_name", "english");
searchParams.put("drop_ratio_search", 0);
SearchResp searchResp = client.search(SearchReq.builder()
        .collectionName("multilingual_documents")
        .data(Collections.singletonList(new EmbeddedText("artificial intelligence")))
        .annsField("sparse")
        .topK(3)
        .searchParams(searchParams)
        .outputFields(Arrays.asList("text", "language"))
        .build());

System.out.println("\n=== English Search Results ===");
List<List<SearchResp.SearchResult>> searchResults = searchResp.getSearchResults();
for (List<SearchResp.SearchResult> results : searchResults) {
    for (SearchResp.SearchResult result : results) {
        System.out.printf("Score: %f, %s\n", result.getScore(), result.getEntity().toString());
    }
}

// Execute the search
const english_results = await client.search({
  collection_name: COLLECTION_NAME,
  data: ["artificial intelligence"],
  anns_field: "sparse",
  params: {
    metric_type: "BM25",
    analyzer_name: "english",
    drop_ratio_search: "0",
  },
  limit: 3,
  output_fields: ["text", "language"],
  consistency_level: "Bounded",
});

// Display English search results
console.log("\n=== English Search Results ===");
english_results.results.forEach((hit, i) => {
  console.log(
    `${i + 1}. [${hit.score.toFixed(4)}] ${hit.entity.text} ` +
      `(Language: ${hit.entity.language})`
  );
});


annSearchParams := index.NewCustomAnnParam()
annSearchParams.WithExtraParam("metric_type", "BM25")
annSearchParams.WithExtraParam("analyzer_name", "english")
annSearchParams.WithExtraParam("drop_ratio_search", 0)

resultSets, err := client.Search(ctx, milvusclient.NewSearchOption(
    "multilingual_documents", // collectionName
    3,                        // limit
    []entity.Vector{entity.Text("artificial intelligence")},
).WithANNSField("sparse").
    WithAnnParam(annSearchParams).
    WithOutputFields("text", "language"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

for _, resultSet := range resultSets {
    for i := 0; i < len(resultSet.Scores); i++ {
        text, _ := resultSet.GetColumn("text").GetAsString(i)
        lang, _ := resultSet.GetColumn("language").GetAsString(i)
        fmt.Println("Score: ", resultSet.Scores[i], "Text: ", text, "Language:", lang)
    }
}

# restful
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data '{
  "collectionName": "multilingual_documents",
  "data": ["artificial intelligence"],
  "annsField": "sparse",
  "limit": 3,
  "searchParams": {
    "metric_type": "BM25",
    "analyzer_name": "english",
    "drop_ratio_search": "0"  
  },
  "outputFields": ["text", "language"],
  "consistencyLevel": "Bounded"
}'

Gunakan penganalisis bahasa Mandarin

Contoh ini mendemonstrasikan peralihan ke penganalisis bahasa Mandarin (menggunakan alias "cn") untuk teks kueri yang berbeda. Semua parameter lainnya tetap sama, tetapi sekarang teks kueri diproses menggunakan aturan tokenisasi khusus bahasa Mandarin.

Python Java NodeJS Go cURL
search_params["analyzer_name"] = "cn"

chinese_results = client.search(
    collection_name=COLLECTION_NAME,  # Collection to search
    data=["人工智能"],                # Query text
    anns_field="sparse",              # Field to search against
    search_params=search_params,      # Search configuration
    limit=3,                      # Max results to return
    output_fields=["text", "language"],  # Fields to include in the output
    consistency_level="Bounded",       # Data‑consistency guarantee
)

# Display Chinese search results
print("\n=== Chinese Search Results ===")
for i, hit in enumerate(chinese_results[0]):
    print(f"{i+1}. [{hit.score:.4f}] {hit.entity.get('text')} "
          f"(Language: {hit.entity.get('language')})")

# Expected output:
# === Chinese Search Results ===
# 1. [3.3814] 人工智能正在改变技术领域 (Language: chinese)

searchParams.put("analyzer_name", "cn");
searchResp = client.search(SearchReq.builder()
        .collectionName("multilingual_documents")
        .data(Collections.singletonList(new EmbeddedText("人工智能")))
        .annsField("sparse")
        .topK(3)
        .searchParams(searchParams)
        .outputFields(Arrays.asList("text", "language"))
        .build());

System.out.println("\n=== Chinese Search Results ===");
searchResults = searchResp.getSearchResults();
for (List<SearchResp.SearchResult> results : searchResults) {
    for (SearchResp.SearchResult result : results) {
        System.out.printf("Score: %f, %s\n", result.getScore(), result.getEntity().toString());
    }
}

// Execute the search
const cn_results = await client.search({
  collection_name: COLLECTION_NAME,
  data: ["人工智能"],
  anns_field: "sparse",
  params: {
    metric_type: "BM25",
    analyzer_name: "cn",
    drop_ratio_search: "0",
  },
  limit: 3,
  output_fields: ["text", "language"],
  consistency_level: "Bounded",
});

// Display Chinese search results
console.log("\n=== Chinese Search Results ===");
cn_results.results.forEach((hit, i) => {
  console.log(
    `${i + 1}. [${hit.score.toFixed(4)}] ${hit.entity.text} ` +
      `(Language: ${hit.entity.language})`
  );
});


annSearchParams.WithExtraParam("analyzer_name", "cn")

resultSets, err = client.Search(ctx, milvusclient.NewSearchOption(
    "multilingual_documents", // collectionName
    3,                        // limit
    []entity.Vector{entity.Text("人工智能")},
).WithANNSField("sparse").
    WithAnnParam(annSearchParams).
    WithOutputFields("text", "language"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

for _, resultSet := range resultSets {
    for i := 0; i < len(resultSet.Scores); i++ {
        text, _ := resultSet.GetColumn("text").GetAsString(i)
        lang, _ := resultSet.GetColumn("language").GetAsString(i)
        fmt.Println("Score: ", resultSet.Scores[i], "Text: ", text, "Language:", lang)
    }
}


# restful
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data '{
  "collectionName": "multilingual_documents",
  "data": ["人工智能"],
  "annsField": "sparse",
  "limit": 3,
  "searchParams": {
    "analyzer_name": "cn"
  },
  "outputFields": ["text", "language"],
  "consistencyLevel": "Bounded"
}'
Daftar isi

Coba Milvus yang Dikelola secara Gratis

Zilliz Cloud bebas masalah, didukung oleh Milvus dan 10x lebih cepat.

Mulai
Umpan balik

Apakah halaman ini bermanfaat?