Panoramica sull'analizzatore

Nell'elaborazione del testo, un analizzatore è un componente cruciale che converte il testo grezzo in un formato strutturato e ricercabile. Ogni analizzatore è generalmente composto da due elementi fondamentali: tokenizer e filtro. Insieme, trasformano il testo in ingresso in token, li raffinano e li preparano per un'indicizzazione e un recupero efficienti.

In Milvus, gli analizzatori sono configurati durante la creazione della raccolta, quando si aggiungono i campi VARCHAR allo schema della raccolta. I token prodotti da un analizzatore possono essere usati per costruire un indice per la corrispondenza con le parole chiave o convertiti in embedding sparsi per la ricerca full text. Per ulteriori informazioni, consultare Ricerca a testo intero, Corrispondenza per frase o Corrispondenza per testo.

Anatomia di un analizzatore

Un analizzatore in Milvus è composto esattamente da un tokenizer e da zero o più filtri.

• Tokenizzatore: Il tokenizer spezza il testo in ingresso in unità discrete chiamate tokens. Questi token possono essere parole o frasi, a seconda del tipo di tokenizer.

• Filtri: I filtri possono essere applicati ai token per affinarli ulteriormente, ad esempio rendendoli minuscoli o rimuovendo parole comuni.

Il flusso di lavoro seguente mostra come un analizzatore elabora il testo.

Flusso di lavoro del processo di analisi

Tipi di analizzatori

Milvus offre due tipi di analizzatori per soddisfare le diverse esigenze di elaborazione del testo:

• Analizzatore integrato: Si tratta di configurazioni predefinite che coprono le attività comuni di elaborazione del testo con una configurazione minima. Gli analizzatori integrati sono ideali per le ricerche generiche, in quanto non richiedono una configurazione complessa.

• Analizzatore personalizzato: Per i requisiti più avanzati, gli analizzatori personalizzati consentono di definire la propria configurazione specificando sia il tokenizer che zero o più filtri. Questo livello di personalizzazione è particolarmente utile per casi d'uso specializzati in cui è necessario un controllo preciso sull'elaborazione del testo.

Analizzatore integrato

Gli analizzatori integrati in Milvus sono preconfigurati con tokenizer e filtri specifici, il che consente di utilizzarli immediatamente senza doverli definire personalmente. Ogni analizzatore integrato è un modello che include un tokenizer e dei filtri preimpostati, con parametri opzionali per la personalizzazione.

Per esempio, per usare l'analizzatore incorporato standard, basta specificare il nome standard come type e includere facoltativamente configurazioni aggiuntive specifiche per questo tipo di analizzatore, come 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
};

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

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

Per verificare il risultato dell'esecuzione di un analizzatore, utilizzare il metodo run_analyzer:

# Sample text to analyze
text = "An efficient system relies on a robust analyzer to correctly process text for various applications."

# Run analyzer
result = client.run_analyzer(
    text,
    analyzer_params
)

import io.milvus.v2.service.vector.request.RunAnalyzerReq;
import io.milvus.v2.service.vector.response.RunAnalyzerResp;

List<String> texts = new ArrayList<>();
texts.add("An efficient system relies on a robust analyzer to correctly process text for various applications.");

RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
        .texts(texts)
        .analyzerParams(analyzerParams)
        .build());
List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();

// javascrip# Sample text to analyze
const text = "An efficient system relies on a robust analyzer to correctly process text for various applications."

// Run analyzer
const result = await client.run_analyzer({
    text,
    analyzer_params
});

import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

bs, _ := json.Marshal(analyzerParams)
texts := []string{"An efficient system relies on a robust analyzer to correctly process text for various applications."}
option := milvusclient.NewRunAnalyzerOption(texts).
    WithAnalyzerParams(string(bs))

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

# restful

L'output sarà:

['efficient', 'system', 'relies', 'on', 'robust', 'analyzer', 'to', 'correctly', 'process', 'text', 'various', 'applications']

Questo dimostra che l'analizzatore ha correttamente tokenizzato il testo in ingresso filtrando le stop words "a", "an", e "for", restituendo i restanti tokens significativi.

