Lindera

Tokenizer lindera melakukan analisis morfologi berbasis kamus. Tokenizer ini dirancang untuk bahasa Jepang dan Korea di mana kata-kata tidak dipisahkan oleh spasi dan penanda tata bahasa (partikel) melekat langsung pada kata.

Untuk teks bahasa Mandarin: Meskipun lindera mendukung bahasa Mandarin melalui kamus cc-cedict, kami menyarankan untuk menggunakan tokenizer jieba tokenizer sebagai gantinya. Jieba dirancang khusus untuk segmentasi kata dalam bahasa Mandarin dan memberikan hasil yang lebih baik.

Gambaran Umum

Bahasa Jepang dan Korea adalah bahasa aglutinatif: penanda tata bahasa yang disebut partikel melekat langsung pada kata benda, membentuk banyak kombinasi. Sebagai contoh:

Bahasa

Kata dasar

+ Partikel

= Bentuk gabungan

Arti

Bahasa Korea

서울 (Seoul)

에서

서울에서

di Seoul

Bahasa Jepang

東京 (Tokyo)

東京に

ke Tokyo

Tokenizer lindera:

  1. Memilahteks menjadi morfem individual (kata dan partikel)

  2. Menandai setiap token dengan informasi part-of-speech (POS) dari kamus

  3. Menerapkan filter untuk menghapus token yang tidak diinginkan (misalnya, partikel, tanda baca)

Proses dua tahap ini - segmentasi diikuti dengan pemfilteran berbasis POS - memungkinkan kontrol yang tepat atas token mana yang diindeks untuk pencarian.

Prasyarat

Pengguna Milvus 2.6+: Anda dapat melewati bagian ini. Semua kamus sudah dikompilasi sebelumnya dan disertakan dalam rilis resmi.

Untuk Milvus 2.5.x, Anda perlu mengkompilasi Milvus dengan kamus tertentu yang diaktifkan. Semua kamus harus disertakan secara eksplisit pada saat kompilasi.

Untuk mengaktifkan kamus tertentu, sertakan kamus tersebut pada perintah kompilasi:

make milvus TANTIVY_FEATURES=lindera-ipadic,lindera-ko-dic

Daftar lengkap kamus yang tersedia:

Kamus

Bahasa

Deskripsi

lindera-ko-dic

Bahasa Korea

Kamus morfologi bahasa Korea(MeCab Ko-dic)

lindera-ipadic

Bahasa Jepang

Kamus morfologi standar(MeCab IPADIC)

lindera-ipadic-neologd

Bahasa Jepang

Kamus yang diperluas dengan kata-kata baru dan kata benda yang tepat(IPADIC NEologd)

lindera-unidic

Bahasa Jepang

Kamus standar akademis(UniDic)

lindera-cc-cedict

Bahasa Mandarin

Kamus bahasa Mandarin-Inggris yang dikelola komunitas(CC-CEDICT)

Misalnya, untuk mengaktifkan semua kamus:

make milvus TANTIVY_FEATURES=lindera-ipadic,lindera-ipadic-neologd,lindera-unidic,lindera-ko-dic,lindera-cc-cedict

Konfigurasi

Untuk mengonfigurasi penganalisis menggunakan tokenizer lindera, setel tokenizer.type ke lindera, pilih kamus dengan dict_kind, dan secara opsional terapkan filter.

analyzer_params = {
    "tokenizer": {
        "type": "lindera",
        "dict_kind": "ko-dic",
        "filter": [
            {
                "kind": "korean_stop_tags",
                "tags": ["SP", "SSC", "SSO", "SC", "SE", "SF", "JKS", "JKC", "JKG", "JKO", "JKB", "JKV", "JKQ", "JX", "JC", "UNK", "EP", "ETM"]
            }
        ]
    }
}
Map<String, Object> analyzerParams = new HashMap<>();                                 
  analyzerParams.put("tokenizer", new HashMap<String, Object>() {{
      put("type", "lindera");                                                           
      put("dict_kind", "ko-dic");                                 
      put("filter", Arrays.asList(
          new HashMap<String, Object>() {{
              put("kind", "korean_stop_tags");
              put("tags", Arrays.asList(
                  "SP", "SSC", "SSO", "SC", "SE", "SF",
                  "JKS", "JKC", "JKG", "JKO", "JKB", "JKV", "JKQ",
                  "JX", "JC", "UNK", "EP", "ETM"
              ));
          }}
      ));
  }});
analyzerParams := map[string]interface{}{                                             
      "tokenizer": map[string]interface{}{     
          "type":      "lindera",                                                       
          "dict_kind": "ko-dic",                                  
          "filter": []interface{}{                                                      
              map[string]interface{}{                             
                  "kind": "korean_stop_tags",
                  "tags": []string{
                      "SP", "SSC", "SSO", "SC", "SE", "SF",
                      "JKS", "JKC", "JKG", "JKO", "JKB", "JKV", "JKQ",
                      "JX", "JC", "UNK", "EP", "ETM",
                  },
              },
          },
      },
  }
