Tutorial: generare WordCloud in Python

Che cos’è una word cloud?

Avrai spesso visto una nuvola piena di parole di dimensioni diverse, che rappresentano la frequenza o l’importanza di ciascun termine. Si chiama Tag Cloud o word cloud. In questo tutorial imparerai a creare una word cloud in Python e a personalizzarla come preferisci. Questo strumento è utile per esplorare dati testuali e rendere le tue presentazioni più vivaci.

Esercitati a generare una WordCloud in Python con questo esercizio pratico.

In questo tutorial useremo un dataset di recensioni di vini dal sito Wine Enthusiast per imparare a:

• Creare una word cloud di base da uno o più documenti testuali
• Regolare colore, dimensione e numero di parole all’interno della word cloud
• Mascherare la word cloud in qualsiasi forma tu preferisca
• Applicare alla word cloud uno schema di colori a tua scelta

Quando usare una word cloud

Ricorda che, sebbene le word cloud siano utili per visualizzare le parole comuni in un testo o in un dataset, di solito servono soprattutto come panoramica ad alto livello dei temi. Sono simili ai grafici a barre, ma spesso più accattivanti (anche se talvolta più difficili da interpretare). Le word cloud possono essere particolarmente utili quando vuoi:

• Identificare rapidamente i temi o gli argomenti più importanti in un ampio corpo di testo
• Capire il sentimento complessivo o il tono di uno scritto
• Esplorare pattern o trend in dati che contengono informazioni testuali
• Comunicare idee o concetti chiave in modo visivamente coinvolgente

Tuttavia, tieni presente che le word cloud non forniscono contesto né una comprensione profonda delle parole e delle frasi usate. Dovrebbero quindi essere accompagnate da altri metodi per analizzare e interpretare i dati testuali.

Prerequisiti

Per iniziare a creare una word cloud in Python, ti servirà installare i seguenti pacchetti:

• numpy
• pandas
• matplotlib
• pillow
• wordcloud

La libreria numpy è una delle più diffuse e utili per gestire array e matrici multidimensionali. Viene spesso usata insieme a pandas per svolgere analisi dei dati.

Il modulo Python os è una libreria integrata, quindi non serve installarla. Per saperne di più sulla gestione dei file con il modulo os, può esserti utile questo tutorial su lettura e scrittura di file in Python di DataCamp.

Per la visualizzazione, matplotlib è una libreria di base su cui si appoggiano molte altre librerie per generare grafici, tra cui seaborn o wordcloud, che userai in questo tutorial. La libreria pillow permette di leggere immagini. Pillow è un wrapper di PIL - Python Imaging Library. Ti servirà per leggere un’immagine da usare come maschera per la word cloud.

wordcloud può essere un po’ insidiosa da installare. Se ti basta generare una word cloud di base, allora pip install wordcloud o conda install -c conda-forge wordcloud sono sufficienti. Tuttavia, l’ultima versione, che permette di mascherare la nuvola in qualsiasi forma tu voglia, richiede un metodo di installazione diverso, come segue:

git clone https://github.com/amueller/word_cloud.git
cd word_cloud
pip install .

Dataset:

Questo tutorial usa il dataset di recensioni di vini da Kaggle. È un ottimo dataset per imparare: non ha valori mancanti (che richiederebbero tempo per essere gestiti) e include molti testi (recensioni di vini), dati categoriali e numerici.

Creare una word cloud in Python: preparazione 

Installa le librerie necessarie

Per prima cosa, carica tutte le librerie necessarie:

# Start with loading all necessary libraries
import numpy as np
import pandas as pd
from os import path
from PIL import Image
from wordcloud import WordCloud, STOPWORDS, ImageColorGenerator

import matplotlib.pyplot as plt
% matplotlib inline

c:\intelpython3\lib\site-packages\matplotlib\__init__.py:
import warnings
warnings.filterwarnings("ignore")

Se hai più di 10 librerie, organizzale per sezioni (ad esempio librerie di base, visualizzazione, modelli, ecc.). Usare i commenti renderà il codice pulito e facile da seguire.