La configurazione dell'analizzatore integrato standard di cui sopra è equivalente alla configurazione di un analizzatore personalizzato con i seguenti parametri, dove le opzioni tokenizer e filter sono definite esplicitamente per ottenere una funzionalità simile:

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"]
        }
    ]
};

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{"lowercase", map[string]any{
        "type":       "stop",
        "stop_words": []string{"a", "an", "for"},
    }}}

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

Milvus offre i seguenti analizzatori integrati, ciascuno progettato per specifiche esigenze di elaborazione del testo:

• standard: Adatto per l'elaborazione di testi generici, applicando la tokenizzazione standard e il filtraggio delle minuscole.

• english: Ottimizzato per i testi in lingua inglese, con supporto per le stop words inglesi.

• chinese: Specializzato per l'elaborazione del testo cinese, con tokenizzazione adattata alle strutture della lingua cinese.

Analizzatore personalizzato

Per un'elaborazione del testo più avanzata, gli analizzatori personalizzati di Milvus consentono di costruire una pipeline di trattamento del testo su misura, specificando sia un tokenizzatore che dei filtri. Questa configurazione è ideale per casi d'uso specializzati in cui è richiesto un controllo preciso.

Tokenizzatore

Il tokenizer è un componente obbligatorio per un analizzatore personalizzato, che avvia la pipeline di analisi scomponendo il testo in ingresso in unità discrete o token. La tokenizzazione segue regole specifiche, come la divisione per spazi bianchi o punteggiatura, a seconda del tipo di tokenizzatore. Questo processo consente una gestione più precisa e indipendente di ogni parola o frase.

Ad esempio, un tokenizer converte il testo "Vector Database Built for Scale" in token separati:

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

Esempio di specificazione di un tokenizer:

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

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

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

analyzerParams = map[string]any{"tokenizer": "whitespace"}

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

Filtro

Ifiltri sono componenti opzionali che lavorano sui token prodotti dal tokenizer, trasformandoli o raffinandoli come necessario. Ad esempio, dopo aver applicato un filtro lowercase ai termini tokenizzati ["Vector", "Database", "Built", "for", "Scale"], il risultato potrebbe essere:

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

I filtri di un analizzatore personalizzato possono essere integrati o personalizzati, a seconda delle esigenze di configurazione.

• Filtri integrati: Preconfigurati da Milvus, richiedono una configurazione minima. È possibile utilizzare questi filtri immediatamente, specificando i loro nomi. I filtri seguenti sono integrati per l'uso diretto:

  • lowercase: Converte il testo in minuscolo, garantendo una corrispondenza senza distinzione tra maiuscole e minuscole. Per maggiori dettagli, consultare Minuscole.

  • asciifolding: Converte i caratteri non ASCII in equivalenti ASCII, semplificando la gestione del testo multilingue. Per ulteriori informazioni, consultare la sezione Piegatura ASCII.

  • alphanumonly: Conserva solo i caratteri alfanumerici eliminando gli altri. Per maggiori dettagli, vedere Solo alfanumerici.

  • cnalphanumonly: Rimuove i token che contengono caratteri diversi da quelli cinesi, lettere inglesi o cifre. Per i dettagli, fare riferimento a Cnalphanumonly.

  • cncharonly: Rimuove i token che contengono caratteri non cinesi. Per i dettagli, fare riferimento a Cncharonly.

  Esempio di utilizzo di un filtro integrato:

  PythonJavaNodeJSGocURL

  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
  }
  

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

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

• Filtri personalizzati: I filtri personalizzati consentono configurazioni specifiche. È possibile definire un filtro personalizzato scegliendo un tipo di filtro valido (filter.type) e aggiungendo impostazioni specifiche per ogni tipo di filtro. Esempi di tipi di filtro che supportano la personalizzazione:

  • stop: Rimuove le parole comuni specificate impostando un elenco di parole di arresto (ad esempio, "stop_words": ["of", "to"]). Per ulteriori informazioni, consultare Stop.

  • length: Esclude i token in base a criteri di lunghezza, come l'impostazione di una lunghezza massima dei token. Per i dettagli, vedere Lunghezza.

  • stemmer: Riduce le parole alla loro forma radicale per una corrispondenza più flessibile. Per ulteriori informazioni, vedere Stemmer.

  Esempio di configurazione di un filtro personalizzato:

  PythonJavaNodeJSGocURL

  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
          }
      ]
  };
  

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

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

