Gambaran Umum Penganalisis

Dalam pemrosesan teks, penganalisis adalah komponen penting yang mengubah teks mentah menjadi format yang terstruktur dan dapat dicari. Setiap penganalisis biasanya terdiri dari dua elemen inti: tokenizer dan filter. Bersama-sama, keduanya mengubah teks masukan menjadi token, menyempurnakan token ini, dan mempersiapkannya untuk pengindeksan dan pengambilan yang efisien.

Didukung oleh Tantivy, penganalisis di Milvus dikonfigurasikan selama pembuatan koleksi ketika Anda menambahkan bidang VARCHAR ke skema koleksi. Token yang dihasilkan oleh penganalisis dapat digunakan untuk membuat indeks untuk pencocokan teks atau diubah menjadi sematan jarang untuk pencarian teks lengkap. Untuk informasi lebih lanjut, lihat Pencocokan Teks atau Pencarian Teks Lengkap.

Anatomi sebuah penganalisis

Penganalisis di Milvus terdiri dari satu tokenizer dan nol atau lebih filter.

• Tokenizer: Tokenizer memecah teks masukan menjadi unit-unit diskrit yang disebut token. Token-token ini dapat berupa kata atau frasa, tergantung pada jenis tokenizer.

• Filter: Filter dapat diterapkan pada token untuk menyempurnakannya lebih lanjut, misalnya, dengan membuatnya menjadi huruf kecil atau menghapus kata-kata umum.

Alur kerja di bawah ini menunjukkan bagaimana penganalisis memproses teks.

Tipe-tipe penganalisis

Milvus menyediakan dua jenis penganalisis untuk memenuhi kebutuhan pemrosesan teks yang berbeda.

• Penganalisis bawaan: Ini adalah konfigurasi yang sudah ditentukan sebelumnya yang mencakup tugas pemrosesan teks umum dengan pengaturan minimal. Penganalisis bawaan ideal untuk pencarian tujuan umum, karena tidak memerlukan konfigurasi yang rumit.

• Penganalisis khusus: Untuk kebutuhan yang lebih canggih, penganalisis khusus memungkinkan Anda untuk menentukan konfigurasi Anda sendiri dengan menentukan tokenizer dan nol atau lebih filter. Tingkat kustomisasi ini sangat berguna untuk kasus penggunaan khusus yang membutuhkan kontrol yang tepat atas pemrosesan teks.

Penganalisis bawaan

Penganalisis bawaan di Milvus telah dikonfigurasi sebelumnya dengan tokenizer dan filter tertentu, sehingga Anda dapat langsung menggunakannya tanpa perlu mendefinisikan komponen-komponen ini sendiri. Setiap penganalisis bawaan berfungsi sebagai templat yang mencakup tokenizer dan filter yang telah ditetapkan sebelumnya, dengan parameter opsional untuk penyesuaian.

Sebagai contoh, untuk menggunakan penganalisis bawaan standard, cukup tentukan namanya standard sebagai type dan secara opsional menyertakan konfigurasi tambahan yang spesifik untuk jenis penganalisis ini, seperti stop_words.

analyzer_params = {
    "type": "standard", # Uses the standard built-in analyzer
    "stop_words": ["a", "an", "for"] # Defines a list of common words (stop words) to exclude from tokenization
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("type", "standard");
analyzerParams.put("stop_words", Arrays.asList("a", "an", "for"));

const analyzer_params = {
    "type": "standard", // Uses the standard built-in analyzer
    "stop_words": ["a", "an", "for"] // Defines a list of common words (stop words) to exclude from tokenization
};

export analyzerParams='{
       "type": "standard",
       "stop_words": ["a", "an", "for"]
    }'

Konfigurasi penganalisis bawaan standard di atas setara dengan menyiapkan penganalisis khusus dengan parameter berikut, di mana opsi tokenizer dan filter secara eksplisit didefinisikan untuk mencapai fungsionalitas yang sama:

analyzer_params = {
    "tokenizer": "standard",
    "filter": [
        "lowercase",
        {
            "type": "stop",
            "stop_words": ["a", "an", "for"]
        }
    ]
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Arrays.asList("lowercase",
                new HashMap<String, Object>() {{
                    put("type", "stop");
                    put("stop_words", Arrays.asList("a", "an", "for"));
                }}));

const analyzer_params = {
    "tokenizer": "standard",
    "filter": [
        "lowercase",
        {
            "type": "stop",
            "stop_words": ["a", "an", "for"]
        }
    ]
};