Carica i dati nel dataframe 

Ora, usa read_csv di pandas per caricare il dataframe. Nota l’uso di index_col=0, che significa che non leggiamo il nome della riga (indice) come colonna separata.

# Load in the dataframe
df = pd.read_csv("data/winemag-data-130k-v2.csv", index_col=0)

# Looking at first 5 rows of the dataset
df.head()

Puoi stampare alcune informazioni di base sul dataset usando print() insieme a .format() per un’uscita più gradevole.

print("There are {} observations and {} features in this dataset. \n".format(df.shape[0],df.shape[1]))

print("There are {} types of wine in this dataset such as {}... \n".format(len(df.variety.unique()),
                                                                           ", ".join(df.variety.unique()[0:5])))

print("There are {} countries producing wine in this dataset such as {}... \n".format(len(df.country.unique()),
                                                                                      ", ".join(df.country.unique()[0:5])))

There are 129971 observations and 13 features in this dataset.

There are 708 types of wine in this dataset such as White Blend, Portuguese Red, Pinot Gris, Riesling, Pinot Noir...

There are 44 countries producing wine in this dataset such as Italy, Portugal, US, Spain, France...

df[["country", "description","points"]].head()

Crea gruppi per confrontare le caratteristiche

Per confrontare gruppi di una variabile, puoi usare groupby() e calcolare statistiche riassuntive.

Con il dataset dei vini, puoi raggruppare per paese e guardare le statistiche riassuntive dei punti e del prezzo per tutti i paesi oppure selezionare i più popolari e costosi.

# Groupby by country
country = df.groupby("country")

# Summary statistic of all countries
country.describe().head()

Questo seleziona i 5 paesi con la media punti più alta tra tutti i 44:

country.mean().sort_values(by="points",ascending=False).head()

Visualizza i dati

Puoi tracciare il numero di vini per paese usando il metodo plot di Pandas DataFrame e Matplotlib. Se non conosci Matplotlib, dai un’occhiata al nostro tutorial su Matplotlib.

plt.figure(figsize=(15,10))
country.size().sort_values(ascending=False).plot.bar()
plt.xticks(rotation=50)
plt.xlabel("Country of Origin")
plt.ylabel("Number of Wines")
plt.show()

Tra i 44 paesi produttori di vino, gli Stati Uniti hanno più di 50.000 tipologie nel dataset di recensioni, il doppio rispetto al successivo in classifica, la Francia — celebre per il vino. Anche l’Italia produce molti vini di qualità, con quasi 20.000 etichette recensite.

Esamina i dati

Guardiamo ora il grafico di tutti i 44 paesi in base al vino con il punteggio più alto, usando la stessa tecnica di plotting vista sopra:

plt.figure(figsize=(15,10))
country.max().sort_values(by="points",ascending=False)["points"].plot.bar()
plt.xticks(rotation=50)
plt.xlabel("Country of Origin")
plt.ylabel("Highest point of Wines")
plt.show()

Australia, Stati Uniti, Portogallo, Italia e Francia hanno tutti vini da 100 punti. Nota che il Portogallo è 5º e l’Australia 9ª per numero di vini nel dataset, e entrambi hanno meno di 8000 etichette.
Questa è stata una breve esplorazione per prendere confidenza con il dataset. Ora passiamo al piatto forte: la word cloud.

Impostare una word cloud di base in Python

Per iniziare

Una word cloud è una tecnica per mostrare quali parole sono più frequenti in un testo. Possiamo usare una libreria Python per aiutarci. Prima di usare qualsiasi funzione, può essere utile consultare la docstring per vedere tutti gli argomenti richiesti e opzionali. Per farlo, digita ?function ed esegui per ottenere tutte le informazioni.

?WordCloud

Init signature: WordCloud(font_path=None, width=400, height=200, margin=2, ranks_only=None, prefer_horizontal=0.9, mask=None, scale=1, color_func=None, max_words=200, min_font_size=4, stopwords=None, random_state=None, background_color='black', max_font_size=None, font_step=1, mode='RGB', relative_scaling=0.5, regexp=None, collocations=True, colormap=None, normalize_plurals=True, contour_width=0, contour_color='black')
Docstring:     
Word cloud object for generating and drawing.

