Makine Öğrenmesi Algoritmaları-Gözetimli Öğrenme (Supervised Learning) (Makine Öğrenmesi-2)

Bu yazımızda makine öğrenmesi algoritmalarının en sık kullanılanlarından bahsedeceğiz.

Makine öğrenmesi algoritmaları aslında Gözetimli Öğrenme (Supervised Learning) ve Gözetimsiz Öğrenme (Unsupervised Learning) olarak 2 gruba ayrılır. Kısaca Gözetimli Öğrenme, bir eğitim verisi yani etiket (label) bilgisi içermektedir. Sonuçları bilinen verilerden oluşmaktadır. Oluşturulan model ile etiket bilgisi bulunmayan verilerin sonuçlarının tahmin edilmesi üzerine kuruludur. Gözetimsiz Öğrenme ise tahmin edildiği gibi gözetimli öğrenmenin tersi olacak şekilde etiket bilgisi yoktur. Veri setindeki birbiriyle bağlantılı ilişkilerin ortaya çıkarılması amaçlanmaktadır.

En sık kullanılan gözetimli öğrenme algoritmaları:

• K-En Yakın Komşuluk Algoritması (K-Nearest Neighbors)(KNN)
• Yapay Sinir Ağları (Artificial Neural Network) (ANN)
• Karar Ağaçları (Decision Trees) (DTs)
• Naive Bayes Sınıflandırması
• Rastgele Orman (Random Forest)
• Regresyon (Regression)

En sık kullanılan gözetimsiz öğrenme algoritmaları:

• Kümeleme (Clustering)
• Birliktelik Kuralları (Association Rules)
• Temel Bileşen Analizi (Principal Component Analysis) (PCA)

Bu yazıda gözetimli öğrenme algoritmalarını inceleyeceğiz. Sadece ikisi arasındaki farkın anlaşılması için kısa bir giriş yaptık.

1) K-En Yakın Komşuluk Algoritması (K-Nearest Neighbors)(KNN)

K-NN algoritması daha önce bahsettiğimiz gibi en basit ve en çok kullanılan sınıflandırma algoritmalarından birdir. Gözetimli öğrenme grubundan yer aldığından; eğitim verilerini öğrenmez, bunun yerine ezberler. Bir tahmin yapılmak istenildiğinde, veri setindeki en yakın komşuları arar. Bu algoritmada bir K değeri belirlenir. Bu K değerinin anlamı bakılacak eleman sayısıdır. Yeni bir değer girildiğinde K değerine mesafeler hesaplanır ve yeni değer bir kümeye ilave edilir. Mesafe hesaplama işleminde ise k-means ve hiyerarşik kümelemede kullanılan Öklid Uzaklığı gibi mesafe hesaplama yöntemleri kullanılır. Öklid Uzaklığına ek olarak; Manhattan, Minkowski ve Hamming fonksiyonları da kullanılabilir. Bu algoritma 5 adımdan oluşur:

1. K değeri belirlenir.
2. Diğer nesnelerden hedef nesneye olan öklid uzaklıkları hesaplanır.
3. Uzaklıklar sıralanır ve en minimum uzaklığa bağlı olarak en yakın komşular bulunur.
4. En yakın komşu kategorileri toplanır.
5. En uygun komşu kategorisi seçilir.

Aşağıdaki şekilde görüldüğü gibi 2 aile bulunmakta: mavi kareler ve kırmızı üçgenler. Bunları birer sınıf olarak kabul edelim. Yeni bir veri girildiğinde yani burada bulunan yeşil daireyi eklediğimizde, bunu da bir sınıfa dahil etmemiz gerekiyor. K-NN algoritması ile bu sınıflandırmayı yapacak olursak kırmızı üçgen sınıfına dahil olacağını tahmin edebiliriz.

Şimdi örnek bir Python kodu yazalım. Kütüphaneleri ekledikten sonra veri setimizi tanımlayalım.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import confusion_matrix
from matplotlib.colors import ListedColormap
ds = pd.read_csv('knn.csv')

Tanımladığımız veri seti beş nitelikten oluşuyor. Hedef değişken SatinAldiMi sütunudur. Diğer dört nitelik bağımsız niteliklerdir. Biz bağımsız değişken olarak sadece yaş ve tahmini maaşı kullanacağız. Önce kodla bunun ayrımını yapıyoruz.

