1. Présentation
Le traitement du langage naturel (TLN) consiste à dégager des insights et à effectuer des analyses sur des données textuelles. À mesure que la quantité de texte générée sur Internet continue de croître, les entreprises cherchent plus que jamais à exploiter leurs textes pour obtenir des informations pertinentes pour leur activité.
Le traitement automatique du langage naturel peut être utilisé pour tout, de la traduction de langues à l'analyse des sentiments, en passant par la génération de phrases à partir de zéro, et bien plus encore. Il s'agit d'un domaine de recherche actif qui transforme notre façon de travailler avec le texte.
Nous allons voir comment utiliser le NLP à grande échelle sur de grandes quantités de données textuelles. Cette tâche peut s'avérer ardue. Heureusement, nous allons utiliser des bibliothèques telles que Spark MLlib et spark-nlp pour faciliter cette tâche.
2. Notre cas d'utilisation
Le Chief Data Scientist de notre organisation (fictive) "FoodCorp" souhaite en savoir plus sur les tendances du secteur alimentaire. Nous avons accès à un corpus de données textuelles sous la forme de posts du subreddit Reddit r/food que nous utiliserons pour explorer les sujets abordés par les utilisateurs.
Pour ce faire, vous pouvez utiliser une méthode de NLP appelée "modélisation de sujets". Le modèle de sujets est une méthode statistique qui permet d'identifier des tendances dans les significations sémantiques d'un groupe de documents. En d'autres termes, nous pouvons créer un modèle de sujets sur notre corpus de "posts" Reddit, qui générera une liste de "thèmes" ou groupes de mots décrivant une tendance.
Pour créer notre modèle, nous allons utiliser un algorithme appelé LDA (Latent Dirichlet Allocation), qui est souvent utilisé pour regrouper du texte. Vous trouverez une excellente introduction à la LDA sur cette page.
3. Créer un projet
Si vous ne possédez pas encore de compte Google (Gmail ou Google Apps), vous devez en créer un. Connectez-vous à la console Google Cloud Platform ( console.cloud.google.com) et créez un projet:
Vous devez ensuite activer la facturation dans Cloud Console pour pouvoir utiliser les ressources Google Cloud.
Suivre cet atelier de programmation ne devrait pas vous coûter plus d'un euro. Cependant, cela peut s'avérer plus coûteux si vous décidez d'utiliser davantage de ressources ou si vous n'interrompez pas les ressources. Les ateliers de programmation PySpark-BigQuery et Spark-NLP expliquent chacun la section "Nettoyage" à la fin.
Les nouveaux utilisateurs de Google Cloud Platform peuvent bénéficier d'un essai sans frais avec 300$de crédits.
4. Configurer notre environnement
Tout d'abord, nous devons activer Dataproc et les API Compute Engine.
Cliquez sur l'icône de menu en haut à gauche de l'écran.
Sélectionnez "API Manager" dans le menu déroulant.
Cliquez sur Activer les API et les services.
Recherchez "Compute Engine" dans le champ de recherche. Cliquez sur "API Google Compute Engine" dans la liste des résultats qui s'affiche.
Sur la page Google Compute Engine, cliquez sur Activer.
Une fois l'option activée, cliquez sur la flèche vers la gauche pour revenir en arrière.
Recherchez maintenant "API Google Dataproc" et activez-la également.
Ouvrez ensuite Cloud Shell en cliquant sur le bouton en haut à droite de la console Cloud:
Nous allons définir des variables d'environnement que nous pourrons référencer au fur et à mesure de l'atelier de programmation. Commencez par choisir un nom pour le cluster Dataproc que nous allons créer, par exemple "my-cluster", et définissez-le dans votre environnement. N'hésitez pas à utiliser le nom de votre choix.
CLUSTER_NAME=my-cluster
Choisissez ensuite une zone parmi celles disponibles ici. Par exemple, us-east1-b.
REGION=us-east1
Enfin, nous devons définir le bucket source à partir duquel notre tâche lira les données. Des exemples de données sont disponibles dans le bucket bm_reddit, mais n'hésitez pas à utiliser les données que vous avez générées à partir de l'atelier PySpark pour prétraiter les données BigQuery si vous l'avez terminé avant celui-ci.
BUCKET_NAME=bm_reddit
Maintenant que nos variables d'environnement sont configurées, exécutons la commande suivante pour créer notre cluster Dataproc:
gcloud beta dataproc clusters create ${CLUSTER_NAME} \
--region ${REGION} \
--metadata 'PIP_PACKAGES=google-cloud-storage spark-nlp==2.7.2' \
--worker-machine-type n1-standard-8 \
--num-workers 4 \
--image-version 1.4-debian10 \
--initialization-actions gs://dataproc-initialization-actions/python/pip-install.sh \
--optional-components=JUPYTER,ANACONDA \
--enable-component-gateway
Passons en revue chacune de ces commandes:
gcloud beta dataproc clusters create ${CLUSTER_NAME}: lance la création d'un cluster Dataproc avec le nom que vous avez fourni précédemment. Nous incluons beta ici pour activer les fonctionnalités bêta de Dataproc, telles que la passerelle des composants, que nous décrivons ci-dessous.
--zone=${ZONE}: définit l'emplacement du cluster.
--worker-machine-type n1-standard-8: type de machine à utiliser pour nos nœuds de calcul.
--num-workers 4: Nous aurons quatre nœuds de calcul dans notre cluster.
--image-version 1.4-debian9: indique la version d'image de Dataproc que nous utiliserons.
--initialization-actions ...: les actions d'initialisation sont des scripts personnalisés exécutés lors de la création de clusters et de workers. Elles peuvent être créées par l'utilisateur et stockées dans un bucket GCS ou référencées à partir du bucket public dataproc-initialization-actions. L'action d'initialisation incluse ici permet d'installer des packages Python à l'aide de Pip, comme indiqué avec l'option --metadata.
--metadata 'PIP_PACKAGES=google-cloud-storage spark-nlp': liste des packages à installer dans Dataproc, séparés par des espaces. Dans ce cas, nous allons installer la bibliothèque cliente Python google-cloud-storage et spark-nlp.
--optional-components=ANACONDA: les composants facultatifs sont des packages courants utilisés avec Dataproc qui sont automatiquement installés sur les clusters Dataproc lors de leur création. Les avantages de l'utilisation de composants facultatifs par rapport aux actions d'initialisation incluent des temps de démarrage plus rapides et des tests pour des versions spécifiques de Dataproc. Globalement, ils sont plus fiables.
--enable-component-gateway: cet indicateur nous permet d'utiliser la passerelle des composants Dataproc pour afficher des UI courantes telles que Zeppelin, Jupyter ou l'historique Spark. Remarque: Certains d'entre eux nécessitent le composant facultatif associé.
Pour une présentation plus détaillée de Dataproc, consultez cet atelier de programmation.
Ensuite, exécutez les commandes suivantes dans votre session Cloud Shell pour cloner le dépôt avec l'exemple de code et accéder au répertoire approprié:
cd
git clone https://github.com/GoogleCloudPlatform/cloud-dataproc
cd cloud-dataproc/codelabs/spark-nlp
5. MLlib Spark
Spark MLlib est une bibliothèque de machine learning évolutive écrite en Apache Spark. En exploitant l'efficacité de Spark avec une suite d'algorithmes de machine learning affinés, MLlib peut analyser de grandes quantités de données. Il propose des API en Java, Scala, Python et R. Dans cet atelier de programmation, nous allons nous concentrer spécifiquement sur Python.
MLlib contient un grand nombre de transformateurs et d'estimateurs. Un transformateur est un outil qui peut modifier ou altérer vos données, généralement à l'aide d'une fonction transform(), tandis qu'un estimateur est un algorithme prédéfini sur lequel vous pouvez entraîner vos données, généralement à l'aide d'une fonction fit().
Voici quelques exemples de transformateurs:
- la tokenisation (création d'un vecteur de nombres à partir d'une chaîne de mots) ;
- Encodage one-hot (création d'un vecteur de nombres clairsemés représentant les mots présents dans une chaîne)
- Outil de suppression des mots vides (supprime les mots qui n'ajoutent aucune valeur sémantique à une chaîne)
Voici quelques exemples d'estimateurs:
- classification (s'agit-il d'une pomme ou d'une orange ?)
- régression (combien cette pomme devrait-elle coûter ?)
- le clustering (dans quelle mesure les pommes sont-elles similaires les unes aux autres ?) ;
- Arbres de décision (si la couleur est orange, alors il s'agit d'une orange. Sinon, il s'agit d'une pomme.)
- réduction de la dimensionnalité (pouvons-nous supprimer des caractéristiques de notre ensemble de données tout en distinguant une pomme d'une orange ?) ;
MLlib contient également des outils pour d'autres méthodes courantes du machine learning, comme le réglage et la sélection des hyperparamètres, ainsi que la validation croisée.
De plus, MLlib contient l'API Pipelines, qui vous permet de créer des pipelines de transformation de données à l'aide de différents transformateurs pouvant être réexécutés.
6. Spark-NLP
Spark-nlp est une bibliothèque créée par John Snow Labs pour effectuer des tâches de traitement du langage naturel efficaces à l'aide de Spark. Il contient des outils intégrés appelés annoteurs pour les tâches courantes, comme:
- la tokenisation (création d'un vecteur de nombres à partir d'une chaîne de mots) ;
- créer des embeddings de mots (définir les relations entre les mots à l'aide de vecteurs) ;
- tags d'élément de discours (quels mots sont des noms ? qui sont des verbes ?).
Bien que cela ne soit pas le sujet de cet atelier de programmation, spark-nlp s'intègre également bien à TensorFlow.
Plus important encore, Spark-NLP étend les fonctionnalités de Spark MLlib en fournissant des composants qui s'intègrent facilement aux pipelines MLlib.
7. Bonnes pratiques pour le traitement du langage naturel
Avant de pouvoir extraire des informations utiles de nos données, nous devons effectuer quelques tâches de nettoyage. Voici les étapes de prétraitement que nous allons suivre:
Tokenisation
La première chose que nous voulons faire est de "tokeniser" les données. Il s'agit de prendre les données et de les diviser en fonction de "jetons" ou de mots. En règle générale, nous supprimons les signes de ponctuation et mettons tous les mots en minuscules à cette étape. Par exemple, supposons que nous ayons la chaîne suivante: What time is it? Après la tokenisation, cette phrase se composerait de quatre jetons: "what" , "time", "is", "it". Nous ne voulons pas que le modèle traite le mot what comme deux mots différents avec deux casses différentes. De plus, la ponctuation ne nous aide généralement pas à mieux déduire des informations à partir des mots. Nous la supprimons donc également.
Normalization
Nous souhaitons souvent "normaliser" les données. Les mots ayant une signification similaire seront remplacés par la même chose. Par exemple, si les mots "combattu", "bataillé" et "duelé" sont identifiés dans le texte, la normalisation peut remplacer "bataillé" et "duelé" par le mot "combattu".
Stemming
La recherche de radical remplace les mots par leur racine. Par exemple, les mots "voiture", "voitures" et "voitures" seront tous remplacés par le mot "voiture", car tous ces mots impliquent la même chose à la base.
Supprimer les mots vides
Les mots vides sont des mots tels que "et" et "le" qui n'ajoutent généralement rien à la signification sémantique d'une phrase. Nous souhaitons généralement les supprimer afin de réduire le bruit dans nos ensembles de données textuelles.
8. Exécuter la tâche
Voyons la tâche que nous allons exécuter. Vous trouverez le code à l'adresse cloud-dataproc/codelabs/spark-nlp/topic_model.py. Prenez au moins quelques minutes pour le lire et examiner les commentaires associés afin de comprendre ce qui se passe. Nous mettons également en évidence certaines des sections ci-dessous:
# Python imports
import sys
# spark-nlp components. Each one is incorporated into our pipeline.
from sparknlp.annotator import Lemmatizer, Stemmer, Tokenizer, Normalizer
from sparknlp.base import DocumentAssembler, Finisher
# A Spark Session is how we interact with Spark SQL to create Dataframes
from pyspark.sql import SparkSession
# These allow us to create a schema for our data
from pyspark.sql.types import StructField, StructType, StringType, LongType
# Spark Pipelines allow us to sequentially add components such as transformers
from pyspark.ml import Pipeline
# These are components we will incorporate into our pipeline.
from pyspark.ml.feature import StopWordsRemover, CountVectorizer, IDF
# LDA is our model of choice for topic modeling
from pyspark.ml.clustering import LDA
# Some transformers require the usage of other Spark ML functions. We import them here
from pyspark.sql.functions import col, lit, concat
# This will help catch some PySpark errors
from pyspark.sql.utils import AnalysisException
# Assign bucket where the data lives
try:
bucket = sys.argv[1]
except IndexError:
print("Please provide a bucket name")
sys.exit(1)
# Create a SparkSession under the name "reddit". Viewable via the Spark UI
spark = SparkSession.builder.appName("reddit topic model").getOrCreate()
# Create a three column schema consisting of two strings and a long integer
fields = [StructField("title", StringType(), True),
StructField("body", StringType(), True),
StructField("created_at", LongType(), True)]
schema = StructType(fields)
# We'll attempt to process every year / month combination below.
years = ['2016', '2017', '2018', '2019']
months = ['01', '02', '03', '04', '05', '06',
'07', '08', '09', '10', '11', '12']
# This is the subreddit we're working with.
subreddit = "food"
# Create a base dataframe.
reddit_data = spark.createDataFrame([], schema)
# Keep a running list of all files that will be processed
files_read = []
for year in years:
for month in months:
# In the form of <project-id>.<dataset>.<table>
gs_uri = f"gs://{bucket}/reddit_posts/{year}/{month}/{subreddit}.csv.gz"
# If the table doesn't exist we will simply continue and not
# log it into our "tables_read" list
try:
reddit_data = (
spark.read.format('csv')
.options(codec="org.apache.hadoop.io.compress.GzipCodec")
.load(gs_uri, schema=schema)
.union(reddit_data)
)
files_read.append(gs_uri)
except AnalysisException:
continue
if len(files_read) == 0:
print('No files read')
sys.exit(1)
# Replacing null values with their respective typed-equivalent is usually
# easier to work with. In this case, we'll replace nulls with empty strings.
# Since some of our data doesn't have a body, we can combine all of the text
# for the titles and bodies so that every row has useful data.
df_train = (
reddit_data
# Replace null values with an empty string
.fillna("")
.select(
# Combine columns
concat(
# First column to concatenate. col() is used to specify that we're referencing a column
col("title"),
# Literal character that will be between the concatenated columns.
lit(" "),
# Second column to concatenate.
col("body")
# Change the name of the new column
).alias("text")
)
)
# Now, we begin assembling our pipeline. Each component here is used to some transformation to the data.
# The Document Assembler takes the raw text data and convert it into a format that can
# be tokenized. It becomes one of spark-nlp native object types, the "Document".
document_assembler = DocumentAssembler().setInputCol("text").setOutputCol("document")
# The Tokenizer takes data that is of the "Document" type and tokenizes it.
# While slightly more involved than this, this is effectively taking a string and splitting
# it along ths spaces, so each word is its own string. The data then becomes the
# spark-nlp native type "Token".
tokenizer = Tokenizer().setInputCols(["document"]).setOutputCol("token")
# The Normalizer will group words together based on similar semantic meaning.
normalizer = Normalizer().setInputCols(["token"]).setOutputCol("normalizer")
# The Stemmer takes objects of class "Token" and converts the words into their
# root meaning. For instance, the words "cars", "cars'" and "car's" would all be replaced
# with the word "car".
stemmer = Stemmer().setInputCols(["normalizer"]).setOutputCol("stem")
# The Finisher signals to spark-nlp allows us to access the data outside of spark-nlp
# components. For instance, we can now feed the data into components from Spark MLlib.
finisher = Finisher().setInputCols(["stem"]).setOutputCols(["to_spark"]).setValueSplitSymbol(" ")
# Stopwords are common words that generally don't add much detail to the meaning
# of a body of text. In English, these are mostly "articles" such as the words "the"
# and "of".
stopword_remover = StopWordsRemover(inputCol="to_spark", outputCol="filtered")
# Here we implement TF-IDF as an input to our LDA model. CountVectorizer (TF) keeps track
# of the vocabulary that's being created so we can map our topics back to their
# corresponding words.
# TF (term frequency) creates a matrix that counts how many times each word in the
# vocabulary appears in each body of text. This then gives each word a weight based
# on its frequency.
tf = CountVectorizer(inputCol="filtered", outputCol="raw_features")
# Here we implement the IDF portion. IDF (Inverse document frequency) reduces
# the weights of commonly-appearing words.
idf = IDF(inputCol="raw_features", outputCol="features")
# LDA creates a statistical representation of how frequently words appear
# together in order to create "topics" or groups of commonly appearing words.
lda = LDA(k=10, maxIter=10)
# We add all of the transformers into a Pipeline object. Each transformer
# will execute in the ordered provided to the "stages" parameter
pipeline = Pipeline(
stages = [
document_assembler,
tokenizer,
normalizer,
stemmer,
finisher,
stopword_remover,
tf,
idf,
lda
]
)
# We fit the data to the model.
model = pipeline.fit(df_train)
# Now that we have completed a pipeline, we want to output the topics as human-readable.
# To do this, we need to grab the vocabulary generated from our pipeline, grab the topic
# model and do the appropriate mapping. The output from each individual component lives
# in the model object. We can access them by referring to them by their position in
# the pipeline via model.stages[<ind>]
# Let's create a reference our vocabulary.
vocab = model.stages[-3].vocabulary
# Next, let's grab the topics generated by our LDA model via describeTopics(). Using collect(),
# we load the output into a Python array.
raw_topics = model.stages[-1].describeTopics().collect()
# Lastly, let's get the indices of the vocabulary terms from our topics
topic_inds = [ind.termIndices for ind in raw_topics]
# The indices we just grab directly map to the term at position <ind> from our vocabulary.
# Using the below code, we can generate the mappings from our topic indices to our vocabulary.
topics = []
for topic in topic_inds:
_topic = []
for ind in topic:
_topic.append(vocab[ind])
topics.append(_topic)
# Let's see our topics!
for i, topic in enumerate(topics, start=1):
print(f"topic {i}: {topic}")
Exécuter la tâche
Exécutons maintenant notre tâche. Exécutez la commande suivante:
gcloud dataproc jobs submit pyspark --cluster ${CLUSTER_NAME}\
--region ${REGION}\
--properties=spark.jars.packages=com.johnsnowlabs.nlp:spark-nlp_2.11:2.7.2\
--driver-log-levels root=FATAL \
topic_model.py \
-- ${BUCKET_NAME}
Cette commande nous permet d'exploiter l'API Jobs de Dataproc. En incluant la commande pyspark, nous indiquons au cluster qu'il s'agit d'une tâche PySpark. Nous fournissons le nom du cluster, les paramètres facultatifs parmi ceux disponibles ici et le nom du fichier contenant la tâche. Dans notre cas, nous fournissons le paramètre --properties, qui nous permet de modifier diverses propriétés pour Spark, Yarn ou Dataproc. Nous modifions la propriété Spark packages, qui nous permet d'indiquer à Spark que nous souhaitons inclure spark-nlp dans le package de notre tâche. Nous fournissons également les paramètres --driver-log-levels root=FATAL, qui supprimeront la plupart des sorties de journal de PySpark, à l'exception des erreurs. En général, les journaux Spark sont bruyants.
Enfin, -- ${BUCKET} est un argument de ligne de commande pour le script Python lui-même qui fournit le nom du bucket. Notez l'espace entre -- et ${BUCKET}.
Après quelques minutes d'exécution de la tâche, nous devrions obtenir un résultat contenant nos modèles:
Génial ! Pouvez-vous déduire des tendances en examinant la sortie de votre modèle ? Vous préférez le nôtre ?
À partir de la sortie ci-dessus, on peut déduire une tendance du thème 8 concernant les aliments pour le petit-déjeuner et les desserts du thème 9.
9. Nettoyage
Pour éviter que des frais inutiles ne soient facturés sur votre compte GCP une fois ce démarrage rapide terminé:
- Supprimez le bucket Cloud Storage que vous avez créé pour l'environnement.
- Supprimez l'environnement Dataproc.
Si vous avez créé un projet spécifiquement pour cet atelier de programmation, vous pouvez également le supprimer:
- Dans la console GCP, accédez à la page Projects (Projets).
- Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans le champ, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
Licence
Ce document est publié sous une licence Creative Commons Attribution 3.0 Generic et une licence Apache 2.0.