Parameters
----------
font_path : string
    Font path to the font that will be used (OTF or TTF).
    Defaults to DroidSansMono path on a Linux machine. If you are on
    another OS or don't have this font; you need to adjust this path.

width : int (default=400)
    Width of the canvas.

height : int (default=200)
    Height of the canvas.

prefer_horizontal : float (default=0.90)
    The ratio of times to try horizontal fitting as opposed to vertical.
    If prefer_horizontal < 1, the algorithm will try rotating the word
    if it doesn't fit. (There is currently no built-in way to get only
    vertical words.)

mask : nd-array or None (default=None)
    If not None, gives a binary mask on where to draw words. If mask is not
    None, width and height will be ignored, and the shape of mask will be
    used instead. All white (#FF or #FFFFFF) entries will be considered
    "masked out" while other entries will be free to draw on. [This
    changed in the most recent version!]

contour_width: float (default=0)
    If mask is not None and contour_width > 0, draw the mask contour.

contour_color: color value (default="black")
    Mask contour color.

scale : float (default=1)
    Scaling between computation and drawing. For large word-cloud images,
    using scale instead of larger canvas size is significantly faster, but
    might lead to a coarser fit for the words.

min_font_size : int (default=4)
    Smallest font size to use. Will stop when there is no more room in this
    size.

font_step : int (default=1)
    Step size for the font. font_step > 1 might speed up computation but
    give a worse fit.

max_words : number (default=200)
    The maximum number of words.

stopwords : set of strings or None
    The words that will be eliminated. If None, the build-in STOPWORDS
    list will be used.

background_color : color value (default="black")
    Background color for the word cloud image.

max_font_size : int or None (default=None)
    Maximum font size for the largest word. If None, the height of the image is
    used.

mode : string (default="RGB")
    Transparent background will be generated when mode is "RGBA" and
    background_color is None.

relative_scaling : float (default=.5)
    Importance of relative word frequencies for font-size.  With
    relative_scaling=0, only word-ranks are considered.  With
    relative_scaling=1, a word that is twice as frequent will have twice
    the size.  If you want to consider the word frequencies and not only
    their rank, relative_scaling around .5 often looks good.

    .. versionchanged: 2.0
        Default is now 0.5.

color_func : callable, default=None
    Callable with parameters word, font_size, position, orientation,
    font_path, random_state that returns a PIL color for each word.
    Overwrites "colormap".
    See colormap for specifying a matplotlib colormap instead.

regexp : string or None (optional)
    Regular expression to split the input text into tokens in process_text.
    If None is specified, ``r"\w[\w']+"`` is used.

collocations : bool, default=True
    Whether to include collocations (bigrams) of two words.

    .. versionadded: 2.0

colormap : string or matplotlib colormap, default="viridis"
    Matplotlib colormap to randomly draw colors from for each word.
    Ignored if "color_func" is specified.

    .. versionadded: 2.0

normalize_plurals : bool, default=True
    Whether to remove trailing 's' from words. If True and a word
    appears with and without a trailing 's', the one with trailing 's'
    is removed and its counts are added to the version without
    trailing 's' -- unless the word ends with 'ss'.

Attributes
----------
``words_`` : dict of string to float
    Word tokens with associated frequency.

    .. versionchanged: 2.0
        ``words_`` is now a dictionary

``layout_`` : list of tuples (string, int, (int, int), int, color))
    Encodes the fitted word cloud. Encodes for each word the string, font
    size, position, orientation, and color.

Notes
-----
Larger canvases will make the code significantly slower. If you need a
large word cloud, try a lower canvas size, and set the scale parameter.

The algorithm might give more weight to the ranking of the words
then their actual frequencies, depending on the ``max_font_size`` and the
scaling heuristic.
File:           c:\intelpython3\lib\site-packages\wordcloud\wordcloud.py
Type:           type

