Python'da WordCloud Oluşturma Eğitimi

Kelime Bulutu Nedir?

Çoğu zaman, farklı boyutlarda pek çok kelimeyle dolu bir bulut görmüşsünüzdür; bu boyutlar her bir kelimenin sıklığını veya önemini temsil eder. Buna Etiket Bulutu ya da kelime bulutu denir. Bu eğitimde, Python ile bir kelime bulutu oluşturmayı ve ihtiyacınıza göre özelleştirmeyi öğreneceksiniz. Bu araç, metin verilerini keşfetmek ve raporlarınızı daha canlı hale getirmek için çok kullanışlıdır.

Bu uygulamalı alıştırma ile Python'da WordCloud oluşturma pratiği yapın.

Bu eğitimde, Wine Enthusiast web sitesindeki bir şarap inceleme veri setini kullanarak şunları öğreneceğiz:

• Birden fazla metin belgesinden temel bir kelime bulutu nasıl oluşturulur
• Kelime bulutunuzdaki metnin rengini, boyutunu ve sayısını nasıl ayarlarsınız
• Kelime bulutunu seçtiğiniz herhangi bir şekle nasıl maske edersiniz
• Kelime bulutunu seçtiğiniz herhangi bir renk desenine nasıl uydurursunuz

Kelime Bulutu Ne Zaman Kullanılır

Kelime bulutlarının bir metin veya veri kümesindeki yaygın kelimeleri görselleştirmek için yararlı olduğunu, ancak genellikle yalnızca temaların yüksek seviyeli bir genel görünümünü sunduğunu unutmamak önemlidir. Çubuk grafiklere benzerler, ancak çoğu zaman daha görsel olarak çekicidirler (bazen yorumlaması daha zor olsa da). Kelime bulutları özellikle şu durumlarda yardımcı olabilir:

• Geniş bir metin gövdesindeki en önemli temaları veya konuları hızlıca belirlemek istediğinizde
• Bir yazının genel duyarlılığını veya tonunu anlamak istediğinizde
• Metinsel bilgi içeren verilerdeki örüntüleri veya eğilimleri keşfetmek istediğinizde
• Ana fikirleri ya da kavramları görsel olarak ilgi çekici bir şekilde aktarmak istediğinizde

Bununla birlikte, kelime bulutlarının kullanılan kelimeler ve ifadeler hakkında herhangi bir bağlam veya daha derin bir anlayış sunmadığını akılda tutmak gerekir. Bu nedenle, metin verilerini analiz etmek ve yorumlamak için diğer yöntemlerle birlikte kullanılmalıdırlar.

Önkoşullar

Python'da kelime bulutu oluşturmaya başlamak için aşağıdaki paketleri kurmanız gerekir:

• numpy
• pandas
• matplotlib
• pillow
• wordcloud

numpy kütüphanesi, çok boyutlu diziler ve matrislerle çalışmak için kullanılan en popüler ve yararlı kütüphanelerden biridir. Ayrıca veri analizi yapmak için pandas kütüphanesiyle birlikte kullanılır.

Python os modülü yerleşik bir kütüphanedir, dolayısıyla kurmanıza gerek yoktur. os modülüyle dosya işlemleri hakkında daha fazla okumak için bu DataCamp Python'da dosya okuma ve yazma eğitimi faydalı olacaktır.

Görselleştirme için matplotlib, bu eğitimde kullanacağınız seaborn veya wordcloud gibi birçok kütüphanenin temelinde çalışan temel bir kütüphanedir. pillow kütüphanesi ise görsel okumayı sağlayan bir pakettir. Pillow, PIL - Python Imaging Library için bir sarmalayıcıdır. Kelime bulutu için maske olarak resmi okumak üzere bu kütüphaneye ihtiyaç duyacaksınız.

wordcloud kurulumu biraz zahmetli olabilir. Sadece temel bir kelime bulutu çizmek istiyorsanız, pip install wordcloud veya conda install -c conda-forge wordcloud yeterlidir. Ancak, bulutu seçtiğiniz herhangi bir şekle maskeleyebilme özelliğine sahip en son sürüm için aşağıdaki gibi farklı bir kurulum yöntemi gereklidir:

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

Veri seti:

Bu eğitimde Kaggle'daki şarap inceleme veri seti kullanılmıştır. Bu derleme, eksik değer içermemesi (ki bunlarla uğraşmak zaman alır), çok sayıda metin (şarap yorumları), kategorik ve sayısal veri barındırması sayesinde öğrenmek için harika bir veri setidir.

