microsoftml.featurize_text : convertit les colonnes de texte en caractéristiques numériques

Article
05/23/2023

Usage

microsoftml.featurize_text(cols: [str, dict, list], language: ['AutoDetect',
    'English', 'French', 'German', 'Dutch', 'Italian', 'Spanish',
    'Japanese'] = 'English', stopwords_remover=None, case: ['Lower',
    'Upper', 'None'] = 'Lower', keep_diacritics: bool = False,
    keep_punctuations: bool = True, keep_numbers: bool = True,
    dictionary: dict = None, word_feature_extractor={'Name': 'NGram',
    'Settings': {'Weighting': 'Tf', 'MaxNumTerms': [10000000],
    'NgramLength': 1, 'AllLengths': True, 'SkipLength': 0}},
    char_feature_extractor=None, vector_normalizer: ['None', 'L1', 'L2',
    'LInf'] = 'L2', **kargs)

Description

Transformations de texte qui peuvent être effectuées sur les données avant d’effectuer l’apprentissage d’un modèle.

Détails

La transformation featurize_text génère un ensemble de nombres de séquences de mots consécutifs (appelées n-grammes) à partir d’un corpus de texte donné. Vous avez deux façons de procéder :

Générer un dictionnaire de n-grammes et utiliser l’ID dans le dictionnaire comme index dans le conteneur.
Hacher chaque n-gramme et utiliser la valeur de hachage en tant qu’index dans le conteneur.

Le hachage consiste à convertir des documents texte de longueur variable en vecteurs de fonctions numériques de longueur égale, pour prendre en charge la réduction de la dimensionnalité et accélérer la recherche du poids des fonctions.

Le processus de transformation de texte est appliqué aux colonnes d’entrée de texte. Il permet de détecter la langue, de créer des jetons, de supprimer les mots vides, de normaliser du texte et de générer des fonctionnalités. Il prend en charge les langues suivantes par défaut : anglais, français, allemand, néerlandais, italien, espagnol et japonais.

Les n-grammes sont représentés en tant que vecteurs de comptage, avec des emplacements vectorisés correspondant à n-grammes (créés à l’aide de n_gram) ou à leurs codes de hachage (créés à l’aide de n_gram_hash). L’incorporation des n-grammes dans un espace vectoriel permet de comparer efficacement leur contenu. Les valeurs d’emplacement dans le vecteur peuvent être pondérées par les facteurs suivants :

fréquence des termes : nombre d’occurrences de l’emplacement dans le texte
fréquence documentaire inverse : rapport (logarithme de la fréquence d’emplacement relative inverse) qui mesure l’information fournie par un emplacement en déterminant sa fréquence ou sa rareté dans l’ensemble du texte.
fréquence de termes-fréquence documentaire inversefréquence des termes et fréquence documentaire inverse.

Arguments

cols

Chaîne de caractères ou liste de noms de variables à transformer. Si dict, les clés représentent les noms des nouvelles variables à créer.

langage

Spécifie la langue utilisée dans le jeu de données. Les valeurs suivantes sont admises :

"AutoDetect" : pour la détection automatique de la langue.
"English"
"French"
"German"
"Dutch"
"Italian"
"Spanish"
"Japanese"

stopwords_remover

Spécifie l’utilitaire de suppression des mots vides à utiliser. Trois options sont prises en charge :

Aucun: aucun utilitaire de suppression des mots vides n’est utilisé.
predefined : une liste spécifique au langage précompilée de mots vides est utilisée et comprend les mots les plus courants de Microsoft Office.
custom : liste définie par l’utilisateur de mots vides. Elle accepte l’option suivante : stopword.

La valeur par défaut est Aucun.

casse

Casse du texte utilisant les règles de la culture dite indifférente. Prend les valeurs suivantes :

"Lower"
"Upper"
"None"

La valeur par défaut est "Lower".

keep_diacritics

False pour supprimer les signes diacritiques ; True pour conserver les signes diacritiques. La valeur par défaut est False.

keep_punctuations

False pour supprimer la ponctuation ; True pour conserver la ponctuation. La valeur par défaut est True.

keep_numbers

False pour supprimer des nombres ; True pour conserver les nombres. La valeur par défaut est True.

dictionnaire

Dictionnaire de termes de la liste d’autorisation qui accepte les options suivantes :

term : vecteur de caractères facultatif des termes ou des catégories.
dropUnknowns : abandonner les éléments.
sort : indique comment ordonner les éléments en cas de vectorisation. Deux commandes sont prises en charge :
- "occurrence" : les éléments apparaissent dans l’ordre rencontré.
- "value" : les éléments sont triés en fonction de leur comparaison par défaut. Par exemple, le tri de texte respecte la casse (par exemple, « A », « Z » puis « a »).