X = ds.iloc[:, [2,3]].values
y = ds.iloc[:, 4].values

Veri setinde 400 kayıt var, 300'ünü eğitim için 100'ünü test için ayıralım.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

Feature scaling uygulayarak değişkenleri aynı birime getirelim.

sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)

Şimdi başta tanımladığımız kütüphanelerden olan KNeighborClassifier ile algoritmamız için gerekli kodları yazalım. Ardından modelimizi eğitelim. ‘n_neighbors’ kullanılacak komşu sayısını ifade eder. ‘metric’ ise komşuların yakınlığını belirlemede hangi yöntemi kullanacağımızı belirler. Burada sadece ‘minkowski’ yazsaydık bu yöntem kullanılacaktı, p=2 parametresini ekleyerek öklid mesafesinin kullanılması sağlandı.

classifier = KNeighborsClassifier(n_neighbors=5, metric=’minkowski’, p = 2)
classifier.fit(X_train, y_train)

Test setimizi kullanarak oluşan model ile tahmin yapalım.

y_pred = classifier.predict(X_test)

Yapılan sınıflandırmanın doğruluğunu kontrol etmek için hata matrisi oluşturalım. 100 kayıtlık test verisi ayırmıştık. Çıktısında görüldüğü gibi 4+3 adet kayıt yanlış sınıflandırılmış.

cm = confusion_matrix(y_test, y_pred)
print(cm)
>>[[64  4]
 [ 3 29]]

Grafiği çizmek için matplotlib ile kodları yazalım. Bu kodların detayını bir önceki yazımızda bahsetmiştik. Burada oluşturulan eğitim seti grafiğidir. Test setinin grafiğini veri setlerini ve etiket bilgilerini değiştirerek elde edebilirsiniz.

X_set, y_set = X_train, y_train
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() — 1, stop = X_set[:, 0].max() + 1, step = 0.01),
 np.arange(start = X_set[:, 1].min() — 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
 alpha = 0.75, cmap = ListedColormap((‘blue’, ‘green’)))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
 plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
 c = ListedColormap((‘yellow’, ‘green’))(i), label = j)
plt.title(‘K En Yakın Komşu (Eğitim Seti)’)
plt.xlabel(‘Yaş’)
plt.ylabel(‘Maaş’)
plt.legend()
plt.show()

Aşağıda kodların çıktısı verilmiştir.

Aşağıda tüm kodların toplu halini bulabilirsiniz.

2) Karar Ağaçları (Decision Trees) (DTs)

Karar ağaçları, özellik ve hedefe göre karar düğümleri (decision nodes) ve yaprak düğümlerinden (leaf nodes) oluşan ağaç yapısı formunda bir model oluşturan bir sınıflandırma yöntemidir. Bu algoritma, veri setini küçük ve hatta daha küçük parçalara bölerek geliştirilir. İlk düğüme kök düğüm (root node) denir. Bir karar ağacı hem kategorik hem de sayısal verilerden oluşabilir.

Karar ağacı oluşturmak zahmetsizdir ve yorumlaması kolaydır. Sürekli ve ayrık nitelik değerleri için kullanılabilir. Ama sürekli nitelik değerlerini tahmin etmekte tahmin edildiği gibi çok da başarılı değildir. Sınıf sayısı fazla ve öğrenme kümesi örnekleri sayısı az olduğunda model oluşturmada çok başarılı değildir.

Algoritmanın adımlarını sıralayacak olursak:

1. T öğrenme kümesi oluşturulur.
2. T kümesindeki örnekleri en iyi ayıran nitelik belirlenir.
3. Seçilen nitelikle ağacın bir düğümü oluşturulur ve bu düğümden ağacın yaprakları oluşturulur. Yaprak düğümlere ait alt veri kümesinin örnekleri belirlenir.

Burada bahsedeceğimiz bir diğer konu da Bilgi Kazancı (Information Gain)’dır. Bilgi kazancı ID3, C4.5 gibi karar ağacı metotlarında en ayırt edici niteliği belirlemek için her niteliğin bilgi kazancı ölçülür. Bu ölçümde Entropy kullanılır.

Entropy: Rastgeleliğe, belirsizliği ve beklenmeyen durumun ortaya çıkma olaslığını gösterir. Eğer örneklerin tamamı düzenli (homojen) ise entropisi sıfır olur. Eğer değerler birbirine eşit ise entropi 1 olur. Entropi formülü:

Şimdi Python ile bu algoritmayı yazalım. Önce ihtiyacımız olan kütüphaneleri ekledik. Ardından veri setimizi tanımladık. Veri setinde neler olduğunu görmek için ‘data.head()’ kodunu kullandık. 5 sütundan oluşan bir veri setimiz var.

import numpy as np
import matplotlib.pyplot as plt 
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier
from sklearn import metrics
from sklearn.metrics import confusion_matrix
from matplotlib.colors import ListedColormap
data = pd.read_csv(‘knn.csv’)
print(data.head())

‘Purchased’ kısmı bizim bağımlı değişkenimiz. ‘Age’ ve ‘EstimatedSalary’ verilerini bağımsız değişken olarak alacağız.

feature_cols = [‘Age’,’EstimatedSalary’ ]
X = data.iloc[:,[2,3]].values
y = data.iloc[:,4].values

Veri setini eğitim ve set olarak ayıralım.

X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.25, random_state= 0)

Başlamadan önce verilerimizi normalize edelim.

sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)

Şimdi karar ağacı için fonksiyonumuzu çağırabiliriz.

classifier = DecisionTreeClassifier()
classifier = classifier.fit(X_train,y_train)

Yaptığımız sınıflandırmadan sonra test setimizin doğruluğunu kontrol edelim. Ardından hata matrisi ile modelin 9 adet hatası olduğunu gördük.

y_pred = classifier.predict(X_test)#Accuracy
print(‘Accuracy Score:’, metrics.accuracy_score(y_test,y_pred))
>>Accuracy Score: 0.91
cm = confusion_matrix(y_test, y_pred)
print(cm)
>>[[62  6]
  [ 3 29]]

Şimdi bu model sonucunu matplotlib ile görselleştirelim.

X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:,0].min()-1, stop= X_set[:,0].max()+1, step = 0.01),np.arange(start = X_set[:,1].min()-1, stop= X_set[:,1].max()+1, step = 0.01))
plt.contourf(X1,X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha=0.75, cmap = ListedColormap((“black”,”white”)))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i,j in enumerate(np.unique(y_set)):
 plt.scatter(X_set[y_set==j,0],X_set[y_set==j,1], c = ListedColormap((“black”,”white”))(i),label = j)
plt.title(“Decision Tree(Test set)”)
plt.xlabel(“Age”)
plt.ylabel(“Estimated Salary”)
plt.legend()
plt.show()

Ağaç görüntülenmek istenirse Jupyter Notebook ile bu sağlanabilir. Aşağıda test setimizin grafiği verilmiştir.

Kodların tamamını aşağıda bulabilirsiniz.

3) Rastgele Orman (Random Forest)

Rastgele ormanlar, karar ağaçlarının bir koleksiyonudur, ancak bazı farklılıklar gösterir. Bu algoritmada tek bir ağacın aksine birden fazla ağaç yetiştirilir. Sınıflandırma durumunda ormandaki tüm ağaçlar arasında en çok oyu alan seçilir. Regresyon durumunda, farklı ağaçların çıktılarının ortalamasını alır. Bu algoritma çok kararlıdır ve mevcut makine öğrenmesi sistemlerinin çoğunu oluşturan hem sınıflandırma hem de regresyon problemleri için kullanılabilir. Ancak sınıflandırmada regresyona göre daha başarılıdır. Hızlı bir şekilde eğitilebilir, ama bir kez eğitildiklerinde tahminler oluşturmak için oldukça yavaştır. Aşağıdaki alanlarda kullanılabilir.

• Görüntü Sınıflandırma
• Nesne algılama
• Nesne takibi
• Kenar algılama
• Anlamsal Bölümleme
• Yüz ifadesi tanıma

Artık Python uygulamasına geçebiliriz. Yine kütüphanelerimizi tanıttık ve veri setimizi ekledik.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
from matplotlib.colors import ListedColormap
dataset = pd.read_csv(‘petrol_consumption.csv’)

Biz veri setinde bağımsız değişken olarak ehliyet yüzdesini ve asfaltlı yolları kullanacağız. Önce bunun ayrımını sağladık. Ardından verilerimizi eğittik.

