Tutorial Membuat WordCloud di Python

Apa itu Word Cloud?

Sering kali Anda melihat awan berisi banyak kata dengan berbagai ukuran yang merepresentasikan frekuensi atau pentingnya setiap kata. Ini disebut Tag Cloud atau word cloud. Dalam tutorial ini, Anda akan belajar cara membuat word cloud di Python dan menyesuaikannya sesuai kebutuhan. Alat ini akan berguna untuk mengeksplorasi data teks dan membuat laporan Anda lebih hidup.

Latih pembuatan WordCloud di Python dengan latihan praktis ini.

Dalam tutorial ini, kita akan menggunakan dataset ulasan wine dari situs Wine Enthusiast untuk mempelajari:

• Cara membuat word cloud dasar dari satu hingga beberapa dokumen teks
• Mengatur warna, ukuran, dan jumlah teks di dalam word cloud
• Mengubah bentuk word cloud sesuai bentuk pilihan Anda
• Mengikuti pola warna pilihan Anda untuk word cloud

Kapan Menggunakan Word Cloud

Penting untuk diingat bahwa meskipun word cloud berguna untuk memvisualisasikan kata-kata umum dalam teks atau himpunan data, biasanya word cloud hanya bermanfaat sebagai ikhtisar tingkat tinggi atas tema-tema. Ini mirip dengan diagram batang, tetapi sering kali lebih menarik secara visual (meski kadang lebih sulit ditafsirkan). Word cloud bisa sangat membantu ketika Anda ingin:

• Dengan cepat mengidentifikasi tema atau topik terpenting dalam korpus teks yang besar
• Memahami sentimen atau nada keseluruhan suatu tulisan
• Mengeksplorasi pola atau tren dalam data yang berisi informasi tekstual
• Menyampaikan gagasan atau konsep kunci dengan cara yang menarik secara visual

Namun, perlu diingat bahwa word cloud tidak memberikan konteks atau pemahaman yang lebih dalam tentang kata dan frasa yang digunakan. Karena itu, word cloud sebaiknya digunakan bersama metode lain untuk menganalisis dan menafsirkan data teks.

Prasyarat

Untuk mulai membuat word cloud di Python, Anda perlu memasang beberapa paket berikut:

• numpy
• pandas
• matplotlib
• pillow
• wordcloud

Pustaka numpy adalah salah satu pustaka paling populer dan bermanfaat untuk menangani array dan matriks multi-dimensi. Pustaka ini juga sering digunakan bersama pandas untuk melakukan analisis data.

Modul Python os adalah pustaka bawaan, jadi Anda tidak perlu memasangnya. Untuk membaca lebih lanjut tentang penanganan file dengan modul os, tutorial DataCamp ini tentang membaca dan menulis file di Python akan membantu.

Untuk visualisasi, matplotlib adalah pustaka dasar yang menjadi landasan banyak pustaka lain untuk berjalan dan memplot, termasuk seaborn atau wordcloud yang akan Anda gunakan dalam tutorial ini. Pustaka pillow memungkinkan pembacaan gambar. Pillow adalah pembungkus untuk PIL - Python Imaging Library. Anda memerlukan pustaka ini untuk membaca gambar sebagai mask untuk word cloud.

wordcloud bisa sedikit rumit saat dipasang. Jika Anda hanya membutuhkannya untuk memplot word cloud dasar, maka pip install wordcloud atau conda install -c conda-forge wordcloud sudah cukup. Namun, versi terbaru, dengan kemampuan memask awan ke bentuk apa pun pilihan Anda, memerlukan metode pemasangan berbeda seperti di bawah ini:

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

Dataset:

Tutorial ini menggunakan dataset ulasan wine dari Kaggle. Kumpulan ini sangat bagus untuk belajar karena tidak memiliki nilai hilang (yang memerlukan waktu untuk ditangani) dan memiliki banyak teks (ulasan wine), data kategorikal, dan numerik.

Membuat Word Cloud di Python: Persiapan 

Pasang pustaka yang diperlukan

Pertama-tama, muat semua pustaka yang diperlukan:

# 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")