La valeur par défaut est Aucun. Notez que la liste de mots vides est prioritaire sur la liste d'autorisation du dictionnaire, car les mots vides sont supprimés avant que les termes du dictionnaire ne soient placés dans la liste d’autorisation.

word_feature_extractor

Indique les arguments de l’extraction de caractéristiques mots. Il existe deux mécanismes d’extraction de caractéristiques :

n_gram() : extraction de caractéristiques basée sur le nombre (équivalent à WordBag). Il accepte les options suivantes : max_num_terms et weighting.
n_gram_hash() : extraction de caractéristiques basée sur le hachage (équivalent à WordHashBag). Il accepte les options suivantes : hash_bits, seed, ordered et invert_hash.

La valeur par défaut est n_gram.

char_feature_extractor

Indique les arguments de l’extraction de caractéristiques caractères. Il existe deux mécanismes d’extraction de caractéristiques :

n_gram() : extraction de caractéristiques basée sur le nombre (équivalent à WordBag). Il accepte les options suivantes : max_num_terms et weighting.
n_gram_hash() : extraction de caractéristiques basée sur le hachage (équivalent à WordHashBag). Il accepte les options suivantes : hash_bits, seed, ordered et invert_hash.

La valeur par défaut est Aucun.

vector_normalizer

Normalise les vecteurs (lignes) individuellement par remise à l’échelle à la norme unitaire. Prend l’une des valeurs suivantes :

"None"
"L2"
"L1"
"LInf"

La valeur par défaut est "L2".

kargs

Arguments supplémentaires envoyés au moteur de calcul.

Retours

Objet définissant la transformation.

Voir aussi

n_gram, n_gram_hash, n_gram, n_gram_hash, get_sentiment.

Exemple

'''
Example with featurize_text and rx_logistic_regression.
'''
import numpy
import pandas
from microsoftml import rx_logistic_regression, featurize_text, rx_predict
from microsoftml.entrypoints._stopwordsremover_predefined import predefined


train_reviews = pandas.DataFrame(data=dict(
    review=[
        "This is great", "I hate it", "Love it", "Do not like it", "Really like it",
        "I hate it", "I like it a lot", "I kind of hate it", "I do like it",
        "I really hate it", "It is very good", "I hate it a bunch", "I love it a bunch",
        "I hate it", "I like it very much", "I hate it very much.",
        "I really do love it", "I really do hate it", "Love it!", "Hate it!",
        "I love it", "I hate it", "I love it", "I hate it", "I love it"],
    like=[True, False, True, False, True, False, True, False, True, False,
        True, False, True, False, True, False, True, False, True, False, True,
        False, True, False, True]))
        
test_reviews = pandas.DataFrame(data=dict(
    review=[
        "This is great", "I hate it", "Love it", "Really like it", "I hate it",
        "I like it a lot", "I love it", "I do like it", "I really hate it", "I love it"]))

out_model = rx_logistic_regression("like ~ review_tran",
                    data=train_reviews,
                    ml_transforms=[
                        featurize_text(cols=dict(review_tran="review"),
                            stopwords_remover=predefined(),
                            keep_punctuations=False)])
                            
# Use the model to score.
score_df = rx_predict(out_model, data=test_reviews, extra_vars_to_write=["review"])
print(score_df.head())

Sortie :

Beginning processing data.
Rows Read: 25, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 25, Read Time: 0, Transform Time: 0
Beginning processing data.
Not adding a normalizer.
Beginning processing data.
Rows Read: 25, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 25, Read Time: 0, Transform Time: 0
Beginning processing data.
LBFGS multi-threading will attempt to load dataset into memory. In case of out-of-memory issues, turn off multi-threading by setting trainThreads to 1.
Warning: Too few instances to use 4 threads, decreasing to 1 thread(s)
Beginning optimization
num vars: 11
improvement criterion: Mean Improvement
L1 regularization selected 3 of 11 weights.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.3725934
Elapsed time: 00:00:00.0131199
Beginning processing data.
Rows Read: 10, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0635453
Finished writing 10 rows.
Writing completed.
           review PredictedLabel     Score  Probability
0   This is great           True  0.443986     0.609208
1       I hate it          False -0.668449     0.338844
2         Love it           True  0.994339     0.729944
3  Really like it           True  0.443986     0.609208
4       I hate it          False -0.668449     0.338844

Partage via