Analizzatore predefinito

L'analizzatore " standard " è l'analizzatore predefinito in Milvus, che viene applicato automaticamente ai campi di testo se non viene specificato alcun analizzatore. Utilizza la tokenizzazione basata sulla grammatica, rendendolo efficace per la maggior parte delle lingue.

Definizione

L'analizzatore " standard " è costituito da:

• Tokenizzatore: utilizza il tokenizzatore " standard " per suddividere il testo in singole parole in base alle regole grammaticali. Per ulteriori informazioni, consultare Tokenizzatore standard.

• Filtro: utilizza il filtro " lowercase " per convertire tutti i token in minuscolo, consentendo ricerche che non tengono conto delle maiuscole e minuscole. Per ulteriori informazioni, consultare la sezione "Minuscolo".

La funzionalità dell’analizzatore standard è equivalente alla seguente configurazione dell’analizzatore personalizzato:

analyzer_params = {
    "tokenizer": "standard",
    "filter": ["lowercase"]
}

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

const analyzer_params = {
    "tokenizer": "standard",
    "filter": ["lowercase"]
};

analyzerParams := map[string]any{"tokenizer": "standard", "filter": []any{"lowercase"}}

# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    "lowercase"
  ]
}'

Configurazione

Per applicare l’analizzatore “ standard ” a un campo, è sufficiente impostare ` type ` su ` standard ` in ` analyzer_params` e includere i parametri opzionali secondo necessità.

analyzer_params = {
    "type": "standard", # Specifies the standard analyzer type
}

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

const analyzer_params = {
    "type": "standard", // Specifies the standard analyzer type
}

analyzerParams = map[string]any{"type": "standard"}

# restful
analyzerParams='{
  "type": "standard"
}'

L’analizzatore standard accetta i seguenti parametri opzionali:

Parametro	Descrizione
stop_words	Un array contenente un elenco di parole di stop, che verranno rimosse dalla tokenizzazione. Il valore predefinito è _english_, un insieme integrato di parole di stop comuni in inglese.

Esempio di configurazione delle parole di stop personalizzate:

analyzer_params = {
    "type": "standard", # Specifies the standard analyzer type
    "stop_words", ["of"] # Optional: List of words to exclude from tokenization
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("type", "standard");
analyzerParams.put("stop_words", Collections.singletonList("of"));

analyzer_params = {
    "type": "standard", // Specifies the standard analyzer type
    "stop_words", ["of"] // Optional: List of words to exclude from tokenization
}

analyzerParams = map[string]any{"type": "standard", "stop_words": []string{"of"}}

# restful

Dopo aver definito analyzer_params, è possibile applicarle a un campo VARCHAR durante la definizione dello schema di una collezione. Ciò consente a Milvus di elaborare il testo in quel campo utilizzando l'analizzatore specificato per una tokenizzazione e un filtraggio efficienti. Per ulteriori informazioni, consultare Esempio di utilizzo.

Esempi

Prima di applicare la configurazione dell’analizzatore allo schema della collezione, verificarne il comportamento utilizzando il metodo ` run_analyzer `.

Configurazione dell’analizzatore

analyzer_params = {
    "type": "standard",  # Standard analyzer configuration
    "stop_words": ["for"] # Optional: Custom stop words parameter
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("type", "standard");
analyzerParams.put("stop_words", Collections.singletonList("for"));

// javascript

analyzerParams = map[string]any{"type": "standard", "stop_words": []string{"for"}}

# restful
analyzerParams='{
  "type": "standard",
  "stop_words": [
    "of"
  ]
}'

Verifica tramite run_analyzer

from pymilvus import (
    MilvusClient,
)

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

# Sample text to analyze
sample_text = "The Milvus vector database is built for scale!"

# 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("The Milvus vector database is built for scale!");

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{"The Milvus vector database is built for scale!"}
option := milvusclient.NewRunAnalyzerOption(texts).
    WithAnalyzerParams(string(bs))

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

# restful

Risultato atteso

Standard analyzer output: ['the', 'milvus', 'vector', 'database', 'is', 'built', 'scale']