Esempio di utilizzo

In questo esempio, si creerà uno schema di raccolta che include:

• Un campo vettoriale per le incorporazioni.

• Due campi VARCHAR per l'elaborazione del testo:

  • Un campo utilizza un analizzatore integrato.

  • L'altro utilizza un analizzatore personalizzato.

Prima di incorporare queste configurazioni nella raccolta, si verificherà ogni analizzatore con il metodo run_analyzer.

Passo 1: inizializzare MilvusClient e creare uno schema

Iniziare a configurare il client Milvus e creare un nuovo schema.

from pymilvus import MilvusClient, DataType

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

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

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();

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

// Set up a Milvus client
const client = new MilvusClient("http://localhost:19530");

import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/index"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)  

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "localhost:19530",
})
if err != nil {
    fmt.Println(err.Error())
    // handle err
}
defer client.Close(ctx)

schema := entity.NewSchema().WithAutoID(true).WithDynamicFieldEnabled(false)

# restful

Passo 2: Definire e verificare le configurazioni dell'analizzatore

1. Configurare e verificare un analizzatore integrato (english):

   • Configurazione: Definire i parametri dell'analizzatore per l'analizzatore integrato inglese.

   • Verifica: Utilizzare run_analyzer per verificare che la configurazione produca la tokenizzazione prevista.

   PythonJavaNodeJSGocURL

   # Built-in analyzer configuration for English text processing
   analyzer_params_built_in = {
       "type": "english"
   }
   
   # Verify built-in analyzer configuration
   sample_text = "Milvus simplifies text analysis for search."
   result = client.run_analyzer(sample_text, analyzer_params_built_in)
   print("Built-in analyzer output:", result)
   
   # Expected output:
   # Built-in analyzer output: ['milvus', 'simplifi', 'text', 'analysi', 'search']
   
   

   Map<String, Object> analyzerParamsBuiltin = new HashMap<>();
   analyzerParamsBuiltin.put("type", "english");
   
   List<String> texts = new ArrayList<>();
   texts.add("Milvus simplifies text ana
   
   lysis for search.");
   
   RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
           .texts(texts)
           .analyzerParams(analyzerParams)
           .build());
   List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();
   
   

   // Use a built-in analyzer for VARCHAR field `title_en`
   const analyzerParamsBuiltIn = {
     type: "english",
   };
   
   const sample_text = "Milvus simplifies text analysis for search.";
   const result = await client.run_analyzer({
       text: sample_text, 
       analyzer_params: analyzer_params_built_in
   });
   
   

   analyzerParams := map[string]any{"type": "english"}
   
   bs, _ := json.Marshal(analyzerParams)
   texts := []string{"Milvus simplifies text analysis for search."}
   option := milvusclient.NewRunAnalyzerOption(texts).
       WithAnalyzerParams(string(bs))
   
   result, err := client.RunAnalyzer(ctx, option)
   if err != nil {
       fmt.Println(err.Error())
       // handle error
   }
   
   

   # restful
   

