Funzioni di analisi del testo

GoogleSQL per BigQuery supporta le seguenti funzioni di analisi del testo.

Elenco funzioni

Nome	Riepilogo
`BAG_OF_WORDS`	Restituisce la frequenza di ogni termine (token) in un documento tokenizzato.
`TEXT_ANALYZE`	Estrae termini (token) dal testo e li converte in un documento tokenizzato.
`TF_IDF`	Valuta la pertinenza di un termine (token) per un documento tokenizzato in un insieme di documenti tokenizzati.

`BAG_OF_WORDS`

BAG_OF_WORDS(tokenized_document)

Definizione

Restituisce la frequenza di ogni termine (token) in un documento tokenizzato.

Definizioni

tokenized_document: valore ARRAY<STRING> che rappresenta un documento che è stato tokenizzato. Un documento tokenizzato è una raccolta di termini (token) utilizzati per l'analisi del testo.

Tipo di reso

ARRAY<STRUCT<term STRING, count INT64>>

Definizioni:

term: un termine univoco nel documento tokenizzato.
count: il numero di volte in cui il termine è stato trovato nel documento tokenizzato.

Esempi

La seguente query produce i termini e le relative frequenze in due documenti tokenizzati:

WITH
  ExampleTable AS (
    SELECT 1 AS id, ['I', 'like', 'pie', 'pie', 'pie', NULL] AS f UNION ALL
    SELECT 2 AS id, ['yum', 'yum', 'pie', NULL] AS f
  )
SELECT id, BAG_OF_WORDS(f) AS results
FROM ExampleTable
ORDER BY id;

/*----+------------------------------------------------*
 | id | results                                        |
 +----+------------------------------------------------+
 | 1  | [(null, 1), ('I', 1), ('like', 1), ('pie', 3)] |
 | 2  | [(null, 1), ('pie', 1), ('yum', 2)]            |
 *----+------------------------------------------------*/

`TEXT_ANALYZE`

TEXT_ANALYZE(
  text
  [, analyzer=>{ 'LOG_ANALYZER' | 'NO_OP_ANALYZER' | 'PATTERN_ANALYZER' }]
  [, analyzer_options=>analyzer_options_values]
)

Description

Estrae termini (token) dal testo e li converte in un documento tokenizzato.

Definizioni

text: valore STRING che rappresenta il testo di input da tokenizzare.
analyzer: argomento facoltativo con nome obbligatorio che determina quale analizzatore utilizzare per convertire text in un array di termini (token). Ad esempio:
- 'LOG_ANALYZER' (valore predefinito): suddivide l'input in termini quando vengono rilevati i delimitatori, quindi normalizza i termini. Se analyzer non è specificato, viene utilizzato per impostazione predefinita. Per saperne di più, consulta la pagina dedicata allo strumento di analisi del testo di LOG_ANALYZER.
- 'NO_OP_ANALYZER': estrae il testo come singolo termine (token), ma non applica la normalizzazione. Per saperne di più, consulta la pagina dedicata allo strumento di analisi del testo di NO_OP_ANALYZER.
- 'PATTERN_ANALYZER': suddivide l'input in termini che corrispondono a un'espressione regolare. Per ulteriori informazioni, consulta Strumento di analisi del testo di PATTERN_ANALYZER.
analyzer_options: argomento denominato obbligatorio facoltativo che prende un elenco di regole di analisi del testo come STRING in formato JSON. Per ulteriori informazioni, consulta Opzioni di analisi del testo.

Dettagli

Non esiste alcuna garanzia sull'ordine dei token prodotti da questa funzione.

Se non viene specificato alcun analizzatore, per impostazione predefinita viene utilizzato l'analizzatore LOG_ANALYZER.

Tipo di reso

ARRAY<STRING>

Esempi

La seguente query utilizza lo strumento di analisi del testo predefinito, LOG_ANALYZER, con il testo di input:

SELECT TEXT_ANALYZE('I like pie, you like-pie, they like 2 PIEs.') AS results