const analyzer_params = {
    "tokenizer": {
        "type": "lindera",
        "dict_kind": "ko-dic",
        "filter": [
            {
                "kind": "korean_stop_tags",
                "tags": ["SP", "SSC", "SSO", "SC", "SE", "SF", "JKS", "JKC", "JKG", "JKO", "JKB", "JKV", "JKQ", "JX", "JC", "UNK", "EP", "ETM"]
            }
        ]
    }
};
# restful

Parameter

Deskripsi

type

Jenis tokenizer. Ini ditetapkan ke "lindera".

dict_kind

Kamus yang digunakan untuk mendefinisikan kosakata. Nilai yang mungkin:

  • ko-dic: Bahasa Korea - Kamus morfologi bahasa Korea(MeCab Ko-dic)

  • ipadic: Bahasa Jepang - Kamus morfologi standar(MeCab IPADIC)

  • ipadic-neologd: Bahasa Jepang dengan kamus neologisme (diperluas) - Mencakup kata-kata baru dan kata benda yang tepat(IPADIC NEologd)

  • unidic: Bahasa Jepang UniDic (diperluas) - Kamus standar akademis dengan informasi linguistik yang terperinci(UniDic)

  • cc-cedict: Bahasa Mandarin (tradisional/disederhanakan) - Kamus bahasa Mandarin-Inggris yang dikelola oleh komunitas(CC-CEDICT)

filter

Daftar filter tingkat tokenizer untuk diterapkan setelah segmentasi. Setiap filter adalah objek dengan:

  • kind: Jenis filter. Nilai yang didukung:

    • korean_stop_tags: Hapus token yang cocok dengan tag POS Korea yang ditentukan.

    • japanese_stop_tags: Hapus token yang cocok dengan tag POS Jepang yang ditentukan.

  • tags: Daftar tag POS yang akan disaring. Tag yang tersedia tergantung pada kind:

    • Untuk korean_stop_tags: Gunakan kode tag yang tepat (misalnya, JKS, JKO, SF). Tag bahasa Korea memerlukan pencocokan yang tepat. Untuk daftar lengkap berdasarkan set tag Sejong, lihat sumber tag stop Lindera bahasa Korea.

    • Untuk japanese_stop_tags: Gunakan kode tag yang tepat (misalnya, 助詞,格助詞, 助詞,係助詞, 助動詞). Tag bahasa Jepang memerlukan pencocokan yang tepat. Untuk daftar lengkap (IPADIC), lihat referensi tag POS Jepang.

Setelah mendefinisikan analyzer_params, Anda dapat menerapkannya ke bidang VARCHAR saat mendefinisikan skema koleksi. Hal ini memungkinkan Milvus untuk memproses teks dalam bidang tersebut menggunakan penganalisis yang ditentukan untuk tokenisasi dan pemfilteran yang efisien. Untuk detailnya, lihat Contoh penggunaan.

Contoh

Sebelum menerapkan konfigurasi penganalisis ke skema koleksi Anda, verifikasi perilakunya menggunakan metode run_analyzer.

Contoh bahasa Korea

from pymilvus import MilvusClient

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

analyzer_params = {
    "tokenizer": {
        "type": "lindera",
        "dict_kind": "ko-dic",
        "filter": [
            {
                "kind": "korean_stop_tags",
                "tags": ["SP", "SSC", "SSO", "SC", "SE", "SF", "JKS", "JKC", "JKG", "JKO", "JKB", "JKV", "JKQ", "JX", "JC", "UNK", "EP", "ETM"]
            }
        ]
    }
}

# Sample Korean text: "서울에서 맛있는 음식을 먹었습니다" (I ate delicious food in Seoul)
sample_text = "서울에서 맛있는 음식을 먹었습니다"

result = client.run_analyzer(sample_text, analyzer_params)
print("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")
        .build();
MilvusClientV2 client = new MilvusClientV2(config);

Map<String, Object> analyzerParams = new HashMap<>();                                                                          
analyzerParams.put("tokenizer", new HashMap<String, Object>() {{
  put("type", "lindera");                                                                                                    
  put("dict_kind", "ko-dic");                                 
  put("filter", Arrays.asList(
      new HashMap<String, Object>() {{
          put("kind", "korean_stop_tags");
          put("tags", Arrays.asList(
              "SP", "SSC", "SSO", "SC", "SE", "SF",
              "JKS", "JKC", "JKG", "JKO", "JKB", "JKV", "JKQ",
              "JX", "JC", "UNK", "EP", "ETM"
          ));
      }}
  ));
}});

List<String> texts = new ArrayList<>();
texts.add("서울에서 맛있는 음식을 먹었습니다");

RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
        .texts(texts)
        .analyzerParams(analyzerParams)
        .build());
List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();
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
}

analyzerParams := map[string]interface{}{
  "tokenizer": map[string]interface{}{
      "type":      "lindera",
      "dict_kind": "ko-dic",
      "filter": []interface{}{
          map[string]interface{}{
              "kind": "korean_stop_tags",
              "tags": []string{
                  "SP", "SSC", "SSO", "SC", "SE", "SF",
                  "JKS", "JKC", "JKG", "JKO", "JKB", "JKV", "JKQ",
                  "JX", "JC", "UNK", "EP", "ETM",
              },
          },
      },
  },
}

bs, _ := json.Marshal(analyzerParams)
texts := []string{"서울에서 맛있는 음식을 먹었습니다"}
option := milvusclient.NewRunAnalyzerOption(texts).
    WithAnalyzerParams(string(bs))

result, err := client.RunAnalyzer(ctx, option)
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
import { MilvusClient } from "@zilliz/milvus2-sdk-node";

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

const analyzer_params = {
  tokenizer: {
    type: "lindera",
    dict_kind: "ko-dic",
    filter: [
      {
        kind: "korean_stop_tags",
        tags: [
          "SP",
          "SSC",
          "SSO",
          "SC",
          "SE",
          "SF",
          "JKS",
          "JKC",
          "JKG",
          "JKO",
          "JKB",
          "JKV",
          "JKQ",
          "JX",
          "JC",
          "UNK",
          "EP",
          "ETM",
        ],
      },
    ],
  },
};

const sample_text = "서울에서 맛있는 음식을 먹었습니다";

const result = await client.run_analyzer(sample_text, analyzer_params);
console.log("Analyzer output:", result);

# restful

Keluaran yang diharapkan:

['서울', '맛있', '음식', '먹', '습니다']

Tanpa korean_stop_tags, keluarannya akan menyertakan partikel seperti 에서 (in), (penanda topik), dan (penanda objek), yang biasanya tidak berguna untuk pencarian.

Contoh bahasa Jepang

from pymilvus import MilvusClient

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

analyzer_params = {
    "tokenizer": {
        "type": "lindera",
        "dict_kind": "ipadic",
        "filter": [
            {
                "kind": "japanese_stop_tags",
                "tags": ["接続詞", "助詞,格助詞", "助詞,格助詞,一般", "助詞,格助詞,引用", "助詞,格助詞,連語", "助詞,係助詞", "助詞,終助詞", "助詞,接続助詞", "助詞,特殊", "助詞,副助詞", "助詞,副助詞/並立助詞/終助詞", "助詞,連体化", "助詞,副詞化", "助詞,並立助詞", "助動詞", "記号,一般", "記号,読点", "記号,句点", "記号,空白", "記号,括弧閉", "記号,括弧開", "その他,間投", "フィラー", "非言語音"]
            }
        ]
    }
}

# Sample Japanese text: "東京スカイツリーの最寄り駅はとうきょうスカイツリー駅です"
sample_text = "東京スカイツリーの最寄り駅はとうきょうスカイツリー駅です"

result = client.run_analyzer(sample_text, analyzer_params)
print("Analyzer output:", result)
// java
// go

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

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

const analyzer_params = {
    "tokenizer": {
        "type": "lindera",
        "dict_kind": "ipadic",
        "filter": [
            {
                "kind": "japanese_stop_tags",
                "tags": ["接続詞", "助詞,格助詞", "助詞,格助詞,一般", "助詞,格助詞,引用", "助詞,格助詞,連語", "助詞,係助詞", "助詞,終助詞", "助詞,接続助詞", "助詞,特殊", "助詞,副助詞", "助詞,副助詞/並立助詞/終助詞", "助詞,連体化", "助詞,副詞化", "助詞,並立助詞", "助動詞", "記号,一般", "記号,読点", "記号,句点", "記号,空白", "記号,括弧閉", "記号,括弧開", "その他,間投", "フィラー", "非言語音"]
            }
        ]
    }
}

// Sample Japanese text: "東京スカイツリーの最寄り駅はとうきょうスカイツリー駅です"
const sample_text = "東京スカイツリーの最寄り駅はとうきょうスカイツリー駅です"

const result = await client.run_analyzer(sample_text, analyzer_params);
console.log("Analyzer output:", result);
# restful

Keluaran yang diharapkan:

['東京', 'スカイ', 'ツリー', '最寄り駅', 'とう', 'きょう', 'スカイ', 'ツリー', '駅']

Tanpa japanese_stop_tags, keluarannya akan menyertakan partikel seperti (posesif), (penanda topik), dan です (kopula).

Coba Milvus yang Dikelola secara Gratis

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

Mulai
Umpan balik

Apakah halaman ini bermanfaat?