2. Configurare e verificare un analizzatore personalizzato:

   • Configurazione: Definire un analizzatore personalizzato che utilizzi un tokenizer standard insieme a un filtro integrato per le minuscole e a filtri personalizzati per la lunghezza dei token e le stop words.

   • Verifica: Usare run_analyzer per assicurarsi che la configurazione personalizzata elabori il testo come previsto.

   PythonJavaNodeJSGocURL

   # Custom analyzer configuration with a standard tokenizer and custom filters
   analyzer_params_custom = {
       "tokenizer": "standard",
       "filter": [
           "lowercase",  # Built-in filter: convert tokens to lowercase
           {
               "type": "length",  # Custom filter: restrict token length
               "max": 40
           },
           {
               "type": "stop",  # Custom filter: remove specified stop words
               "stop_words": ["of", "for"]
           }
       ]
   }
   
   # Verify custom analyzer configuration
   sample_text = "Milvus provides flexible, customizable analyzers for robust text processing."
   result = client.run_analyzer(sample_text, analyzer_params_custom)
   print("Custom analyzer output:", result)
   
   # Expected output:
   # Custom analyzer output: ['milvus', 'provides', 'flexible', 'customizable', 'analyzers', 'robust', 'text', 'processing']
   
   

   // 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("of", "for"));
                   }}
           )
   );
   
   List<String> texts = new ArrayList<>();
   texts.add("Milvus provides flexible, customizable analyzers for robust text processing.");
   
   RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
           .texts(texts)
           .analyzerParams(analyzerParams)
           .build());
   List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();
   

   // Configure a custom analyzer for VARCHAR field `title`
   const analyzerParamsCustom = {
     tokenizer: "standard",
     filter: [
       "lowercase",
       {
         type: "length",
         max: 40,
       },
       {
         type: "stop",
         stop_words: ["of", "to"],
       },
     ],
   };
   const sample_text = "Milvus provides flexible, customizable analyzers for robust text processing.";
   const result = await client.run_analyzer({
       text: sample_text, 
       analyzer_params: analyzer_params_built_in
   });
   

   analyzerParams = map[string]any{"tokenizer": "standard",
       "filter": []any{"lowercase", 
       map[string]any{
           "type": "length",
           "max":  40,
       map[string]any{
           "type": "stop",
           "stop_words": []string{"of", "to"},
       }}}
       
   bs, _ := json.Marshal(analyzerParams)
   texts := []string{"Milvus provides flexible, customizable analyzers for robust text processing."}
   option := milvusclient.NewRunAnalyzerOption(texts).
       WithAnalyzerParams(string(bs))
   
   result, err := client.RunAnalyzer(ctx, option)
   if err != nil {
       fmt.Println(err.Error())
       // handle error
   }
   

   # curl
   

Passo 3: Aggiungere campi allo schema

Dopo aver verificato le configurazioni dell'analizzatore, aggiungerle ai campi dello schema:

# Add VARCHAR field 'title_en' using the built-in analyzer configuration
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,
)

# Add VARCHAR field 'title' using the custom analyzer configuration
schema.add_field(
    field_name='title',
    datatype=DataType.VARCHAR,
    max_length=1000,
    enable_analyzer=True,
    analyzer_params=analyzer_params_custom,
    enable_match=True,
)

# Add a vector field for embeddings
schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=3)

# Add a primary key field
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)

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());

// 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,
    },
  ],
};

schema.WithField(entity.NewField().
    WithName("id").
    WithDataType(entity.FieldTypeInt64).
    WithIsPrimaryKey(true).
    WithIsAutoID(true),
).WithField(entity.NewField().
    WithName("embedding").
    WithDataType(entity.FieldTypeFloatVector).
    WithDim(3),
).WithField(entity.NewField().
    WithName("title").
    WithDataType(entity.FieldTypeVarChar).
    WithMaxLength(1000).
    WithEnableAnalyzer(true).
    WithAnalyzerParams(analyzerParams).
    WithEnableMatch(true),
)

# restful

Passo 4: Preparare i parametri dell'indice e creare la collezione

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

# Create the collection with the defined schema and index parameters
client.create_collection(
    collection_name="my_collection",
    schema=schema,
    index_params=index_params
)

// 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("my_collection")
        .collectionSchema(schema)
        .indexParams(indexes)
        .build();
client.createCollection(requestCreate);

// 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: "my_collection",
  schema: schema,
  index_params: indexParams,
});

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

idx := index.NewAutoIndex(index.MetricType(entity.COSINE))
indexOption := milvusclient.NewCreateIndexOption("my_collection", "embedding", idx)

err = client.CreateCollection(ctx,
    milvusclient.NewCreateCollectionOption("my_collection", schema).
        WithIndexOptions(indexOption))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

# restful

Cosa fare dopo

Dopo aver configurato un analizzatore, è possibile integrarlo con le funzioni di recupero del testo fornite da Milvus. Per maggiori dettagli:

• Ricerca a tutto testo

• Corrispondenza del testo

• Corrispondenza di frase