export analyzerParams='{
       "type": "standard",
       "filter":  [
       "lowercase",
       {
            "type": "stop",
            "stop_words": ["a", "an", "for"]
       }
   ]
}'

Milvus menawarkan penganalisis bawaan berikut ini, yang masing-masing dapat digunakan secara langsung dengan menentukan namanya sebagai parameter type.

• standard: Cocok untuk pemrosesan teks tujuan umum, menerapkan tokenisasi standar dan pemfilteran huruf kecil.

• english: Dioptimalkan untuk teks berbahasa Inggris, dengan dukungan untuk stop words dalam bahasa Inggris.

• chinese: Khusus untuk memproses teks bahasa Mandarin, termasuk tokenisasi yang diadaptasi untuk struktur bahasa Mandarin.

Penganalisis khusus

Untuk pemrosesan teks yang lebih canggih, penganalisis khusus di Milvus memungkinkan Anda untuk membuat pipeline penanganan teks yang disesuaikan dengan menentukan tokenizer dan filter. Pengaturan ini ideal untuk kasus penggunaan khusus yang memerlukan kontrol yang tepat.

Tokenizer

Tokenizer adalah komponen wajib untuk penganalisis khusus, yang memulai pipeline penganalisis dengan memecah teks input menjadi unit diskrit atau token. Tokenisasi mengikuti aturan khusus, seperti pemisahan dengan spasi atau tanda baca, tergantung pada jenis tokenizer. Proses ini memungkinkan penanganan yang lebih tepat dan independen untuk setiap kata atau frasa.

Sebagai contoh, tokenizer akan mengubah teks "Vector Database Built for Scale" menjadi token-token yang terpisah.

["Vector", "Database", "Built", "for", "Scale"]

Contoh menentukan tokenizer.

analyzer_params = {
    "tokenizer": "whitespace",
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "whitespace");

const analyzer_params = {
    "tokenizer": "whitespace",
};

export analyzerParams='{
       "type": "whitespace"
    }'

Filter

Filter adalah komponen opsional yang bekerja pada token yang dihasilkan oleh tokenizer, mengubah atau menyempurnakannya sesuai kebutuhan. Misalnya, setelah menerapkan filter lowercase pada istilah yang diberi token ["Vector", "Database", "Built", "for", "Scale"], hasilnya mungkin seperti ini.

["vector", "database", "built", "for", "scale"]

Filter dalam penganalisis khusus dapat berupa filter bawaan atau khusus, tergantung pada kebutuhan konfigurasi.

• Filter bawaan: Telah dikonfigurasi sebelumnya oleh Milvus, yang membutuhkan pengaturan minimal. Anda dapat menggunakan filter ini secara langsung dengan menentukan namanya. Filter di bawah ini adalah filter bawaan untuk penggunaan langsung.

  • lowercase: Mengonversi teks menjadi huruf kecil, memastikan pencocokan yang tidak peka huruf. Untuk detailnya, lihat Huruf Kecil.

  • asciifolding: Mengonversi karakter non-ASCII menjadi ekuivalen ASCII, menyederhanakan penanganan teks multibahasa. Untuk rinciannya, lihat ASCII folding (Pelipatan ASCII).

  • alphanumonly: Mempertahankan hanya karakter alfanumerik dengan menghapus karakter lainnya. Untuk rinciannya, lihat Hanya alfanumerik.

  • cnalphanumonly: Menghapus token yang berisi karakter apa pun selain karakter Cina, huruf Inggris, atau angka. Untuk detailnya, lihat Cnalphanumonly.

  • cncharonly: Menghapus token yang berisi karakter non-Cina. Untuk detailnya, lihat Cncharonly.

  Contoh penggunaan filter bawaan:

  Python JavaNode.jscURL

  analyzer_params = {
      "tokenizer": "standard", # Mandatory: Specifies tokenizer
      "filter": ["lowercase"], # Optional: Built-in filter that converts text to lowercase
  }
  

  Map<String, Object> analyzerParams = new HashMap<>();
  analyzerParams.put("tokenizer", "standard");
  analyzerParams.put("filter", Collections.singletonList("lowercase"));
  

  const analyzer_params = {
      "tokenizer": "standard", // Mandatory: Specifies tokenizer
      "filter": ["lowercase"], // Optional: Built-in filter that converts text to lowercase
  }
  

  export analyzerParams='{
     "type": "standard",
     "filter":  ["lowercase"]
  }'
  

