Tutorial: Wordclouds genereren in Python

Wat is een wordcloud?

Je hebt vast weleens een wolk gezien vol woorden in verschillende groottes, die de frequentie of het belang van elk woord weergeven. Dit heet een tagcloud of wordcloud. In deze tutorial leer je hoe je in Python een wordcloud maakt en die naar wens aanpast. Dit is een handig hulpmiddel om tekstdata te verkennen en je rapport levendiger te maken.

Oefen met het genereren van een WordCloud in Python met deze praktische oefening.

In deze tutorial gebruiken we een dataset met wijnreviews van de Wine Enthusiast-website om te leren:

• Hoe je een basis-wordcloud maakt van één of meerdere tekstdocumenten
• De kleur, grootte en het aantal woorden in je wordcloud aanpassen
• Je wordcloud in elke gewenste vorm maskeren
• Je wordcloud in elk gewenst kleurpatroon maskeren

Wanneer gebruik je een wordcloud

Onthoud dat wordclouds handig zijn om veelvoorkomende woorden in een tekst of dataset te visualiseren, maar meestal vooral dienen als een overzicht op hoofdlijnen van thema’s. Ze lijken op staafdiagrammen, maar zijn vaak visueel aantrekkelijker (zij het soms lastiger te interpreteren). Wordclouds kunnen vooral nuttig zijn wanneer je wilt:

• Snel de belangrijkste thema’s of onderwerpen in een grote hoeveelheid tekst identificeren
• Het algemene sentiment of de toon van een tekst begrijpen
• Patronen of trends verkennen in data met tekstuele informatie
• De kernideeën of concepten op een visueel aansprekende manier communiceren

Houd er echter rekening mee dat wordclouds geen context of diepere duiding geven van de gebruikte woorden en zinnen. Gebruik ze daarom in combinatie met andere methoden om tekstdata te analyseren en te interpreteren.

Vereisten

Om te beginnen met het maken van een wordcloud in Python, moet je de volgende packages installeren:

• numpy
• pandas
• matplotlib
• pillow
• wordcloud

De numpy-bibliotheek is een van de meest populaire en nuttige libraries voor het werken met multidimensionale arrays en matrices. Ze wordt ook vaak samen met de pandas-bibliotheek gebruikt voor data-analyse.

De Python-module os is een ingebouwde bibliotheek, dus die hoef je niet te installeren. Wil je meer lezen over het werken met bestanden met de os-module, dan is deze DataCamp-tutorial over lezen en schrijven van bestanden in Python handig.

Voor visualisatie is matplotlib een basisbibliotheek waarop veel andere libraries draaien en op plotten, waaronder seaborn of wordcloud, die je in deze tutorial gebruikt. De pillow-bibliotheek is een package om afbeeldingen te lezen. Pillow is een wrapper voor PIL - Python Imaging Library. Je hebt deze bibliotheek nodig om een afbeelding in te lezen als masker voor de wordcloud.

wordcloud kan wat lastig te installeren zijn. Als je het alleen nodig hebt voor een basis-wordcloud, dan volstaat pip install wordcloud of conda install -c conda-forge wordcloud. De nieuwste versie, met de mogelijkheid om de wolk in elke gewenste vorm te maskeren, vereist echter een andere installatiemethode zoals hieronder:

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

Dataset:

Deze tutorial gebruikt de wine review-dataset van Kaggle. Deze collectie is een fijne dataset om mee te leren, met geen ontbrekende waarden (die tijd kosten om te verwerken) en veel tekst (wijnreviews), categorische en numerieke data.

Een wordcloud maken in Python: voorbereiding 

Installeer de benodigde libraries

Allereerst laad je alle benodigde libraries:

# Start met het laden van alle benodigde 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")

Als je meer dan tien libraries hebt, orden ze dan per sectie (zoals basislibs, visualisatie, modellen, enz.). Commentaar in je code houdt alles overzichtelijk en goed te volgen.

Laad de data in de dataframe 

Gebruik nu pandas read_csv om de dataframe in te laden. Let op het gebruik van index_col=0, wat betekent dat we de rijnamen (index) niet als aparte kolom inlezen.

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

# Bekijk de eerste 5 rijen van de dataset
df.head()

Je kunt wat basisinformatie over de dataset afdrukken met print() gecombineerd met .format() voor een nette weergave.

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()

Maak groepen om features te vergelijken

Om vergelijkingen te maken tussen groepen van een feature, kun je groupby() gebruiken en samenvattende statistieken berekenen.