Come vedi, l’unico argomento obbligatorio per un oggetto WordCloud è il text, mentre tutti gli altri sono opzionali.

Parti da un input semplice

Iniziamo con un esempio semplice: usa la descrizione della prima osservazione come input per la word cloud. I tre passaggi sono:

• Estrarre la recensione (documento testuale)
• Creare e generare un’immagine di word cloud
• Visualizzare la nuvola con matplotlib

# Start with one review:
text = df.description[0]

# Create and generate a word cloud image:
wordcloud = WordCloud().generate(text)

# Display the generated image:
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()

Ottimo! Si vede che la prima recensione parla molto di aromi e sentori “dried”.

Modificare gli argomenti opzionali della word cloud

Ora modifica alcuni argomenti opzionali della word cloud come max_font_size, max_word e background_color.

# lower max_font_size, change the maximum number of word and lighten the background:
wordcloud = WordCloud(max_font_size=50, max_words=100, background_color="white").generate(text)
plt.figure()
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.show()

Sembra che usare max_font_size qui non sia l’idea migliore: rende più difficile cogliere le differenze tra le frequenze delle parole. Invece, schiarire lo sfondo rende la nuvola più leggibile.

Se vuoi salvare l’immagine, WordCloud fornisce la funzione to_file

# Save the image in the img folder:
wordcloud.to_file("img/first_review.png")

<wordcloud.wordcloud.WordCloud at 0x16f1d704978>

Il risultato apparirà così quando lo carichi:

Avrai probabilmente notato l’argomento interpolation="bilinear" in plt.imshow(). Serve a rendere l’immagine visualizzata più morbida. Per maggiori informazioni sulla scelta, questo tutorial sui metodi di interpolazione per imshow è una risorsa utile.

Combinare i dati

Ora combinerai tutte le recensioni in un unico grande testo e creerai una nuvola “corposa” per vedere quali caratteristiche sono più comuni in questi vini.

text = " ".join(review for review in df.description)
print ("There are {} words in the combination of all review.".format(len(text)))

There are 31661073 words in the combination of all review.

# Create stopword list:
stopwords = set(STOPWORDS)
stopwords.update(["drink", "now", "wine", "flavor", "flavors"])

# Generate a word cloud image
wordcloud = WordCloud(stopwords=stopwords, background_color="white").generate(text)

# Display the generated image:
# the matplotlib way:
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()

Sembra che “black cherry” e “full-bodied” siano le caratteristiche più menzionate, e che Cabernet Sauvignon sia la più popolare. Questo è in linea con il fatto che il Cabernet Sauvignon «è una delle varietà di uva a bacca rossa più riconosciute al mondo. È coltivata in quasi tutti i principali paesi produttori di vino, in un’ampia gamma di climi, dalla Okanagan Valley in Canada alla Beqaa Valley in Libano».^[1]

Visualizzazione della word cloud in Python

Ora versiamo queste parole in un calice (o persino in una bottiglia) di vino!

Per creare una forma per la tua word cloud, devi prima trovare un file PNG da usare come maschera. Qui sotto ce n’è una bella, disponibile online:

Non tutte le immagini usate come maschera hanno lo stesso formato, con risultati differenti e possibili malfunzionamenti della funzione WordCloud. Per assicurarti che la tua maschera funzioni, guardiamola sotto forma di array numpy:

wine_mask = np.array(Image.open("img/wine_mask.png"))
wine_mask

array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)

Il modo in cui funziona la mascheratura richiede che tutta la parte bianca della maschera sia 255 e non 0 (tipo intero). Questo valore rappresenta l’“intensità” del pixel. Valori pari a 255 sono bianco puro, mentre valori pari a 1 sono nero. Qui puoi usare la funzione seguente per trasformare la maschera se ha lo stesso formato sopra. Nota che se hai una maschera con sfondo non 0 ma 1 o 2, adatta la funzione alla tua maschera.

Per prima cosa usa la funzione transform_format() per scambiare lo 0 con 255.