Jika Anda memiliki lebih dari 10 pustaka, susun berdasarkan bagian (seperti pustaka dasar, visualisasi, model, dll.). Gunakan komentar di dalam kode untuk membuat kode Anda rapi dan mudah diikuti.

Muat data ke dalam dataframe 

Sekarang, gunakan read_csv dari pandas untuk memuat dataframe. Perhatikan penggunaan index_col=0 yang berarti kita tidak membaca nama baris (indeks) sebagai kolom terpisah.

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

Anda dapat mencetak beberapa informasi dasar tentang dataset menggunakan print() dikombinasikan dengan .format() untuk hasil cetak yang rapi.

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

Buat grup untuk membandingkan fitur

Untuk membuat perbandingan antar grup dari suatu fitur, Anda dapat menggunakan groupby() dan menghitung statistik ringkas.

Dengan dataset wine, Anda dapat melakukan pengelompokan berdasarkan negara dan melihat statistik ringkas untuk poin dan harga semua negara atau memilih yang paling populer dan mahal.

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

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

Ini memilih 5 rata-rata poin tertinggi di antara 44 negara:

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

Plot data

Anda dapat memplot jumlah wine berdasarkan negara menggunakan metode plot dari Pandas DataFrame dan Matplotlib. Jika Anda belum familiar dengan Matplotlib, lihat sekilas tutorial Matplotlib kami.

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

Di antara 44 negara yang memproduksi wine, AS memiliki lebih dari 50.000 jenis dalam dataset ulasan wine, dua kali lipat dari peringkat berikutnya, Prancis—negara yang terkenal dengan wine-nya. Italia juga memproduksi banyak wine berkualitas, dengan hampir 20.000 wine yang tersedia untuk diulas.

Periksa data

Sekarang mari lihat plot semua 44 negara berdasarkan wine dengan peringkat tertinggi, menggunakan teknik plot yang sama seperti di atas:

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, AS, Portugal, Italia, dan Prancis semuanya memiliki wine dengan 100 poin. Jika Anda perhatikan, Portugal berada di peringkat ke-5 dan Australia di peringkat ke-9 dalam jumlah wine yang diproduksi di dataset, dan kedua negara memiliki kurang dari 8000 jenis wine.
Itu sedikit eksplorasi data untuk mengenal dataset yang Anda gunakan hari ini. Sekarang Anda akan mulai masuk ke hidangan utama: word cloud.

Menyiapkan Word Cloud Dasar di Python

Mulai

Word cloud adalah teknik untuk menunjukkan kata-kata mana yang paling sering muncul dalam teks tertentu. Kita dapat menggunakan pustaka Python untuk membantu. Hal pertama yang sebaiknya Anda lakukan sebelum menggunakan fungsi apa pun adalah melihat docstring fungsi tersebut dan semua argumen wajib serta opsionalnya. Untuk melakukannya, ketik ?function dan jalankan untuk mendapatkan semua informasi.

?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

Anda dapat melihat bahwa satu-satunya argumen wajib untuk objek WordCloud adalah text, sedangkan yang lainnya bersifat opsional.

Mulai dengan masukan sederhana

Jadi mari mulai dengan contoh sederhana: menggunakan deskripsi pada observasi pertama sebagai masukan untuk word cloud. Tiga langkahnya adalah:

• Ekstrak ulasan (dokumen teks)
• Buat dan hasilkan gambar word cloud
• Tampilkan cloud menggunakan 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()

Bagus! Anda dapat melihat bahwa ulasan pertama banyak menyebut rasa kering dan aroma wine.

Mengubah argumen opsional word cloud

Sekarang, ubah beberapa argumen opsional pada word cloud seperti max_font_size, max_word, dan 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()

Tampaknya penggunaan max_font_size di sini bukan ide yang baik. Ini membuat perbedaan frekuensi kata lebih sulit dilihat. Namun, mencerahkan latar belakang membuat cloud lebih mudah dibaca.

Jika Anda ingin menyimpan gambar, WordCloud menyediakan fungsi to_file

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

<wordcloud.wordcloud.WordCloud at 0x16f1d704978>