• Filter khusus: Filter khusus memungkinkan konfigurasi khusus. Anda dapat menentukan filter khusus dengan memilih jenis filter yang valid (filter.type) dan menambahkan pengaturan khusus untuk setiap jenis filter. Contoh jenis filter yang mendukung kustomisasi.

  • stop: Menghapus kata-kata umum tertentu dengan menetapkan daftar kata henti (misalnya, "stop_words": ["of", "to"]). Untuk detailnya, lihat Berhenti.

  • length: Mengecualikan token berdasarkan kriteria panjang, seperti mengatur panjang token maksimum. Untuk detailnya, lihat Panjang.

  • stemmer: Mengurangi kata ke bentuk dasarnya untuk pencocokan yang lebih fleksibel. Untuk detailnya, lihat Stemmer.

  Contoh mengonfigurasi filter khusus:

  Python JavaNode.jscURL

  analyzer_params = {
      "tokenizer": "standard", # Mandatory: Specifies tokenizer
      "filter": [
          {
              "type": "stop", # Specifies 'stop' as the filter type
              "stop_words": ["of", "to"], # Customizes stop words for this filter type
          }
      ]
  }
  
  

  Map<String, Object> analyzerParams = new HashMap<>();
  analyzerParams.put("tokenizer", "standard");
  analyzerParams.put("filter",
      Collections.singletonList(new HashMap<String, Object>() {{
          put("type", "stop");
          put("stop_words", Arrays.asList("a", "an", "for"));
      }}));
  

  const analyzer_params = {
      "tokenizer": "standard", // Mandatory: Specifies tokenizer
      "filter": [
          {
              "type": "stop", // Specifies 'stop' as the filter type
              "stop_words": ["of", "to"], // Customizes stop words for this filter type
          }
      ]
  };
  

  export analyzerParams='{
      "type": "standard",
      "filter":  [
      {
              "type": "stop",
              "stop_words": ["a", "an", "for"]
      }
      ]
  }'
  

Contoh penggunaan

Dalam contoh ini, kita mendefinisikan skema koleksi dengan bidang vektor untuk penyematan dan dua bidang VARCHAR untuk kemampuan pemrosesan teks. Setiap bidang VARCHAR dikonfigurasikan dengan pengaturan penganalisisnya sendiri untuk menangani kebutuhan pemrosesan yang berbeda.

from pymilvus import MilvusClient, DataType

# Set up a Milvus client
client = MilvusClient(
    uri="http://localhost:19530"
)

# Create schema
schema = client.create_schema(auto_id=True, enable_dynamic_field=False)

# Add fields to schema

# Use a built-in analyzer
analyzer_params_built_in = {
    "type": "english"
}

# Add VARCHAR field `title_en`
schema.add_field(
    field_name='title_en', 
    datatype=DataType.VARCHAR, 
    max_length=1000, 
    enable_analyzer=True，
    analyzer_params=analyzer_params_built_in,
    enable_match=True, 
)

# Configure a custom analyzer
analyzer_params_custom = {
    "tokenizer": "standard",
    "filter": [
        "lowercase", # Built-in filter
        {
            "type": "length", # Custom filter
            "max": 40
        },
        {
            "type": "stop", # Custom filter
            "stop_words": ["of", "to"]
        }
    ]
}

# Add VARCHAR field `title`
schema.add_field(
    field_name='title', 
    datatype=DataType.VARCHAR, 
    max_length=1000, 
    enable_analyzer=True，
    analyzer_params=analyzer_params_custom,
    enable_match=True, 
)

# Add vector field
schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=3)
# Add primary field
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)

# Set up index params for vector field
index_params = client.prepare_index_params()
index_params.add_index(field_name="embedding", metric_type="COSINE", index_type="AUTOINDEX")

# Create collection with defined schema
client.create_collection(
    collection_name="YOUR_COLLECTION_NAME",
    schema=schema,
    index_params=index_params
)

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;

// Set up a Milvus client
ConnectConfig config = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build();
MilvusClientV2 client = new MilvusClientV2(config);

// Create schema
CreateCollectionReq.CollectionSchema schema = CreateCollectionReq.CollectionSchema.builder()
        .enableDynamicField(false)
        .build();

