Fonctions d'analyse de texte

GoogleSQL pour BigQuery est compatible avec les fonctions d'analyse de texte suivantes.

Liste des fonctions

Nom	Résumé
BAG_OF_WORDS	Récupère la fréquence de chaque terme (jeton) dans un document segmenté.
TEXT_ANALYZE	Extrait les termes (jetons) du texte et les convertit dans un document segmenté.
TF_IDF	Évalue la pertinence d'un terme (jeton) par rapport à un document segmenté dans un ensemble de documents segmentés.

BAG_OF_WORDS

Aperçu

Ce produit ou cette fonctionnalité est soumis aux "Conditions des offres pré-DG" de la section "Conditions d'utilisation générales du service" des Conditions spécifiques du service. Les produits et fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une compatibilité limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Remarque : Pour demander des conseils ou obtenir de l'aide pour cette fonctionnalité, envoyez un e-mail à l'adresse [e-mail].

BAG_OF_WORDS(tokenized_document)

Définition

Récupère la fréquence de chaque terme (jeton) dans un document segmenté.

Définitions

• tokenized_document : valeur ARRAY<STRING> représentant un document qui a été segmenté. Un document segmenté est un ensemble de termes (jetons) utilisés pour l'analyse de texte.

Type renvoyé

ARRAY<STRUCT<term STRING, count INT64>>

Définitions :

• term : terme unique dans le document segmenté.
• count : nombre de fois où le terme a été trouvé dans le document segmenté.

Exemples

La requête suivante produit des termes et leurs fréquences dans deux documents segmentés :

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

Aperçu

Ce produit ou cette fonctionnalité est soumis aux "Conditions des offres pré-DG" de la section "Conditions d'utilisation générales du service" des Conditions spécifiques du service. Les produits et fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une compatibilité limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Remarque : Pour demander des conseils ou obtenir de l'aide pour cette fonctionnalité, envoyez un e-mail à l'adresse [e-mail].

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

Description

Extrait les termes (jetons) du texte et les convertit dans un document segmenté.

Définitions

• text : valeur STRING représentant le texte d'entrée à segmenter.

• analyzer : argument facultatif obligatoirement nommé qui détermine l'analyseur à utiliser pour convertir text en un tableau de termes (jetons). Il peut s'agir de :

  • 'LOG_ANALYZER' (par défaut) : divise l'entrée en termes lorsque des délimiteurs sont présents, puis normalise les termes. Cette option est utilisée par défaut si analyzer n'est pas spécifié. Pour en savoir plus, consultez la section Analyseur de texte LOG_ANALYZER.

  • 'NO_OP_ANALYZER' : extrait le texte en tant que terme unique (jeton), mais n'applique pas la normalisation. Pour en savoir plus, consultez la section Analyseur de texte NO_OP_ANALYZER.

  • 'PATTERN_ANALYZER' : divise l'entrée en termes correspondant à une expression régulière. Pour en savoir plus, consultez la section Analyseur de texte PATTERN_ANALYZER.

• analyzer_options : argument facultatif obligatoirement nommé qui prend une liste de règles d'analyse de texte en tant que STRING au format JSON. Pour en savoir plus, consultez la section Options des analyseurs de texte.

Détails

Il n'existe aucune garantie quant à l'ordre des jetons générés par cette fonction.

Si aucun analyseur n'est spécifié, l'analyseur LOG_ANALYZER est utilisé par défaut.

Type renvoyé

ARRAY<STRING>

Exemples

La requête suivante utilise l'analyseur de texte par défaut, LOG_ANALYZER, avec le texte d'entrée :

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 requête suivante utilise l'analyseur de texte NO_OP_ANALYZER avec le texte d'entrée :

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 requête suivante utilise l'analyseur de texte PATTERN_ANALYZER avec le texte d'entrée :

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' ] |
 *----------------------------------------------------------------*/

Pour obtenir d'autres exemples incluant des options d'analyse, consultez la page Analyse de texte.

Pour obtenir des recettes d'analyseurs à utiliser pour améliorer les requêtes compatibles avec les analyseurs, consultez la page Effectuer des recherches avec des analyseurs de texte.

TF_IDF

Aperçu

Ce produit ou cette fonctionnalité est soumis aux "Conditions des offres pré-DG" de la section "Conditions d'utilisation générales du service" des Conditions spécifiques du service. Les produits et fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une compatibilité limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Remarque : Pour demander des conseils ou obtenir de l'aide pour cette fonctionnalité, envoyez un e-mail à l'adresse [e-mail].

TF_IDF(tokenized_document) OVER()

TF_IDF(tokenized_document, max_distinct_tokens) OVER()

TF_IDF(tokenized_document, max_distinct_tokens, frequency_threshold) OVER()

Description

Évalue la pertinence d'un terme par rapport à un document segmenté dans un ensemble de documents segmentés, à l'aide de l'algorithme TF-IDF (fréquence du terme – fréquence inverse des documents).

Définitions

• tokenized_document : valeur ARRAY<STRING> représentant un document qui a été segmenté. Un document segmenté est un ensemble de termes (jetons) utilisés pour l'analyse de texte.

• max_distinct_tokens : argument facultatif. Prend une valeur INT64 non négative, qui représente la taille du dictionnaire, à l'exclusion du terme inconnu.

  Les termes sont ajoutés au dictionnaire jusqu'à ce que ce seuil soit atteint. Ainsi, si cette valeur est 20, les 20 premiers termes uniques sont ajoutés, puis aucun terme supplémentaire n'est ajouté.

  Si cet argument n'est pas fourni, la valeur par défaut est 32000. Si cet argument est spécifié, la valeur maximale est 1048576.

• frequency_threshold : argument facultatif. Prend une valeur INT64 non négative qui représente le nombre minimal de fois où un terme doit apparaître dans un document segmenté pour être inclus dans le dictionnaire. Ainsi, si cette valeur est 3, un terme doit apparaître au moins trois fois dans le document segmenté pour être ajouté au dictionnaire.

  Si cet argument n'est pas fourni, la valeur par défaut est 5.

Détails

Cette fonction utilise un algorithme TF-IDF (fréquence du terme – fréquence inverse des documents) pour calculer la pertinence des termes dans un ensemble de documents segmentés. TF-IDF multiplie deux métriques : le nombre de fois où un terme apparaît dans un document (fréquence du terme) et la fréquence inverse des documents du terme dans un ensemble de documents (fréquence inverse des documents).

• TDIF :

  term frequency * inverse document frequency
  

• Fréquence du terme :

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

• Fréquence inverse des documents :

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

Les termes sont ajoutés à un dictionnaire de termes s'ils répondent aux critères de max_distinct_tokens et frequency_threshold. Sinon, ils sont considérés comme des termes inconnus. Le terme inconnu est toujours le premier terme du dictionnaire et est représenté par NULL. Le reste du dictionnaire est classé par fréquence de terme plutôt que par ordre alphabétique.

Type renvoyé

ARRAY<STRUCT<term STRING, tf_idf DOUBLE>>

Définitions :

• term : terme unique ajouté au dictionnaire.
• tf_idf : calcul TF-IDF pour le terme.

Exemples

La requête suivante calcule la pertinence d'un maximum de 10 termes qui apparaissent au moins deux fois dans un ensemble de documents segmentés. Dans cet exemple, les arguments nommés sont transmis en fonction de leur position. 10 représente max_distinct_tokens et 2 représente 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 requête suivante calcule la pertinence d'un maximum de trois termes qui apparaissent au moins une fois dans un ensemble de documents segmentés :

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"}] |
 *----+-------------------------------------------------*/