Python'da Kelime Bulutu Oluşturma: Hazırlık 

Gerekli kütüphaneleri kurun

Öncelikle, gerekli tüm kütüphaneleri yüklersiniz:

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

10'dan fazla kütüphaneniz varsa, bunları bölümlere göre (ör. temel kütüphaneler, görselleştirme, modeller vb.) düzenleyin. Kodda yorum kullanmak, kodunuzu temiz ve takip etmesi kolay hale getirecektir.

Veriyi dataframe'e yükleyin 

Şimdi, pandas read_csv kullanarak veriyi dataframe'e yükleyin. index_col=0 kullanımının, satır adını (indisi) ayrı bir sütun olarak okumadığımız anlamına geldiğine dikkat edin.

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

print() ile .format()'ı birleştirerek veri seti hakkında bazı temel bilgileri güzel bir şekilde yazdırabilirsiniz.

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

Özellikleri karşılaştırmak için gruplar oluşturun

Bir özelliğin grupları arasında karşılaştırma yapmak için groupby() kullanabilir ve özet istatistikler hesaplayabilirsiniz.

Şarap veri setiyle, ülkeye göre gruplayabilir ve tüm ülkelerin puan ve fiyatlarına ilişkin özet istatistiklere bakabilir veya en popüler ve pahalı olanları seçebilirsiniz.

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

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

Bu, 44 ülke arasından en yüksek ortalama puana sahip ilk 5'ini seçer:

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

Veriyi görselleştirin

Pandas DataFrame ve Matplotlib'in plot yöntemiyle ülkeye göre şarap sayısını çizebilirsiniz. Matplotlib'e aşina değilseniz, Matplotlib eğitimimize hızlıca göz atın.

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

Şarap üreten 44 ülke arasında, ABD şarap inceleme veri setinde 50.000'den fazla türe sahip; bu, sıradaki Fransa'nın (şarabıyla ünlü ülke) iki katıdır. İtalya da çok sayıda kaliteli şarap üretmekte olup, incelemeye açık neredeyse 20.000 şaraba sahiptir.

Veriyi inceleyin

Şimdi, yukarıdakiyle aynı çizim tekniğini kullanarak 44 ülkenin en yüksek puanlı şaraplarına göre grafiğine göz atalım:

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

Avustralya, ABD, Portekiz, İtalya ve Fransa'nın hepsinde 100 puan alan şaraplar var. Dikkat ederseniz, Portekiz veri setinde üretilen şarap sayısında 5., Avustralya ise 9. sırada yer alıyor ve her iki ülkede de 8000'den az şarap türü bulunuyor.
Bugün kullandığınız veri setini tanımak için küçük bir veri keşfi yaptık. Şimdi ana yemeğe, yani kelime bulutuna geçeceksiniz.

Python'da Temel Bir Kelime Bulutu Kurulumu

Başlarken

Bir kelime bulutu, verilen metinde en sık geçen kelimeleri gösterme tekniğidir. Bize bu konuda yardımcı olacak bir Python kütüphanesi kullanabiliriz. Herhangi bir işlevi kullanmadan önce yapmak isteyebileceğiniz ilk şey, işlevin docstring'ine bakmak ve tüm zorunlu ve isteğe bağlı argümanları görmektir. Bunu yapmak için ?function yazıp çalıştırarak tüm bilgileri alabilirsiniz.

?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

Bir WordCloud nesnesi için tek zorunlu argümanın text olduğunu, diğer tüm argümanların isteğe bağlı olduğunu görebilirsiniz.

Basit bir girdiyle başlayın

Öyleyse basit bir örnekle başlayalım: kelime bulutu için ilk gözlem açıklamasını girdi olarak kullanalım. Üç adım şunlardır:

• İncelemeyi (metin belgesini) çıkarın
• Bir kelime bulutu görseli oluşturun ve üretin
• Bulutu matplotlib kullanarak görüntüleyin

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

Harika! İlk incelemenin şarabın kuru tatları ve aromaları hakkında çok şey söylediğini görebilirsiniz.

İsteğe bağlı kelime bulutu argümanlarını değiştirme

Şimdi, kelime bulutunun bazı isteğe bağlı argümanlarını, örneğin max_font_size, max_word ve background_color'ı değiştirin.

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

Burada max_font_size kullanmak iyi bir fikir olmayabilir gibi görünüyor. Kelime sıklıkları arasındaki farkları görmeyi zorlaştırıyor. Ancak arka planı aydınlatmak bulutun okunmasını kolaylaştırıyor.