// Add fields to schema
// Use a built-in analyzer
Map<String, Object> analyzerParamsBuiltin = new HashMap<>();
analyzerParamsBuiltin.put("type", "english");
// Add VARCHAR field `title_en`
schema.addField(AddFieldReq.builder()
        .fieldName("title_en")
        .dataType(DataType.VarChar)
        .maxLength(1000)
        .enableAnalyzer(true)
        .analyzerParams(analyzerParamsBuiltin)
        .enableMatch(true)
        .build());

// Configure a custom analyzer
Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Arrays.asList("lowercase",
                new HashMap<String, Object>() {{
                    put("type", "length");
                    put("max", 40);
                }},
                new HashMap<String, Object>() {{
                    put("type", "stop");
                    put("stop_words", Arrays.asList("a", "an", "for"));
                }}
        )
);
schema.addField(AddFieldReq.builder()
        .fieldName("title")
        .dataType(DataType.VarChar)
        .maxLength(1000)
        .enableAnalyzer(true)
        .analyzerParams(analyzerParams)
        .enableMatch(true) // must enable this if you use TextMatch
        .build());

// Add vector field
schema.addField(AddFieldReq.builder()
        .fieldName("embedding")
        .dataType(DataType.FloatVector)
        .dimension(3)
        .build());
// Add primary field
schema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(true)
        .build());

// Set up index params for vector field
List<IndexParam> indexes = new ArrayList<>();
indexes.add(IndexParam.builder()
        .fieldName("embedding")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.COSINE)
        .build());

// Create collection with defined schema
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("YOUR_COLLECTION_NAME")
        .collectionSchema(schema)
        .indexParams(indexes)
        .build();
client.createCollection(requestCreate);

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

// Set up a Milvus client
const client = new MilvusClient("http://localhost:19530");
// Use a built-in analyzer for VARCHAR field `title_en`
const analyzerParamsBuiltIn = {
  type: "english",
};

// Configure a custom analyzer for VARCHAR field `title`
const analyzerParamsCustom = {
  tokenizer: "standard",
  filter: [
    "lowercase",
    {
      type: "length",
      max: 40,
    },
    {
      type: "stop",
      stop_words: ["of", "to"],
    },
  ],
};

// Create schema
const schema = {
  auto_id: true,
  fields: [
    {
      name: "id",
      type: DataType.INT64,
      is_primary: true,
    },
    {
      name: "title_en",
      data_type: DataType.VARCHAR,
      max_length: 1000,
      enable_analyzer: true,
      analyzer_params: analyzerParamsBuiltIn,
      enable_match: true,
    },
    {
      name: "title",
      data_type: DataType.VARCHAR,
      max_length: 1000,
      enable_analyzer: true,
      analyzer_params: analyzerParamsCustom,
      enable_match: true,
    },
    {
      name: "embedding",
      data_type: DataType.FLOAT_VECTOR,
      dim: 4,
    },
  ],
};

// Set up index params for vector field
const indexParams = [
  {
    name: "embedding",
    metric_type: "COSINE",
    index_type: "AUTOINDEX",
  },
];

// Create collection with defined schema
await client.createCollection({
  collection_name: "YOUR_COLLECTION_NAME",
  schema: schema,
  index_params: indexParams,
});

console.log("Collection created successfully!");

export schema='{
        "autoId": true,
        "enabledDynamicField": false,
        "fields": [
            {
                "fieldName": "id",
                "dataType": "Int64",
                "isPrimary": true
            },
            {
                "fieldName": "title_en",
                "dataType": "VarChar",
                "elementTypeParams": {
                    "max_length": 1000,
                    "enable_analyzer": true,
                    "enable_match": true,
                    "analyzer_params": {"type": "english"}
                }
            },
            {
                "fieldName": "title",
                "dataType": "VarChar",
                "elementTypeParams": {
                    "max_length": 1000,
                    "enable_analyzer": true,
                    "enable_match": true,
                    "analyzer_params": {
                        "tokenizer": "standard",
                        "filter":[
                            "lowercase",
                            {
                                "type":"length",
                                "max":40
                            },
                            {
                                "type":"stop",
                                "stop_words":["of","to"]
                            }
                        ]
                    }
                }
            },
            {
                "fieldName": "embedding",
                "dataType": "FloatVector",
                "elementTypeParams": {
                    "dim":3
                }
            }
        ]
    }'
    
export indexParams='[
        {
            "fieldName": "embedding",
            "metricType": "COSINE",
            "indexType": "AUTOINDEX"
        }
    ]'

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

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
    \"collectionName\": \"YOUR_COLLECTION_NAME\",
    \"schema\": $schema,
    \"indexParams\": $indexParams
}"