Met de wijndataset kun je groeperen op land en kijken naar de samenvattende statistieken voor de punten en prijs van alle landen, of de populairste en duurste selecteren.

# Groepeer op land
country = df.groupby("country")

# Samenvattende statistieken van alle landen
country.describe().head()

Dit selecteert de top 5 met de hoogste gemiddelde score van alle 44 landen:

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

Plot de data

Je kunt het aantal wijnen per land plotten met de plotmethode van Pandas DataFrame en Matplotlib. Als je niet bekend bent met Matplotlib, bekijk dan snel onze Matplotlib-tutorial.

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()

Van de 44 landen die wijn produceren, heeft de VS meer dan 50.000 types in de wine review-dataset, twee keer zoveel als de volgende in de ranglijst, Frankrijk – het land dat beroemd is om zijn wijn. Italië produceert ook veel kwaliteitswijn, met bijna 20.000 wijnen die beoordeeld zijn.

Onderzoek de data

Laten we nu kijken naar de plot van alle 44 landen op basis van hun hoogst beoordeelde wijn, met dezelfde plottechniek als hierboven:

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()

Australië, de VS, Portugal, Italië en Frankrijk hebben allemaal wijnen met 100 punten. Als je oplet, staat Portugal op plek 5 en Australië op plek 9 qua aantal geproduceerde wijnen in de dataset, en beide landen hebben minder dan 8000 wijntypes.
Dat was wat data-exploratie om de dataset te leren kennen die je vandaag gebruikt. Nu gaan we naar het hoofdgerecht: de wordcloud.

Een basis-wordcloud opzetten in Python

Aan de slag

Een wordcloud is een techniek om te laten zien welke woorden het vaakst voorkomen in de opgegeven tekst. We kunnen hiervoor een Python-bibliotheek gebruiken. Het eerste wat je kunt doen voordat je functies gebruikt, is de docstring van de functie bekijken om alle vereiste en optionele argumenten te zien. Typ hiervoor ?function en voer dit uit om alle informatie te krijgen.

?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

Je ziet dat het enige vereiste argument voor een WordCloud-object de text is, terwijl alle andere optioneel zijn.

Begin met een eenvoudige invoer

Laten we beginnen met een eenvoudig voorbeeld: de beschrijving van de eerste observatie gebruiken als invoer voor de wordcloud. De drie stappen zijn:

• Haal de review op (tekstdocument)
• Maak en genereer een wordcloud-afbeelding
• Toon de cloud met matplotlib

# Begin met één review:
text = df.description[0]

# Maak en genereer een wordcloud-afbeelding:
wordcloud = WordCloud().generate(text)

# Toon de gegenereerde afbeelding:
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()

Mooi! Je ziet dat de eerste review veel spreekt over gedroogde smaken en de aroma’s van de wijn.

Optionele argumenten van de wordcloud wijzigen

Verander nu enkele optionele argumenten van de wordcloud zoals max_font_size, max_word en background_color.

# verlaag max_font_size, wijzig het maximumaantal woorden en maak de achtergrond lichter:
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()

Het lijkt erop dat max_font_size hier gebruiken geen goed idee is. Het maakt het lastiger om de verschillen tussen woordfrequenties te zien. Het oplichten van de achtergrond maakt de cloud echter makkelijker leesbaar.

Als je de afbeelding wilt opslaan, biedt WordCloud de functie to_file

# Sla de afbeelding op in de map img:
wordcloud.to_file("img/first_review.png")

<wordcloud.wordcloud.WordCloud at 0x16f1d704978>

Het resultaat ziet er zo uit wanneer je het inlaadt:

Je hebt waarschijnlijk het argument interpolation="bilinear" opgemerkt in plt.imshow(). Dit zorgt ervoor dat de getoonde afbeelding vloeiender lijkt. Voor meer informatie over de keuze is deze tutorial over interpolatiemethoden voor imshow een nuttige bron.

Data combineren

Nu combineer je alle wijnreviews tot één grote tekst en maak je een flinke cloud om te zien welke kenmerken het meest voorkomen in deze wijnen.

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.

# Maak een stopwoordlijst:
stopwords = set(STOPWORDS)
stopwords.update(["drink", "now", "wine", "flavor", "flavors"])

# Genereer een wordcloud-afbeelding
wordcloud = WordCloud(stopwords=stopwords, background_color="white").generate(text)

# Toon de gegenereerde afbeelding:
# de matplotlib-manier:
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()