Hasilnya akan terlihat seperti ini saat Anda memuatnya:

Anda mungkin memperhatikan argumen interpolation="bilinear" dalam plt.imshow(). Ini untuk membuat gambar tampilan terlihat lebih halus. Untuk informasi lebih lanjut tentang pilihannya, tutorial metode interpolasi untuk imshow ini adalah sumber yang berguna.

Menggabungkan data

Sekarang Anda akan menggabungkan semua ulasan wine menjadi satu teks besar dan membuat cloud besar untuk melihat karakteristik mana yang paling umum pada wine ini.

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

Tampaknya black cherry dan full-bodied adalah karakteristik yang paling sering disebut, dan Cabernet Sauvignon adalah yang paling populer. Ini selaras dengan fakta bahwa Cabernet Sauvignon "adalah salah satu varietas anggur merah paling dikenal di dunia. Varietas ini ditanam di hampir setiap negara penghasil wine utama dalam beragam iklim, dari Okanagan Valley di Kanada hingga Beqaa Valley di Lebanon".^[1]

Visualisasi word cloud di Python

Sekarang, mari tuangkan kata-kata ini ke dalam sebuah cangkir (atau bahkan sebotol) wine!

Untuk membuat bentuk bagi word cloud, pertama Anda perlu mencari file PNG yang akan menjadi mask. Di bawah ini adalah salah satu yang bagus dan tersedia di internet:

Tidak semua gambar mask memiliki format yang sama sehingga menghasilkan keluaran berbeda, yang dapat membuat fungsi WordCloud tidak berjalan dengan benar. Untuk memastikan mask Anda berfungsi, mari lihat dalam bentuk 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)

Cara kerja fungsi masking adalah semua bagian berwarna putih pada mask harus bernilai 255, bukan 0 (tipe integer). Nilai ini merepresentasikan "intensitas" piksel. Nilai 255 adalah putih murni, sedangkan nilai 1 adalah hitam. Di sini, Anda dapat menggunakan fungsi yang disediakan di bawah untuk mentransformasikan mask jika mask Anda memiliki format yang sama seperti di atas. Perhatikan jika Anda memiliki mask dengan latar belakang bukan 0, melainkan 1 atau 2, sesuaikan fungsi agar sesuai dengan mask Anda.

Pertama, gunakan fungsi transform_format() untuk menukar angka 0 menjadi 255.

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

Kemudian, buat mask baru dengan bentuk yang sama seperti mask yang Anda miliki dan terapkan fungsi transform_format() pada setiap nilai di setiap baris mask sebelumnya.

# 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]))

Sekarang Anda memiliki mask baru dalam bentuk yang benar. Mencetak mask yang telah ditransformasikan adalah cara terbaik untuk memeriksa apakah fungsi berfungsi dengan baik.

# 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]])

Dengan mask yang benar, Anda dapat mulai membuat word cloud dengan bentuk pilihan Anda. Perhatikan pada fungsi WordCloud terdapat argumen mask yang menerima mask yang telah ditransformasikan seperti yang Anda buat di atas. contour_width dan contour_color adalah, sesuai namanya, argumen untuk menyesuaikan karakteristik garis luar cloud. Botol wine yang Anda miliki di sini adalah wine merah, jadi firebrick tampaknya pilihan warna kontur yang baik. Untuk pilihan warna lainnya, Anda dapat melihat tabel kode warna ini.

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

Voila! Anda membuat word cloud berbentuk botol wine! Tampaknya deskripsi wine paling sering menyebut black cherry, cita rasa buah, dan karakteristik full-bodied. Sekarang mari lihat lebih dekat ulasan untuk setiap negara dan plot word cloud menggunakan bendera masing-masing negara. Di bawah ini adalah contoh yang akan segera Anda buat:

Membuat Word Cloud Mengikuti Pola Warna

Anda dapat menggabungkan semua ulasan dari lima negara dengan jumlah wine terbanyak. Untuk menemukan negara-negara tersebut, Anda bisa melihat plot country vs number wine di atas atau menggunakan grup yang Anda buat sebelumnya untuk mencari jumlah observasi setiap negara (setiap grup) dan sort_values() dengan argumen ascending=False untuk mengurutkan menurun.

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

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

