أداة تفكيك الكلمات المركبة

يقوم مرشح " decompounder " بتقسيم الكلمات المركبة إلى مكونات فردية استنادًا إلى قاموس محدد، مما يسهل البحث عن أجزاء من المصطلحات المركبة. ويُعد هذا المرشح مفيدًا بشكل خاص للغات التي تستخدم الكلمات المركبة بشكل متكرر، مثل اللغة الألمانية.

يمكن توفير قاموس المكونات مباشرةً عبر المعلمة word_list أو تحميله من مورد ملف مسجل عبر المعلمة word_list_file.

التكوين

يقبل مرشح decompounder قاموس مكوناته إما بشكل مضمن عبر المعلمة word_list أو من مورد ملف مسجل عبر المعلمة word_list_file.

قائمة الكلمات المضمنة

يُعد مرشح « decompounder » مرشحًا مخصصًا في Milvus. لاستخدامه، حدد « "type": "decompounder" » في تكوين المرشح، إلى جانب المعلمة « word_list » التي توفر قاموس مكونات الكلمات المطلوب التعرف عليها.

analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "decompounder", # Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
}

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Collections.singletonList(
                new HashMap<String, Object>() {{
                    put("type", "decompounder");
                    put("word_list", Arrays.asList("dampf", "schiff", "fahrt", "brot", "backen", "automat"));
                }}
        )
);

analyzerParams := map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "decompounder",
        "word_list": []string{"dampf", "schiff", "fahrt", "brot", "backen", "automat"},
    }}}

let analyzer_params = serde_json::json!({
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"]
    }]
});

nlohmann::json analyzer_params = {
    {"tokenizer", "standard"},
    {"filter", {
        {
            {"type", "decompounder"},
            {"word_list", {"dampf", "schiff", "fahrt", "brot", "backen", "automat"}}
        }
    }}
};

const analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "decompounder", // Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
};

using System.Collections.Generic;

var analyzerParams = new Dictionary<string, object>
{
    ["tokenizer"] = "standard",
    ["filter"] = new object[]
    {
        new Dictionary<string, object>
        {
            ["type"] = "decompounder", // Specifies the filter type as decompounder
            ["word_list"] = new[] { "dampf", "schiff", "fahrt", "brot", "backen", "automat" }
        }
    }
};

# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "decompounder",
      "word_list": [
        "dampf",
        "schiff",
        "fahrt",
        "brot",
        "backen",
        "automat"
      ]
    }
  ]
}'

يقبل مرشح « decompounder » المعلمات القابلة للتكوين التالية.

المعلمة	الوصف
word_list	قائمة بمكونات الكلمات المستخدمة لتقسيم المصطلحات المركبة. يحدد هذا القاموس كيفية تفكيك الكلمات المركبة إلى مصطلحات فردية.

يعمل مرشح " decompounder " على المصطلحات التي يولدها أداة التقطيع (tokenizer)، لذا يجب استخدامه بالاقتران مع أداة التقطيع. للاطلاع على قائمة أدوات التقطيع المتاحة في Milvus، راجع "Standard Tokenizer " والصفحات المرتبطة بها.

بعد تعريف « analyzer_params »، يمكنك تطبيقها على حقل « VARCHAR » عند تعريف مخطط المجموعة. وهذا يسمح لـ Milvus بمعالجة النص في هذا الحقل باستخدام المحلل المحدد من أجل التقطيع والتصفية بكفاءة. لمزيد من التفاصيل، راجع «مثال على الاستخدام».

تحميل مكونات الكلمات من مورد ملفCompatible with Milvus 3.0.x

بالنسبة لقواميس المكونات الكبيرة — خاصة قوائم الكلمات للغة كاملة — قم بتخزين المكونات في ملف وتسجيل الملف كمورد ملف بعيد، ثم قم بالإشارة إليه من المرشح عبر المعلمة word_list_file. يمكنك استخدام word_list_file بمفرده أو جنبًا إلى جنب مع word_list المضمن؛ وعند تعيين كليهما، يقوم المرشح بدمج المصدرين في قائمة مكونات واحدة.

الملف عبارة عن نص عادي بتنسيق UTF‑8 يحتوي على كلمة مكون واحدة في كل سطر. على سبيل المثال:

dampf
schiff
fahrt
brot
backen
automat

قم بتحميل الملف إلى مخزن الكائنات الذي تم تكوين مجموعة Milvus الخاصة بك لاستخدامه، ثم قم بتسجيله:

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="de_components",
    path="file/decompounder.txt",    # full S3 object key, including the rootPath prefix
)

أشر إلى المورد المسجل في المرشح عبر word_list_file:

analyzer_params = {
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list_file": {
            "type": "remote",
            "resource_name": "de_components",
            "file_name": "decompounder.txt",
        },
    }],
}

يقبل المعلمة word_list_file كائنًا يحتوي على الحقول التالية:

الحقل	الوصف
type	نوع المورد. استخدم "remote" لملف مسجل عبر add_file_resource. بالنسبة لمتغير "local" المستخدم في عمليات النشر ذاتية الاستضافة، راجع إدارة موارد الملفات.
resource_name	الاسم المستخدم عند تسجيل الملف باستخدام add_file_resource.
file_name	جزء اسم الملف من مسار مخزن الكائنات للمورد المسجل (على سبيل المثال، "decompounder.txt" إذا تم تسجيل المورد عبر path="file/decompounder.txt").