Het lijkt erop dat zwarte kers en full-bodied de meest genoemde kenmerken zijn, en Cabernet Sauvignon de populairste van allemaal. Dit komt overeen met het feit dat Cabernet Sauvignon “een van ’s werelds meest herkenbare rode druivenrassen is. Het wordt geteeld in bijna elk belangrijk wijnproducerend land, in een breed spectrum aan klimaten, van Canada’s Okanagan Valley tot Libanon’s Bekavallei”.^[1]

Wordcloud-visualisatie in Python

Laten we deze woorden nu in een glas (of zelfs een fles) wijn gieten!

Om een vorm voor je wordcloud te maken, heb je eerst een PNG-bestand nodig dat als masker dient. Hieronder staat een mooie die online beschikbaar is:

Niet alle maskers hebben hetzelfde formaat, wat tot verschillende uitkomsten kan leiden en ervoor kan zorgen dat de WordCloud-functie niet goed werkt. Om zeker te weten dat je masker werkt, bekijken we het in numpy-arrayvorm:

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)

De manier waarop de maskerfunctie werkt, vereist dat alle witte delen van het masker 255 zijn en niet 0 (integer type). Deze waarde vertegenwoordigt de “intensiteit” van de pixel. Waarden van 255 zijn puur wit, terwijl waarden van 1 zwart zijn. Hier kun je de onderstaande functie gebruiken om je masker te transformeren als jouw masker hetzelfde formaat heeft als hierboven. Let op: als je een masker hebt waarvan de achtergrond niet 0 is, maar 1 of 2, pas dan de functie aan zodat die bij je masker past.

Eerst gebruik je de functie transform_format() om 0 om te zetten naar 255.

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

Maak vervolgens een nieuw masker met dezelfde vorm als het masker dat je hebt, en pas de functie transform_format() toe op elke waarde in elke rij van het vorige masker.

# Transformeer je masker naar een nieuw masker dat met de functie werkt:
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]))

Nu heb je een nieuw masker in de juiste vorm. Het afdrukken van het getransformeerde masker is de beste manier om te controleren of de functie goed werkt.

# Controleer het verwachte resultaat van je masker
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]])

Met het juiste masker kun je de wordcloud maken met de door jou gekozen vorm. Merk op dat er in de WordCloud-functie een argument mask is dat het getransformeerde masker inneemt dat je hierboven hebt gemaakt. De contour_width en contour_color zijn, zoals de naam al aangeeft, argumenten om de eigenschappen van de omlijning van de cloud aan te passen. De wijnfles hier is een rode wijnfles, dus firebrick lijkt een goede keuze voor de contourkleur. Voor meer kleurkeuzes kun je deze kleurenkaart bekijken.

# Maak een wordcloud-afbeelding
wc = WordCloud(background_color="white", max_words=1000, mask=transformed_wine_mask,
               stopwords=stopwords, contour_width=3, contour_color='firebrick')

# Genereer een wordcloud
wc.generate(text)

# opslaan naar bestand
wc.to_file("img/wine.png")

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

Voilà! Je hebt een wordcloud gemaakt in de vorm van een wijnfles! Het lijkt erop dat wijnbeschrijvingen vaak zwarte kers, fruitsmaken en full-bodied kenmerken noemen. Laten we nu de reviews per land nader bekijken en de wordcloud plotten met de vlag van elk land. Hieronder staat een voorbeeld dat je zo gaat maken:

Een wordcloud maken volgens een kleurpatroon

Je kunt alle reviews combineren van de vijf landen met de meeste wijnen. Om die landen te vinden, kun je ofwel kijken naar de plot land vs aantal wijnen hierboven, of gebruikmaken van de groep die je eerder maakte om het aantal observaties per land (per groep) te vinden en sort_values() met het argument ascending=False om aflopend te sorteren.

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

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

Je hebt nu dus de 5 toplanden: de VS, Frankrijk, Italië, Spanje en Portugal. Je kunt het aantal landen wijzigen door jouw gekozen aantal in head() te zetten, zoals hieronder

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

Voor nu zijn vijf landen genoeg.

Om alle reviews per land te krijgen, kun je alle reviews samenvoegen met de " ".join(list)-syntaxis, die alle elementen in een lijst samenvoegt en ze met een spatie scheidt.

# Voeg alle reviews per land samen:
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)

Vervolgens kun je de wordcloud maken zoals hierboven beschreven. Je kunt de twee stappen van maken en genereren combineren in één, zoals hieronder. De kleurmapping gebeurt vlak voor je de cloud plot met de functie ImageColorGenerator uit de WordCloud-bibliotheek.

# Genereer een wordcloud-afbeelding
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)