/*--------------------------------------------------------------------------*
 | results                                                                  |
 +--------------------------------------------------------------------------+
 | ['i', 'like', 'pie', 'you', 'like', 'pie', 'they', 'like', '2', 'pies' ] |
 *--------------------------------------------------------------------------*/

La seguente query utilizza lo strumento di analisi del testo NO_OP_ANALYZER con il testo di input:

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'NO_OP_ANALYZER'
) AS results

/*-----------------------------------------------*
 | results                                       |
 +-----------------------------------------------+
 | 'I like pie, you like-pie, they like 2 PIEs.' |
 *-----------------------------------------------*/

La seguente query utilizza lo strumento di analisi del testo PATTERN_ANALYZER con il testo di input:

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'PATTERN_ANALYZER'
) AS results

/*----------------------------------------------------------------*
 | results                                                        |
 +----------------------------------------------------------------+
 | ['like', 'pie', 'you', 'like', 'pie', 'they', 'like', 'pies' ] |
 *----------------------------------------------------------------*/

Per ulteriori esempi che includono opzioni di analisi, consulta Analisi del testo.

Per informazioni utili sulle ricette degli analizzatori da utilizzare per migliorare le query supportate dall'analizzatore, consulta Ricerca con analizzatori di testo.

`TF_IDF`

TF_IDF(tokenized_document) OVER()

TF_IDF(tokenized_document, max_distinct_tokens) OVER()

TF_IDF(tokenized_document, max_distinct_tokens, frequency_threshold) OVER()

Description

Valuta la pertinenza di un termine rispetto a un documento tokenizzato in un insieme di documenti tokenizzati, utilizzando l'algoritmo TF-IDF (term quantity-inverse documentfrequency).

Definizioni

tokenized_document: valore ARRAY<STRING> che rappresenta un documento che è stato tokenizzato. Un documento tokenizzato è una raccolta di termini (token) utilizzati per l'analisi del testo.
max_distinct_tokens: argomento facoltativo. Prende un valore INT64 non negativo, che rappresenta la dimensione del dizionario, escluso il termine sconosciuto.

I termini vengono aggiunti al dizionario finché non viene raggiunta questa soglia. Quindi, se questo valore è 20, vengono aggiunti i primi 20 termini univoci e poi non vengono aggiunti altri termini.

Se questo argomento non viene fornito, il valore predefinito è 32000. Se questo argomento è specificato, il valore massimo è 1048576.
frequency_threshold: argomento facoltativo. Utilizza un valore INT64 non negativo che rappresenta il numero minimo di volte in cui un termine deve comparire in un documento tokenizzato per essere incluso nel dizionario. Quindi, se questo valore è 3, un termine deve apparire almeno tre volte nel documento tokenizzato per essere aggiunto al dizionario.

Se questo argomento non viene fornito, il valore predefinito è 5.

Dettagli

Questa funzione utilizza un algoritmo TF-IDF (term quantity-inverse document quantity) per calcolare la pertinenza dei termini in un insieme di documenti tokenizzati. TF-IDF moltiplica due metriche: quante volte un termine compare in un documento (frequenza termine) e la frequenza inversa del termine in una raccolta di documenti (frequenza inversa del documento).

TDIF:

term frequency * inverse document frequency

frequenza dei termini:

(count of term in document) / (document size)

frequenza inversa del documento:

log(1 + document set size / (1 + count of documents containing term))

I termini vengono aggiunti a un dizionario se soddisfano i criteri di max_distinct_tokens e frequency_threshold, altrimenti vengono considerati come termine sconosciuto. Il termine sconosciuto è sempre il primo termine del dizionario ed è rappresentato come NULL. Il resto del dizionario è ordinato in base alla frequenza dei termini e non in ordine alfabetico.

Tipo di reso

ARRAY<STRUCT<term STRING, tf_idf DOUBLE>>

Definizioni:

term: il termine univoco aggiunto al dizionario.
tf_idf: il calcolo di TF-IDF per il termine.

Esempi