Jadi sekarang Anda memiliki 5 negara teratas: AS, Prancis, Italia, Spanyol, dan Portugal. Anda dapat mengubah jumlah negara dengan memasukkan angka pilihan Anda ke dalam head() seperti di bawah ini

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

Untuk saat ini, lima negara sudah cukup.

Untuk mendapatkan semua ulasan tiap negara, Anda dapat menggabungkan semua ulasan menggunakan sintaks " ".join(list), yang menyatukan semua elemen dalam daftar dan memisahkannya dengan spasi.

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

Kemudian, Anda dapat membuat word cloud seperti yang diuraikan di atas. Anda dapat menggabungkan dua langkah pembuatan dan penghasilannya menjadi satu seperti di bawah ini. Pemetaan warna dilakukan tepat sebelum Anda memplot cloud menggunakan fungsi ImageColorGenerator dari pustaka 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()

Terlihat bagus! Sekarang mari ulangi dengan ulasan dari Prancis.

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

Perlu dicatat bahwa Anda harus menyimpan gambar setelah plotting untuk mendapatkan word cloud dengan pola warna yang diinginkan.

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

Berikutnya Italia adalah Spanyol:

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

Terakhir, Portugal:

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

Hasil akhirnya ada pada tabel di bawah untuk membandingkan mask dan word cloud. Yang mana favorit Anda?

Cara Menafsirkan Word Cloud

Kita sudah melihat beberapa contoh word cloud dan cara membuatnya di Python. Namun, ada baiknya mengeksplorasi cara menafsirkan visualisasi data ini. Secara umum, ukuran setiap kata dalam cloud merepresentasikan frekuensi atau pentingnya dalam teks. Biasanya, semakin sering suatu kata muncul dalam teks, semakin besar ukurannya dalam word cloud.

Ada beberapa hal yang perlu diingat saat menafsirkan word cloud: 

• Perhatikan ukuran kata: Seperti disebutkan, ukuran setiap kata dalam cloud berkaitan dengan frekuensi atau pentingnya dalam teks. Karena itu, kata yang lebih besar umumnya lebih signifikan dalam pesan keseluruhan teks.
• Cari pola: Apakah ada kelompok kata yang sering muncul bersama? Ini dapat mengindikasikan tema atau topik yang penting dalam teks.
• Pertimbangkan konteks: Ingat bahwa word cloud hanya merepresentasikan kata yang muncul dalam teks, dan tidak memberikan informasi tentang maknanya atau bagaimana kata itu digunakan. Karena itu, penting untuk memikirkan konteks teks dan makna spesifik dari kata-kata yang digunakan.
• Waspadai outlier: Terkadang, sebuah kata dapat muncul sangat besar dalam word cloud hanya karena sering muncul, meski tidak terlalu bermakna atau relevan dengan pesan keseluruhan teks. Perhatikan outlier semacam ini dan fokuslah pada kata dan pola yang paling signifikan.

Secara keseluruhan, word cloud bisa menjadi alat yang berguna untuk dengan cepat memvisualisasikan tema dan gagasan kunci dalam teks. Namun, penting diingat bahwa ini hanyalah salah satu alat di antara banyak cara untuk menganalisis data teks, dan sebaiknya digunakan bersama metode lain untuk analisis dan pemahaman yang lebih mendalam.

Selamat!

Anda berhasil! Anda telah mempelajari beberapa cara untuk menggambar word cloud di Python menggunakan pustaka WordCloud yang berguna untuk visualisasi analisis teks apa pun. Anda juga belajar bagaimana memask cloud menjadi bentuk apa pun, menggunakan warna pilihan Anda. Jika Anda ingin mempraktikkan keterampilan Anda, pertimbangkan proyek DataCamp: Topik Terpanas dalam Machine Learning

Jika Anda tertarik mempelajari lebih lanjut tentang Pemrosesan Bahasa Alami, ikuti track kami Fundamental Natural Language Processing di Python.