# maak kleuring op basis van de afbeelding
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_usa.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# opslaan naar bestand
plt.savefig("img/us_wine.png", format="png")

plt.show()

Ziet er goed uit! Laten we dit nu herhalen met een review uit Frankrijk.

# Genereer een wordcloud-afbeelding
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)

# maak kleuring op basis van de afbeelding
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_fra.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# opslaan naar bestand
plt.savefig("img/fra_wine.png", format="png")

#plt.show()

Let erop dat je de afbeelding moet opslaan na het plotten om de wordcloud met het gewenste kleurpatroon te krijgen.

# Genereer een wordcloud-afbeelding
mask = np.array(Image.open("img/italy.png"))
wordcloud_ita = WordCloud(stopwords=stopwords, background_color="white", max_words=1000, mask=mask).generate(ita)

# maak kleuring op basis van de afbeelding
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_ita.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# opslaan naar bestand
plt.savefig("img/ita_wine.png", format="png")

#plt.show()

Daarna Spanje:

# Genereer een wordcloud-afbeelding
mask = np.array(Image.open("img/spain.png"))
wordcloud_spa = WordCloud(stopwords=stopwords, background_color="white", max_words=1000, mask=mask).generate(spa)

# maak kleuring op basis van de afbeelding
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_spa.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# opslaan naar bestand
plt.savefig("img/spa_wine.png", format="png")
#plt.show()

En tot slot Portugal:

# Genereer een wordcloud-afbeelding
mask = np.array(Image.open("img/portugal.png"))
wordcloud_por = WordCloud(stopwords=stopwords, background_color="white", max_words=1000, mask=mask).generate(por)

# maak kleuring op basis van de afbeelding
image_colors = ImageColorGenerator(mask)
plt.figure(figsize=[7,7])
plt.imshow(wordcloud_por.recolor(color_func=image_colors), interpolation="bilinear")
plt.axis("off")

# opslaan naar bestand
plt.savefig("img/por_wine.png", format="png")
#plt.show()

Het eindresultaat staat in de onderstaande tabel om de maskers en de wordclouds te vergelijken. Welke is jouw favoriet?

Hoe interpreteer je wordclouds

We hebben nu verschillende voorbeelden van wordclouds gezien en hoe je ze in Python maakt. Het is echter de moeite waard om te bekijken hoe je deze datavisualisaties interpreteert. Over het algemeen geeft de grootte van elk woord in de cloud de frequentie of het belang ervan in de tekst weer. Meestal geldt: hoe vaker een woord in de tekst voorkomt, hoe groter het in de wordcloud verschijnt.

Er zijn een paar dingen om in gedachten te houden bij het interpreteren van wordclouds: 

• Let op de grootte van de woorden: Zoals gezegd komt de grootte van elk woord in de cloud overeen met de frequentie of het belang in de tekst. Grotere woorden zijn dus over het algemeen belangrijker voor de algemene boodschap van de tekst.
• Zoek naar patronen: Zijn er groepen woorden die vaak samen voorkomen? Dit kan wijzen op een thema of onderwerp dat belangrijk is in de tekst.
• Denk aan de context: Onthoud dat de wordcloud alleen de woorden weergeeft die in de tekst voorkomen en geen informatie geeft over hun betekenis of het gebruik. Het is daarom belangrijk om aan de context van de tekst en de specifieke betekenissen van de gebruikte woorden te denken.
• Wees alert op uitschieters: Soms verschijnt een woord heel groot in de wordcloud simpelweg omdat het vaak voorkomt, ook als het niet bijzonder betekenisvol of relevant is voor de algemene boodschap. Let op zulke uitschieters en focus op de woorden en patronen die het meest significant zijn.

Al met al kan een wordcloud een handig hulpmiddel zijn om snel de belangrijkste thema’s en ideeën in een tekst te visualiseren. Houd er echter rekening mee dat het slechts één hulpmiddel is voor het analyseren van tekstdata en dat het samen met andere methoden moet worden gebruikt voor diepere analyse en begrip.

Gefeliciteerd!

Je bent er! Je hebt verschillende manieren geleerd om een wordcloud in Python te tekenen met de WordCloud-bibliotheek, wat handig is voor de visualisatie van elke tekstanalyse. Je hebt ook geleerd hoe je de cloud naar elke vorm kunt maskeren en elke gewenste kleur kunt gebruiken. Wil je je skills oefenen, kijk dan eens naar DataCamp’s project: The Hottest Topics in Machine Learning

Als je meer wilt leren over Natural Language Processing, volg dan ons Natural Language Processing Fundamentals in Python-traject.