def transform_format(val):
    if val == 0:
        return 255
    else:
        return val

Poi crea una nuova maschera con la stessa forma della maschera originale e applica la funzione transform_format() a ciascun valore in ogni riga della maschera precedente.

# Transform your mask into a new one that will work with the function:
transformed_wine_mask = np.ndarray((wine_mask.shape[0],wine_mask.shape[1]), np.int32)

for i in range(len(wine_mask)):
    transformed_wine_mask[i] = list(map(transform_format, wine_mask[i]))

Ora hai una nuova maschera nel formato corretto. Stampare la maschera trasformata è il modo migliore per controllare che la funzione abbia funzionato.

# Check the expected result of your mask
transformed_wine_mask

array([[255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255],
       ...,
       [255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255]])

Con la maschera giusta, puoi iniziare a creare la word cloud con la forma scelta. Nota che nella funzione WordCloud c’è l’argomento mask che prende la maschera trasformata creata sopra. contour_width e contour_color servono, come suggerisce il nome, ad aggiustare il contorno della nuvola. La bottiglia qui è di vino rosso, quindi “firebrick” sembra una buona scelta per il colore del contorno. Per altre opzioni di colore, dai un’occhiata a questa tabella dei codici colore.

# Create a word cloud image
wc = WordCloud(background_color="white", max_words=1000, mask=transformed_wine_mask,
               stopwords=stopwords, contour_width=3, contour_color='firebrick')

# Generate a wordcloud
wc.generate(text)

# store to file
wc.to_file("img/wine.png")

# show
plt.figure(figsize=[20,10])
plt.imshow(wc, interpolation='bilinear')
plt.axis("off")
plt.show()

Voilà! Hai creato una word cloud a forma di bottiglia di vino! Sembra che le descrizioni dei vini menzionino spesso black cherry, note fruttate e caratteristiche “full-bodied”. Ora diamo un’occhiata più da vicino alle recensioni per ciascun paese e tracciamo la word cloud usando la bandiera di ogni paese. Qui sotto trovi un esempio che creerai tra poco:

Creare una word cloud seguendo uno schema di colori

Puoi combinare tutte le recensioni dei cinque paesi con il maggior numero di vini. Per trovare questi paesi, puoi guardare il grafico paese vs numero di vini sopra oppure usare il gruppo calcolato in precedenza per trovare il numero di osservazioni per paese (per gruppo) e sort_values() con ascending=False per ordinare in modo decrescente.

country.size().sort_values(ascending=False).head()

country
US          54504
France      22093
Italy       19540
Spain        6645
Portugal     5691
dtype: int64

Ora quindi hai 5 paesi in testa: Stati Uniti, Francia, Italia, Spagna e Portogallo. Puoi cambiare il numero di paesi passando il numero desiderato a head() come sotto

country.size().sort_values(ascending=False).head(10)

country
US           54504
France       22093
Italy        19540
Spain         6645
Portugal      5691
Chile         4472
Argentina     3800
Austria       3345
Australia     2329
Germany       2165
dtype: int64

Per ora, cinque paesi bastano.

Per ottenere tutte le recensioni per ciascun paese, puoi concatenarle usando la sintassi " ".join(list), che unisce tutti gli elementi di una lista separandoli con uno spazio.

# Join all reviews of each country:
usa = " ".join(review for review in df[df["country"]=="US"].description)
fra = " ".join(review for review in df[df["country"]=="France"].description)
ita = " ".join(review for review in df[df["country"]=="Italy"].description)
spa = " ".join(review for review in df[df["country"]=="Spain"].description)
por = " ".join(review for review in df[df["country"]=="Portugal"].description)

Poi puoi creare la word cloud come descritto sopra. Puoi anche combinare i due passaggi di creazione e generazione in uno solo, come sotto. La mappatura dei colori viene fatta subito prima di plottare la nuvola usando la funzione ImageColorGenerator della libreria WordCloud.

# Generate a word cloud image
mask = np.array(Image.open("img/us.png"))
wordcloud_usa = WordCloud(stopwords=stopwords, background_color="white", mode="RGBA", max_words=1000, mask=mask).generate(usa)