La seguente query calcola la pertinenza di un massimo di 10 termini che compaiono almeno due volte in un insieme di documenti tokenizzati. In questo esempio, gli argomenti con nome vengono passati in posizione. 10 rappresenta max_distinct_tokens e 2 rappresenta frequency_threshold:

WITH ExampleTable AS (
  SELECT 1 AS id, ['I', 'like', 'pie', 'pie', 'pie', NULL] AS f UNION ALL
  SELECT 2 AS id, ['yum', 'yum', 'pie', NULL] AS f UNION ALL
  SELECT 3 AS id, ['I', 'yum', 'pie', NULL] AS f UNION ALL
  SELECT 4 AS id, ['you', 'like', 'pie', 'too', NULL] AS f
)
SELECT id, TF_IDF(f, 10, 2) OVER() AS results
FROM ExampleTable
ORDER BY id;

/*----+-------------------------------------------------*
 | id | results                                         |
 +----+-------------------------------------------------+
 | 1  | [{"index":null,"value":"0.1304033435859887"},   |
 |    |  {"index":"I","value":"0.1412163100645339"},    |
 |    |  {"index":"like","value":"0.1412163100645339"}, |
 |    |  {"index":"pie","value":"0.29389333245105953"}] |
 +----+-------------------------------------------------+
 | 2  | [{"index":null,"value":"0.1956050153789831"},   |
 |    |  {"index":"pie","value":"0.14694666622552977"}, |
 |    |  {"index":"yum","value":"0.4236489301936017"}]  |
 +----+-------------------------------------------------+
 | 3  | [{"index":null,"value":"0.1956050153789831"},   |
 |    |  {"index":"I","value":"0.21182446509680086"},   |
 |    |  {"index":"pie","value":"0.14694666622552977"}, |
 |    |  {"index":"yum","value":"0.21182446509680086"}] |
 +----+-------------------------------------------------+
 | 4  | [{"index":null,"value":"0.4694520369095594"},   |
 |    |  {"index":"like","value":"0.1694595720774407"}, |
 |    |  {"index":"pie","value":"0.11755733298042381"}] |
 *----+-------------------------------------------------*/

La seguente query calcola la pertinenza di un massimo di tre termini che appaiono almeno una volta in un insieme di documenti tokenizzati:

WITH ExampleTable AS (
  SELECT 1 AS id, ['I', 'like', 'pie', 'pie', 'pie', NULL] AS f UNION ALL
  SELECT 2 AS id, ['yum', 'yum', 'pie', NULL] AS f UNION ALL
  SELECT 3 AS id, ['I', 'yum', 'pie', NULL] AS f UNION ALL
  SELECT 4 AS id, ['you', 'like', 'pie', 'too', NULL] AS f
)
SELECT id, TF_IDF(f, 3, 2) OVER() AS results
FROM ExampleTable
ORDER BY id;

/*----+-------------------------------------------------*
 | id | results                                         |
 +----+-------------------------------------------------+
 | 1  | [{"index":null,"value":"0.12679902142647365"},  |
 |    |  {"index":"I","value":"0.1412163100645339"},    |
 |    |  {"index":"like","value":"0.1412163100645339"}, |
 |    |  {"index":"pie","value":"0.29389333245105953"}] |
 +----+-------------------------------------------------+
 | 2  | [{"index":null,"value":"0.5705955964191315"},   |
 |    |  {"index":"pie","value":"0.14694666622552977"}] |
 +----+-------------------------------------------------+
 | 3  | [{"index":null,"value":"0.380397064279421"},    |
 |    |  {"index":"I","value":"0.21182446509680086"},   |
 |    |  {"index":"pie","value":"0.14694666622552977"}] |
 +----+-------------------------------------------------+
 | 4  | [{"index":null,"value":"0.45647647713530515"},  |
 |    |  {"index":"like","value":"0.1694595720774407"}, |
 |    |  {"index":"pie","value":"0.11755733298042381"}] |
 *----+-------------------------------------------------*/