Görseli kaydetmek isterseniz, WordCloud to_file işlevini sağlar

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

<wordcloud.wordcloud.WordCloud at 0x16f1d704978>

İçeri aktardığınızda sonuç şöyle görünecektir:

plt.imshow() içindeki interpolation="bilinear" argümanını muhtemelen fark etmişsinizdir. Bu, görüntülenen görselin daha pürüzsüz görünmesini sağlar. Seçenekler hakkında daha fazla bilgi için, bu imshow için enterpolasyon yöntemleri eğitimi yararlı bir kaynaktır.

Veriyi birleştirme

Şimdi tüm şarap yorumlarını tek bir büyük metinde birleştirip bu şaraplarda en yaygın hangi özelliklerin bulunduğunu görmek için kocaman bir bulut oluşturacaksınız.

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

Siyah kiraz ve gövdeli (full-bodied) özelliklerinin en çok bahsedilen nitelikler olduğu, Cabernet Sauvignon'un ise hepsinin en popüleri olduğu görülüyor. Bu, Cabernet Sauvignon'un “dünyanın en yaygın tanınan kırmızı şarap üzümü çeşitlerinden biri olduğu; Kanada'nın Okanagan Vadisi'nden Lübnan'ın Beka Vadisi'ne kadar çeşitli iklimlerde, hemen her büyük şarap üretim ülkesinde yetiştirildiği” gerçeğiyle uyumludur.^[1]

Python'da kelime bulutu görselleştirmesi

Şimdi, bu kelimeleri bir kadeh (hatta bir şişe) şarabın içine dökelim!

Kelime bulutunuz için bir şekil oluşturmak üzere önce maske olacak bir PNG dosyası bulmanız gerekir. Aşağıda internette bulunan güzel bir örnek var:

Tüm maske görselleri aynı biçime sahip değildir; bu da farklı sonuçlara yol açarak WordCloud işlevinin düzgün çalışmamasına neden olabilir. Maskenizin çalıştığından emin olmak için onu numpy dizi biçiminde inceleyelim:

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)

Maskeleme işlevlerinin çalışma biçimi, maskenin tüm beyaz kısımlarının 0 değil 255 (tamsayı türünde) olmasını gerektirir. Bu değer pikselin “yoğunluğunu” temsil eder. 255 değerleri saf beyazı, 1 değerleri ise siyahı ifade eder. Maskeniz yukarıdakiyle aynı biçimdeyse, aşağıda sağlanan işlevi kullanarak maskenizi dönüştürebilirsiniz. Arka planın 0 değil de 1 veya 2 olduğu bir maskeniz varsa, işlevi maskenize uyacak şekilde ayarlayın.

Önce, 0 sayısını 255 ile değiştirmek için transform_format() işlevini kullanırsınız.

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

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

Artık doğru biçimde yeni bir maskeniz var. Dönüştürülmüş maskeyi yazdırmak, işlevin düzgün çalışıp çalışmadığını kontrol etmenin en iyi yoludur.

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

Doğru maskeyle, seçtiğiniz şekle sahip kelime bulutunu oluşturmaya başlayabilirsiniz. WordCloud işlevinde, yukarıda oluşturduğunuz dönüştürülmüş maskeyi alan bir mask argümanı olduğunu unutmayın. contour_width ve contour_color adlarından da anlaşılacağı üzere, bulutun dış hatlarının özelliklerini ayarlamak için kullanılan argümanlardır. Elinizdeki şarap şişesi bir kırmızı şarap şişesi, bu nedenle contour rengi için firebrick iyi bir seçim gibi görünüyor. Daha fazla renk seçeneği için bu renk kodu tablosuna bakabilirsiniz.

# 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à! Bir şarap şişesi şeklinde kelime bulutu oluşturdunuz! Şarap açıklamalarında en sık siyah kiraz, meyvemsi tatlar ve gövdeli özelliklerden bahsedildiği görülüyor. Şimdi, her ülke için yorumlara daha yakından bakalım ve her ülkenin bayrağını kullanarak kelime bulutunu çizelim. Aşağıda, birazdan oluşturacağınız bir örnek var:

Bir Renk Desenini Takip Eden Kelime Bulutu Oluşturma

En fazla şaraba sahip beş ülkenin tüm yorumlarını birleştirebilirsiniz. Bu ülkeleri bulmak için yukarıdaki ülke vs sayı grafiğine bakabilir veya yukarıda elde ettiğiniz grupla, her ülke (her grup) için gözlem sayısını bulup azalan sıralamak üzere ascending=False argümanıyla sort_values() kullanabilirsiniz.

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

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