أمثلة

قبل تطبيق تكوين المحلل على مخطط المجموعة الخاص بك، تحقق من سلوكه باستخدام طريقة run_analyzer.

تكوين المحلل

analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "decompounder", # Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
}

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Collections.singletonList(
                new HashMap<String, Object>() {{
                    put("type", "decompounder");
                    put("word_list", Arrays.asList("dampf", "schiff", "fahrt", "brot", "backen", "automat"));
                }}
        )
);

analyzerParams := map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "decompounder",
        "word_list": []string{"dampf", "schiff", "fahrt", "brot", "backen", "automat"},
    }}}

let analyzer_params = serde_json::json!({
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"]
    }]
});

nlohmann::json analyzer_params = {
    {"tokenizer", "standard"},
    {"filter", {
        {
            {"type", "decompounder"},
            {"word_list", {"dampf", "schiff", "fahrt", "brot", "backen", "automat"}}
        }
    }}
};

const analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "decompounder", // Specifies the filter type as decompounder
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"],
    }],
};

using System.Collections.Generic;

var analyzerParams = new Dictionary<string, object>
{
    ["tokenizer"] = "standard",
    ["filter"] = new object[]
    {
        new Dictionary<string, object>
        {
            ["type"] = "decompounder", // Specifies the filter type as decompounder
            ["word_list"] = new[] { "dampf", "schiff", "fahrt", "brot", "backen", "automat" }
        }
    }
};

# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "decompounder",
      "word_list": [
        "dampf",
        "schiff",
        "fahrt",
        "brot",
        "backen",
        "automat"
      ]
    }
  ]
}'

التحقق باستخدام run_analyzer

from pymilvus import (
    MilvusClient,
)

client = MilvusClient(uri="http://localhost:19530", token="root:Milvus")

# Sample text to analyze
sample_text = "dampfschifffahrt brotbackautomat"

# Run the analyzer with the defined configuration
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;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

List<String> texts = new ArrayList<>();
texts.add("dampfschifffahrt brotbackautomat");

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/v3/milvusclient"
)

ctx := context.Background()

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

bs, _ := json.Marshal(analyzerParams)
texts := []string{"dampfschifffahrt brotbackautomat"}
option := milvusclient.NewRunAnalyzerOption(texts...).
    WithAnalyzerParamsStr(string(bs))

result, err := client.RunAnalyzer(ctx, option)
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println(result)

use milvus::v2::error::Result;
use milvus::v2::prelude::*;
use serde_json::json;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let analyzer_params = json!({
    "tokenizer": "standard",
    "filter": [{
        "type": "decompounder",
        "word_list": ["dampf", "schiff", "fahrt", "brot", "backen", "automat"]
    }]
});

let result = client.run_analyzer(
    RunAnalyzerRequest::builder()
        .texts(["dampfschifffahrt brotbackautomat".to_string()])
        .analyzer_params(analyzer_params)
        .build()?,
).await?;
println!("{:?}", result.results());

#include "milvus/MilvusClientV2.h"
#include <iostream>
#include <string>

auto client = milvus::MilvusClientV2::Create();

milvus::ConnectParam connect_param{"http://localhost:19530", "root:Milvus"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

std::string text = "dampfschifffahrt brotbackautomat";
auto request = milvus::RunAnalyzerRequest()
                       .AddText(text)
                       .WithAnalyzerParams(analyzer_params);

milvus::RunAnalyzerResponse response;
status = client->RunAnalyzer(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

for (const auto& result : response.Results()) {
    for (const auto& token : result.Tokens()) {
        std::cout << token.token_ << " ";
    }
    std::cout << std::endl;
}

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

const client = new MilvusClient({
  address: 'http://localhost:19530',
  token: 'root:Milvus'
});

const res = await client.runAnalyzer({
  text: 'dampfschifffahrt brotbackautomat',
  analyzer_params: analyzer_params
});

console.log(res);

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Utility;
using Milvus.Client.V2.Types;

using var client = new MilvusClientV2(new ConnectConfig { Uri = "http://localhost:19530", ApiKey = "root:Milvus" });
await client.ConnectAsync();

// Sample text to analyze
var sampleText = "dampfschifffahrt brotbackautomat";

var result = await client.RunAnalyzerAsync(new RunAnalyzerReq
{
    AnalyzerParams = analyzerParams,
    Texts = new[] { sampleText }
});
foreach (var r in result.Results)
{
    Console.WriteLine("Analyzer output: " + string.Join(", ", r.Tokens.Select(t => t.Token)));
}

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

curl --request POST \
  --url "${CLUSTER_ENDPOINT}/v2/vectordb/common/run_analyzer" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{
    "analyzerParams": "{\"tokenizer\":\"standard\",\"filter\":[{\"type\":\"decompounder\",\"word_list\":[\"dampf\",\"schiff\",\"fahrt\",\"brot\",\"backen\",\"automat\"]}]}",
    "text": ["dampfschifffahrt brotbackautomat"]
  }'

الناتج المتوقع

['dampf', 'schiff', 'fahrt', 'brotbackautomat']