# create coloring from image
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_usa.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# store to file
plt.savefig("img/us_wine.png", format="png")

plt.show()

Bene! Ora ripetiamo con una recensione dalla Francia.

# Generate a word cloud image
mask = np.array(Image.open("img/france.png"))
wordcloud_fra = WordCloud(stopwords=stopwords, background_color="white", mode="RGBA", max_words=1000, mask=mask).generate(fra)

# create coloring from image
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_fra.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# store to file
plt.savefig("img/fra_wine.png", format="png")

#plt.show()

Ricorda che dovresti salvare l’immagine dopo averla plottata per ottenere la word cloud con lo schema di colori desiderato.

# Generate a word cloud image
mask = np.array(Image.open("img/italy.png"))
wordcloud_ita = WordCloud(stopwords=stopwords, background_color="white", max_words=1000, mask=mask).generate(ita)

# create coloring from image
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_ita.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# store to file
plt.savefig("img/ita_wine.png", format="png")

#plt.show()

A seguire, la Spagna:

# Generate a word cloud image
mask = np.array(Image.open("img/spain.png"))
wordcloud_spa = WordCloud(stopwords=stopwords, background_color="white", max_words=1000, mask=mask).generate(spa)

# create coloring from image
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_spa.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# store to file
plt.savefig("img/spa_wine.png", format="png")
#plt.show()

Infine, il Portogallo:

# Generate a word cloud image
mask = np.array(Image.open("img/portugal.png"))
wordcloud_por = WordCloud(stopwords=stopwords, background_color="white", max_words=1000, mask=mask).generate(por)

# create coloring from image
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_por.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# store to file
plt.savefig("img/por_wine.png", format="png")
#plt.show()

Il risultato finale è nella tabella qui sotto per confrontare maschere e word cloud. Qual è la tua preferita?

Come interpretare le word cloud

Abbiamo visto vari esempi di word cloud e come crearle in Python. Vale però la pena capire come interpretare queste visualizzazioni. In generale, la dimensione di ogni parola nella nuvola rappresenta la sua frequenza o importanza nel testo. Di solito, più frequentemente una parola compare nel testo, più grande apparirà nella word cloud.

Ci sono alcune cose da tenere a mente quando interpreti una word cloud: 

• Fai attenzione alla dimensione delle parole: come detto, la dimensione di ciascuna parola corrisponde alla sua frequenza o importanza nel testo. Quindi, le parole più grandi sono in genere più significative nel messaggio complessivo.
• Cerca pattern: ci sono gruppi di parole che compaiono spesso insieme? Questo può indicare un tema o un argomento importante nel testo.
• Considera il contesto: ricorda che la word cloud rappresenta solo le parole che compaiono nel testo e non fornisce informazioni sul loro significato o su come vengono usate. È quindi importante pensare al contesto del testo e ai significati specifici delle parole usate.
• Attenzione agli outlier: a volte una parola può apparire molto grande nella word cloud semplicemente perché ricorre spesso, anche se non è particolarmente significativa o rilevante per il messaggio complessivo. Tieni d’occhio questi outlier e prova a concentrarti sulle parole e sui pattern più significativi.

In sintesi, una word cloud può essere uno strumento utile per visualizzare rapidamente i temi e le idee chiave di un testo. Ricorda però che è solo uno degli strumenti per analizzare dati testuali e andrebbe usata insieme ad altri metodi per un’analisi e una comprensione più profonde.

Complimenti!

Ce l’hai fatta! Hai imparato diversi modi per disegnare una word cloud in Python usando la libreria WordCloud, utile per visualizzare qualsiasi analisi testuale. Hai anche visto come mascherare la nuvola in qualsiasi forma e usare i colori che preferisci. Se vuoi esercitarti, prova il progetto di DataCamp: Gli argomenti più caldi del Machine Learning

Se vuoi approfondire l’Elaborazione del Linguaggio Naturale, segui il nostro percorso Fondamenti di NLP in Python.