Şimdi elinizde 5 zirvedeki ülke var: ABD, Fransa, İtalya, İspanya ve Portekiz. Ülke sayısını aşağıdaki gibi head() içine istediğiniz sayıyı koyarak değiştirebilirsiniz

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

Şimdilik beş ülke yeterli olacaktır.

Her ülke için tüm yorumları almak üzere " ".join(list) söz dizimini kullanarak tüm yorumları birleştirebilirsiniz; bu, listedeki tüm öğeleri boşlukla ayırarak birleştirir.

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

Sonrasında, yukarıda özetlediğimiz gibi kelime bulutunu oluşturabilirsiniz. Aşağıdaki gibi, oluşturma ve üretme adımlarını tek bir adımda birleştirebilirsiniz. Renk eşlemesi, WordCloud kütüphanesindeki ImageColorGenerator işlevi kullanılarak bulutu çizmeden hemen önce yapılır.

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

Güzel görünüyor! Şimdi Fransa'dan bir incelemeyle tekrarlayalım.

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

İstediğiniz renk desenine sahip kelime bulutunu elde etmek için görseli çizdirdikten sonra kaydetmeniz gerektiğini unutmayın.

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

İtalya'yı İspanya takip ediyor:

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

Son olarak, Portekiz:

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

Maskeleri ve kelime bulutlarını karşılaştırmak için nihai sonuç aşağıdaki tabloda. Sizin favoriniz hangisi?

Kelime Bulutları Nasıl Yorumlanır

Artık birkaç kelime bulutu örneği gördük ve bunların Python'da nasıl oluşturulacağını öğrendik. Ancak bu veri görselleştirmelerinin nasıl yorumlanacağını incelemekte fayda var. Genel olarak, buluttaki her kelimenin boyutu, metindeki sıklığını veya önemini temsil eder. Genellikle, bir kelime metinde ne kadar sık görünürse, kelime bulutunda o kadar büyük görünür.

Kelime bulutlarını yorumlarken akılda tutulması gereken birkaç nokta vardır: 

• Kelimelerin boyutuna dikkat edin: Belirtildiği gibi, buluttaki her kelimenin boyutu, metindeki sıklığına veya önemine karşılık gelir. Bu nedenle, daha büyük kelimeler genellikle metnin genel mesajında daha anlamlıdır.
• Örüntülere bakın: Sık birlikte görünen kelime grupları var mı? Bu, metinde önemli bir tema veya konuyu gösterebilir.
• Bağlamı göz önünde bulundurun: Unutmayın ki kelime bulutu yalnızca metinde yer alan kelimeleri temsil eder; anlamları veya nasıl kullanıldıkları hakkında bilgi vermez. Bu nedenle, metnin bağlamını ve kullanılan kelimelerin özel anlamlarını düşünmek önemlidir.
• Aykırıklara karşı dikkatli olun: Bazen bir kelime, özellikle anlamlı veya metnin genel mesajıyla ilgili olmasa bile, yalnızca sık geçtiği için kelime bulutunda çok büyük görünebilir. Bu tür aykırı değerlere dikkat edin ve en anlamlı kelimelere ve örüntülere odaklanmaya çalışın.

Genel olarak, kelime bulutu bir metindeki temel tema ve fikirleri hızlıca görselleştirmek için yararlı bir araç olabilir. Ancak, metin verilerini analiz etmek için kullanılan pek çok araçtan yalnızca biri olduğunu ve daha derin analiz ve anlayış için diğer yöntemlerle birlikte kullanılması gerektiğini unutmamak önemlidir.

Tebrikler!

Başardınız! WordCloud kütüphanesini kullanarak Python'da kelime bulutu çizmenin birkaç yolunu öğrendiniz; bu, herhangi bir metin analizinin görselleştirilmesi için faydalı olacaktır. Ayrıca bulutu herhangi bir şekle maskelemeyi ve seçtiğiniz herhangi bir rengi kullanmayı öğrendiniz. Becerilerinizi pekiştirmek isterseniz, DataCamp'in şu projesini göz önünde bulundurun: Makine Öğrenimindeki En Sıcak Konular

Doğal Dil İşleme hakkında daha fazla bilgi edinmekle ilgileniyorsanız, Python ile Doğal Dil İşleme Temelleri eğitim yolumuzu inceleyin.