Stop

Il filtro " stop " rimuove le parole vuote specificate dal testo tokenizzato, contribuendo a eliminare le parole comuni e meno significative. È possibile configurare l'elenco delle parole vuote utilizzando il parametro " stop_words ".

Configurazione

Il filtro stop accetta l’elenco delle parole di stop sia in linea tramite il parametro stop_words, sia da una risorsa file registrata tramite il parametro stop_words_file.

Elenco di stop-word in linea

Per utilizzare il filtro stop con un elenco in linea, specificare "type": "stop" nella configurazione del filtro, insieme al parametro stop_words che fornisce l’elenco delle parole di stop.

analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "stop", # Specifies the filter type as stop
        "stop_words": ["of", "to", "_english_"], # Defines custom stop words and includes the English stop word list
    }],
}

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("of", "to", "_english_"));
                }}
        )
);

const analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "stop", # Specifies the filter type as stop
        "stop_words": ["of", "to", "_english_"], # Defines custom stop words and includes the English stop word list
    }],
};

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "stop",
        "stop_words": []string{"of", "to", "_english_"},
    }}}

# restful
analyzerParams='{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "stop",
      "stop_words": [
        "of",
        "to",
        "_english_"
      ]
    }
  ]
}'

Il filtro stop accetta i seguenti parametri configurabili.

Parametro

Descrizione

stop_words

Un elenco di parole da rimuovere dalla tokenizzazione. Per impostazione predefinita, il filtro utilizza il dizionario _english_ integrato. È possibile sovrascriverlo o estenderlo in tre modi: Dizionari integrati – specificare uno di questi alias di lingua per utilizzare un dizionario predefinito: "_arabic_", "_english_", "_danish_", "_dutch_", "_finnish_", "_french_", "_german_", "_hungarian_", "_italian_", "_norwegian_", "_portuguese_", "_russian_", "_spanish_", "_swedish_", "_thai_" Elenco personalizzato: passare un array dei propri termini, ad esempio ["foo", "bar", "baz"]. Elenco misto – combina alias e termini personalizzati, ad es. ["of", "to", "_english_"]. Per i dettagli sul contenuto esatto di ciascun dizionario predefinito, consultare stop_words. Per esaminare il dizionario arabo o thailandese, consultare l’elenco delle parole vuote in arabo o l’elenco delle parole vuote in thailandese.

Il filtro stop opera sui termini generati dal tokenizer, pertanto deve essere utilizzato in combinazione con un tokenizer. Per un elenco dei tokenizer disponibili in Milvus, consultare la pagina Standard Tokenizer e le pagine correlate.

Dopo aver definito le parole da escludere ( analyzer_params), è possibile applicarle a un campo di tipo « 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 i dettagli, consultare Esempio di utilizzo.

Caricare le parole di stop da una risorsa fileCompatible with Milvus 3.0.x

Per elenchi personalizzati di parole di stop di grandi dimensioni — elenchi specifici per lingua, vocabolari di dominio o elenchi che si desidera condividere tra più collezioni — memorizzare le parole in un file e registrare il file come risorsa file remota, quindi fare riferimento ad esso dal filtro tramite il parametro ` stop_words_file `. È possibile utilizzare ` stop_words_file ` da solo o insieme a ` stop_words` in linea; quando entrambi sono impostati, il filtro unisce le due fonti in un unico elenco di parole di stop.

Il file è un testo semplice in formato UTF‑8 con una parola da escludere per riga. Ad esempio:

the
of
for

Caricare il file nell’object store che il cluster Milvus è configurato per utilizzare, quindi registrarlo:

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

Fai riferimento alla risorsa registrata nel filtro tramite ` stop_words_file`:

analyzer_params = {
    "tokenizer": "standard",
    "filter": [{
        "type": "stop",
        "stop_words_file": {
            "type": "remote",
            "resource_name": "en_stop_words",
            "file_name": "stop_words.txt",
        },
    }],
}

Il parametro ` stop_words_file ` accetta un oggetto con i seguenti campi:

Campo	Descrizione
type	Il tipo di risorsa. Utilizza "remote" per un file registrato tramite add_file_resource. Per la variante "local" utilizzata nelle distribuzioni self-hosted, consulta Gestisci risorse file.
resource_name	Il nome utilizzato al momento della registrazione del file su add_file_resource.
file_name	La porzione relativa al nome del file nel percorso dell’object store della risorsa registrata (ad esempio, "stop_words.txt" se la risorsa è stata registrata su path="file/stop_words.txt").

Esempi

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

Configurazione dell’analizzatore

analyzer_params = {
    "tokenizer": "standard",
    "filter":[{
        "type": "stop", # Specifies the filter type as stop
        "stop_words": ["of", "to", "_english_"], # Defines custom stop words and includes the English stop word list
    }],
}

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("of", "to", "_english_"));
                }}
        )
);

// javascript

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{map[string]any{
        "type":       "stop",
        "stop_words": []string{"of", "to", "_english_"},
    }}}

# restful

Verifica tramite run_analyzer

from pymilvus import (
    MilvusClient,
)

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

# Sample text to analyze
sample_text = "The stop filter allows control over common stop words for text processing."

# 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")
        .build();
MilvusClientV2 client = new MilvusClientV2(config);

List<String> texts = new ArrayList<>();
texts.add("The stop filter allows control over common stop words for text processing.");

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 stop filter allows control over common stop words for text processing."}
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

['The', 'stop', 'filter', 'allows', 'control', 'over', 'common', 'stop', 'words', 'text', 'processing']