X = dataset.iloc[:, [2,3]].values
y = dataset.iloc[:, 4].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

Şimdi normalize edelim.

sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)

Artık Random Forest algoritmasının fonksiyonunu çağırabiliriz.

classifier = RandomForestClassifier(n_estimators=10, criterion=’entropy’, random_state=0)
classifier.fit(X_train, y_train)

Test verilerinin doğruluğunu hata matrisi ile kontrol edelim.

y_pred = classifier.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
print(cm)

Şimdi test setini grafiğe dökelim.

X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() — 1, stop = X_set[:, 0].max() + 1, step = 0.01),
 np.arange(start = X_set[:, 1].min() — 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
 alpha = 0.75, cmap = ListedColormap((‘black’, ‘white’)))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
 plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
 c = ListedColormap((‘black’, ‘white’))(i), label = j)
plt.title(‘Random Forest (Test seti)’)
plt.xlabel(‘Ehliyet Yüzdesi’)
plt.ylabel(‘Asfaltlı Yol’)
plt.legend()
plt.show()

Aşağıda kodlarımızın çıktısı verilmiştir.

Kodların tamamı aşağıda verilmiştir.

4) Naive Bayes Sınıflandırması

Naive Bayes sınıflandırması, adını İngiliz matematikçi Thomas Bayes’ten almıştır. Bayes teoreminin bağımsızlık önermesiyle basitleştirilmiş halidir. Sınıflandırma işleminde genel olarak elde bir örüntü (pattern) vardır. Buradaki işlem de bu örüntüyü daha önceden tanımlanmış sınıflara sınıflandırmaktır. Her örüntü nicelik (feature ya da parametre) kümesi tarafından temsil edilir. Naive Bayes veri madenciliğinde, biyomedikal mühendisliği alanında, hastalıkların ya da anormalliklerin tıbbi tanımlanmasında ve daha birçok yerde kullanılabilir. Aşağıda Bayes teoreminin denklemi verilmiştir:

• P(c|x); x olayı gerçekleştiği durumda c olayının meydana gelme olasılığıdır.
• P(x|c); c olayı gerçekleştiği durumda x olayının meydana gelme olasılığıdır.
• P(c) ve P(x) ; x ve c olaylarının önsel olasılıklarıdır.

Şimdi Python kodlarına bakalım. Kütüphaneleri ve veri setimizi tanıttık. Bağımsız değişkenlerimizi ayırdık.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import confusion_matrix
from matplotlib.colors import ListedColormap
dataset = pd.read_csv(‘knn.csv’)
X = dataset.iloc[:, [2,3]].values
y = dataset.iloc[:, 4].values

Veri setini eğittikten sonra verileri feature scaling ile normalize ettik.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)

Artık Naive Bayes fonksiyonunu çağırabiliriz.

classifier = GaussianNB()
classifier.fit(X_train, y_train)

Hata matrisi ile 10 tane hatanın bulunduğunu tespit ettik.

y_pred = classifier.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
print(cm)
>>[[65  3]
  [ 7 25]]

Test grafiğini çizelim.

X_set, y_set = X_train, y_train
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() — 1, stop = X_set[:, 0].max() + 1, step = 0.01),
 np.arange(start = X_set[:, 1].min() — 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
 alpha = 0.75, cmap = ListedColormap((‘black’, ‘blue’)))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
 plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
 c = ListedColormap((‘black’, ‘white’))(i), label = j)
plt.title(‘Naive Bayes (Eğitim Seti)’)
plt.xlabel(‘Yaş’)
plt.ylabel(‘Maaş’)
plt.legend()
plt.show()

Aşağıda kodun çıktısı verilmiştir.

Tüm kodların toplu hali aşağıda verilmiştir.

Bu yazımızda bazı gözetimli öğrenme algoritmalarının ne olduğuna ve nasıl çalıştığına göz attık.

Bir sonraki yazıda görüşmek üzere…

Yardımcı Kaynaklar:

• https://www.veribilimiokulu.com/siniflandirma-notlari-16-karar-agaci-python-uygulama/
• https://www.veribilimiokulu.com/naive-bayes-yontemiyle-siniflandirma-classification-with-naive-bayes-python-ile-uygulama/
• https://www.veribilimiokulu.com/siniflandirma-notlari-18-random-forest-python-uygulama/