Python ile AI - Denetimli Öğrenme: Sınıflandırma

Bu bölümde, denetimli öğrenme - sınıflandırma uygulamaya odaklanacağız.

Sınıflandırma tekniği veya modeli, gözlemlenen değerlerden bir sonuç çıkarmaya çalışır. Sınıflandırma probleminde, "Siyah" veya "beyaz" veya "Öğretme" ve "Öğretim Dışı" gibi kategorize edilmiş çıktılarımız var. Sınıflandırma modelini oluştururken, veri noktalarını ve ilgili etiketleri içeren eğitim veri kümesine ihtiyacımız var. Örneğin, resmin bir arabaya ait olup olmadığını kontrol etmek istiyorsak. Bunu kontrol etmek için, "araba" ve "arabasız" ile ilgili iki sınıfa sahip bir eğitim veri kümesi oluşturacağız. Daha sonra eğitim örneklerini kullanarak modeli eğitmemiz gerekiyor. Sınıflandırma modelleri esas olarak yüz tanıma, istenmeyen posta tanımlama vb. Alanlarda kullanılır.

Python'da Sınıflandırıcı Oluşturma Adımları

Python'da bir sınıflandırıcı oluşturmak için Python 3 ve makine öğrenimi için bir araç olan Scikit-learn'ü kullanacağız. Python'da bir sınıflandırıcı oluşturmak için şu adımları izleyin -

Adım 1 - Scikit-learn'ü içe aktarın

Bu, Python'da bir sınıflandırıcı oluşturmanın ilk adımı olacaktır. Bu adımda, Python'daki en iyi makine öğrenimi modüllerinden biri olan Scikit-learn adlı bir Python paketi kuracağız. Aşağıdaki komut paketi içe aktarmamıza yardımcı olacaktır -

Import Sklearn

Adım 2 - Scikit-learn'ün veri kümesini içe aktarın

Bu adımda, makine öğrenimi modelimiz için veri kümesiyle çalışmaya başlayabiliriz. Burada kullanacağızthe Meme Kanseri Wisconsin Teşhis Veritabanı. Veri seti, meme kanseri tümörleri hakkında çeşitli bilgilerin yanı sıramalignant veya benign. Veri kümesinde 569 tümörle ilgili 569 örnek veya veri bulunur ve tümörün yarıçapı, dokusu, pürüzsüzlüğü ve alanı gibi 30 özellik veya özellik hakkında bilgi içerir. Aşağıdaki komutun yardımıyla Scikit-learn'ün meme kanseri veri setini içe aktarabiliriz -

from sklearn.datasets import load_breast_cancer

Şimdi, aşağıdaki komut veri kümesini yükleyecektir.

data = load_breast_cancer()

Aşağıda, önemli sözlük tuşlarının bir listesi verilmiştir -

Sınıflandırma etiketi adları (target_names)
Gerçek etiketler (hedef)
Öznitelik / özellik adları (özellik adları)
Öznitelik (veri)

Şimdi, aşağıdaki komutun yardımıyla, her önemli bilgi kümesi için yeni değişkenler oluşturabilir ve verileri atayabiliriz. Başka bir deyişle, verileri aşağıdaki komutlarla düzenleyebiliriz -

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

Şimdi, daha net hale getirmek için, sınıf etiketlerini, ilk veri örneğinin etiketini, özellik isimlerimizi ve özelliğin değerini aşağıdaki komutların yardımıyla yazdırabiliriz -

print(label_names)

Yukarıdaki komut, sırasıyla kötü huylu ve iyi huylu sınıf adlarını yazdıracaktır. Aşağıdaki çıktı olarak gösterilmiştir -

['malignant' 'benign']

Şimdi, aşağıdaki komut, 0 ve 1 ikili değerlerine eşleştirildiklerini gösterecektir. Burada 0, kötü huylu kanseri temsil eder ve 1, iyi huylu kanseri temsil eder. Aşağıdaki çıktıyı alacaksınız -

print(labels[0])
0

Aşağıda verilen iki komut, özellik adlarını ve özellik değerlerini üretecektir.

print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

Yukarıdaki çıktıdan, ilk veri örneğinin, yarıçapı 1.7990000e + 01 olan kötü huylu bir tümör olduğunu görebiliriz.

Adım 3 - Verileri kümeler halinde düzenleme

Bu adımda verilerimizi eğitim seti ve test seti olmak üzere ikiye ayıracağız. Verileri bu kümelere ayırmak çok önemlidir çünkü modelimizi görünmeyen veriler üzerinde test etmeliyiz. Verileri kümelere ayırmak için sklearn'ın adı verilen bir işlevi vardır.train_test_split()işlevi. Aşağıdaki komutların yardımıyla verileri bu setlere ayırabiliriz -

from sklearn.model_selection import train_test_split

Yukarıdaki komut, train_test_splitsklearn fonksiyonunu kullanın ve aşağıdaki komut verileri eğitim ve test verilerine böler. Aşağıda verilen örnekte, verilerin% 40'ını test için kullanıyoruz ve kalan veriler modelin eğitilmesi için kullanılacaktır.

train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)

Adım 4 - Modeli oluşturma

Bu adımda modelimizi oluşturacağız. Modeli oluşturmak için Naïve Bayes algoritmasını kullanacağız. Modeli oluşturmak için aşağıdaki komutlar kullanılabilir -

from sklearn.naive_bayes import GaussianNB

Yukarıdaki komut GaussianNB modülünü içe aktaracaktır. Şimdi, aşağıdaki komut modeli başlatmanıza yardımcı olacaktır.

gnb = GaussianNB()

Modeli gnb.fit () kullanarak verilere uydurarak eğiteceğiz.

model = gnb.fit(train, train_labels)

Adım 5 - Modeli ve doğruluğunu değerlendirme

Bu adımda test verilerimiz üzerinden tahminler yaparak modeli değerlendireceğiz. O zaman doğruluğunu da öğreneceğiz. Tahmin yapmak için, predikt () işlevini kullanacağız. Aşağıdaki komut bunu yapmanıza yardımcı olacaktır -

preds = gnb.predict(test)
print(preds)

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1
 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 
 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0 
 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0 0 0 
 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 
 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 
 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 
 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 1]

Yukarıdaki 0'lar ve 1'ler, tümör sınıfları için tahmin edilen değerlerdir - kötü huylu ve iyi huylu.

Şimdi, iki diziyi, yani test_labels ve predsmodelimizin doğruluğunu öğrenebiliriz. Kullanacağızaccuracy_score()doğruluğu belirlemek için işlev. Bunun için aşağıdaki komutu düşünün -

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

Sonuç, NaïveBayes sınıflandırıcısının% 95,17 doğru olduğunu göstermektedir.

Bu şekilde, yukarıdaki adımların yardımıyla sınıflandırıcımızı Python'da oluşturabiliriz.

Python'da Yapı Sınıflandırıcı

Bu bölümde, Python'da bir sınıflandırıcı oluşturmayı öğreneceğiz.

Naïve Bayes Sınıflandırıcı

Naïve Bayes, Bayes teoremini kullanarak sınıflandırıcı oluşturmak için kullanılan bir sınıflandırma tekniğidir. Varsayım, yordayıcıların bağımsız olmasıdır. Basit bir deyişle, bir sınıftaki belirli bir özelliğin varlığının başka herhangi bir özelliğin varlığıyla ilgisi olmadığını varsayar. Naïve Bayes sınıflandırıcı oluşturmak için scikit learn adlı python kitaplığını kullanmamız gerekir. Adlı üç tür Naif Bayes modeli vardır.Gaussian, Multinomial and Bernoulli scikit altında öğrenme paketi.

Naïve Bayes makine öğrenimi sınıflandırıcı modeli oluşturmak için aşağıdakilere & eksi

Veri kümesi

Breast Cancer Wisconsin Diagnostic Database adlı veri setini kullanacağız . Veri seti, meme kanseri tümörleri hakkında çeşitli bilgilerin yanı sıramalignant veya benign. Veri kümesinde 569 tümörle ilgili 569 örnek veya veri bulunur ve tümörün yarıçapı, dokusu, pürüzsüzlüğü ve alanı gibi 30 özellik veya özellik hakkında bilgi içerir. Bu veri setini sklearn paketinden içe aktarabiliriz.

Naif Bayes Modeli

Naïve Bayes sınıflandırıcı oluşturmak için, Naif Bayes modeline ihtiyacımız var. Daha önce de belirtildiği gibi, adında üç tür Naif Bayes modeli vardır.Gaussian, Multinomial ve Bernoulliscikit altında öğrenme paketi. Burada, aşağıdaki örnekte Gaussian Naif Bayes modelini kullanacağız.

Yukarıdakileri kullanarak, bir tümörün kötü huylu veya iyi huylu olup olmadığını tahmin etmek için tümör bilgisini kullanmak üzere bir Naif Bayes makine öğrenimi modeli oluşturacağız.

Başlamak için sklearn modülünü kurmamız gerekiyor. Aşağıdaki komutun yardımı ile yapılabilir -

Import Sklearn

Şimdi, Breast Cancer Wisconsin Diagnostic Database adlı veri setini içe aktarmamız gerekiyor.

from sklearn.datasets import load_breast_cancer

Şimdi, aşağıdaki komut veri kümesini yükleyecektir.

data = load_breast_cancer()

Veriler şu şekilde düzenlenebilir -

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

Şimdi, daha net hale getirmek için, aşağıdaki komutların yardımıyla sınıf etiketlerini, ilk veri örneğinin etiketini, özellik isimlerimizi ve özelliğin değerini yazdırabiliriz -

print(label_names)

Yukarıdaki komut, sırasıyla kötü huylu ve iyi huylu sınıf adlarını yazdıracaktır. Aşağıdaki çıktı olarak gösterilmiştir -

['malignant' 'benign']

Şimdi, aşağıda verilen komut, 0 ve 1 ikili değerlerine eşleştirildiklerini gösterecektir. Burada 0, kötü huylu kanseri temsil eder ve 1, iyi huylu kanseri temsil eder. Aşağıdaki çıktı olarak gösterilmiştir -

print(labels[0])
0

Aşağıdaki iki komut, unsur adlarını ve unsur değerlerini üretecektir.

print(feature_names[0])
mean radius
print(features[0])

[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

Yukarıdaki çıktıdan, ilk veri örneğinin ana yarıçapı 1.7990000e + 01 olan kötü huylu bir tümör olduğunu görebiliriz.

Modelimizi görünmeyen veriler üzerinde test etmek için verilerimizi eğitim ve test verilerine bölmemiz gerekir. Aşağıdaki kod yardımı ile yapılabilir -

from sklearn.model_selection import train_test_split

Yukarıdaki komut, train_test_splitsklearn fonksiyonunu kullanın ve aşağıdaki komut verileri eğitim ve test verilerine böler. Aşağıdaki örnekte, verilerin% 40'ını test etmek için kullanıyoruz ve anımsatıcı veriler modeli eğitmek için kullanılacaktır.

train, test, train_labels, test_labels = 
train_test_split(features,labels,test_size = 0.40, random_state = 42)

Şimdi, modeli aşağıdaki komutlarla oluşturuyoruz -

from sklearn.naive_bayes import GaussianNB

Yukarıdaki komut, GaussianNBmodül. Şimdi, aşağıda verilen komutla modeli başlatmamız gerekiyor.

gnb = GaussianNB()

Modeli kullanarak verilere uydurarak eğiteceğiz gnb.fit().

model = gnb.fit(train, train_labels)

Şimdi, test verileri üzerinde tahmin yaparak modeli değerlendirin ve şu şekilde yapılabilir -

preds = gnb.predict(test)
print(preds)

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1
 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 
 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0 
 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0 0 0 
 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 
 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 
 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 
 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 1]

Yukarıdaki 0'lar ve 1'ler, tümör sınıfları için tahmin edilen değerlerdir, yani kötü huylu ve iyi huylu.

Şimdi, iki diziyi, yani test_labels ve predsmodelimizin doğruluğunu öğrenebiliriz. Kullanacağızaccuracy_score()doğruluğu belirlemek için işlev. Şu komutu düşünün -

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

Sonuç, NaïveBayes sınıflandırıcısının% 95,17 oranında doğru olduğunu göstermektedir.

Bu, Naïve Bayse Gauss modeline dayalı makine öğrenimi sınıflandırıcısıydı.

Destek Vektör Makineleri (SVM)

Temel olarak, Destek vektör makinesi (SVM), hem regresyon hem de sınıflandırma için kullanılabilen denetimli bir makine öğrenme algoritmasıdır. SVM'nin ana konsepti, her bir veri öğesini n boyutlu uzayda bir nokta olarak çizmektir ve her özelliğin değeri belirli bir koordinatın değeridir. Burada n sahip olacağımız özellikler olacaktır. Aşağıda, SVM kavramını anlamak için basit bir grafik temsil verilmiştir -

Yukarıdaki diyagramda iki özelliğimiz var. Bu nedenle, öncelikle bu iki değişkeni, her noktanın destek vektörleri adı verilen iki koordinata sahip olduğu iki boyutlu uzayda çizmemiz gerekir. Çizgi, verileri iki farklı sınıflandırılmış gruba ayırır. Bu satır sınıflandırıcı olacaktır.

Burada, scikit-learn ve iris veri kümesini kullanarak bir SVM sınıflandırıcı oluşturacağız. Scikitlearn kütüphanesi,sklearn.svmmodül ve sınıflandırma için sklearn.svm.svc sağlar. 4 özelliğe dayalı olarak iris bitkisinin sınıfını tahmin etmek için SVM sınıflandırıcısı aşağıda gösterilmiştir.

Veri kümesi

Her biri 50 örnek içeren 3 sınıf içeren iris veri kümesini kullanacağız, burada her sınıf bir tür iris bitkisini ifade eder. Her örnek, ayrı uzunluk, ayrı genişlik, taç yaprağı uzunluğu ve taç yaprağı genişliği olmak üzere dört özelliğe sahiptir. 4 özelliğe dayalı olarak iris bitkisinin sınıfını tahmin etmek için SVM sınıflandırıcısı aşağıda gösterilmiştir.

Çekirdek

SVM tarafından kullanılan bir tekniktir. Temelde bunlar, düşük boyutlu girdi uzayını alıp daha yüksek boyutlu bir uzaya dönüştüren fonksiyonlardır. Ayrılmaz problemi ayrılabilir probleme dönüştürür. Çekirdek işlevi doğrusal, polinom, rbf ve sigmoid arasında herhangi biri olabilir. Bu örnekte doğrusal çekirdeği kullanacağız.

Şimdi aşağıdaki paketleri içe aktaralım -

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

Şimdi, giriş verilerini yükleyin -

iris = datasets.load_iris()

İlk iki özelliği alıyoruz -

X = iris.data[:, :2]
y = iris.target

Destek vektör makine sınırlarını orijinal verilerle çizeceğiz. Çizmek için bir ağ oluşturuyoruz.

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

Düzenlileştirme parametresinin değerini vermemiz gerekiyor.

C = 1.0

SVM sınıflandırıcı nesnesini oluşturmamız gerekiyor.

Svc_classifier = svm_classifier.SVC(kernel='linear', 
C=C, decision_function_shape = 'ovr').fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize = (15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap = plt.cm.tab10, alpha = 0.3)
plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('SVC with linear kernel')

Lojistik regresyon

Temel olarak, lojistik regresyon modeli, denetimli sınıflandırma algoritma ailesinin üyelerinden biridir. Lojistik regresyon, bir lojistik fonksiyon kullanarak olasılıkları tahmin ederek bağımlı değişkenler ile bağımsız değişkenler arasındaki ilişkiyi ölçer.

Burada, bağımlı ve bağımsız değişkenlerden bahsedersek, bağımlı değişken tahmin edeceğimiz hedef sınıf değişkenidir ve diğer tarafta bağımsız değişkenler, hedef sınıfı tahmin etmek için kullanacağımız özelliklerdir.

Lojistik regresyonda, olasılıkları tahmin etmek, olayın gerçekleşme olasılığını tahmin etmek anlamına gelir. Örneğin, dükkan sahibi mağazaya giren müşterinin Playstation'ı satın alıp almayacağını (örneğin) tahmin etmek ister. Mağaza sahibi tarafından olasılığın tahmin edilmesi, yani bir oyun istasyonu satın alıp almaması için gözlemleyeceği birçok müşteri - cinsiyet, yaş vb. Özellikler olacaktır. Lojistik fonksiyon, fonksiyonu çeşitli parametrelerle oluşturmak için kullanılan sigmoid eğridir.

Önkoşullar

Sınıflandırıcıyı lojistik regresyon kullanarak oluşturmadan önce, sistemimize Tkinter paketini kurmamız gerekiyor. Şuradan kurulabilirhttps://docs.python.org/2/library/tkinter.html.

Şimdi, aşağıda verilen kod yardımıyla, lojistik regresyon kullanarak bir sınıflandırıcı oluşturabiliriz -

İlk olarak, bazı paketleri içe aktaracağız -

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

Şimdi, yapılabilecek örnek verileri aşağıdaki gibi tanımlamamız gerekiyor -

X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6, 5], [7.6, 4],
              [3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4], [1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])

Ardından, aşağıdaki gibi yapılabilen lojistik regresyon sınıflandırıcısını oluşturmamız gerekiyor -

Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)

Son fakat en az değil, bu sınıflandırıcıyı eğitmemiz gerekiyor -

Classifier_LR.fit(X, y)

Şimdi çıktıyı nasıl görselleştirebiliriz? Logistic_visualize () adında bir işlev oluşturularak yapılabilir -

Def Logistic_visualize(Classifier_LR, X, y):
   min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
   min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0

Yukarıdaki satırda mesh gridinde kullanılacak minimum ve maksimum değerleri X ve Y tanımladık. Ek olarak, örgü ızgarayı çizmek için adım boyutunu tanımlayacağız.

mesh_step_size = 0.02

X ve Y değerlerinin örgü ızgarasını şu şekilde tanımlayalım -

x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
                 np.arange(min_y, max_y, mesh_step_size))

Aşağıdaki kodun yardımıyla, sınıflandırıcıyı örgü ızgara üzerinde çalıştırabiliriz -

output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)
 
plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black', 
linewidth=1, cmap = plt.cm.Paired)

Aşağıdaki kod satırı, arsanın sınırlarını belirleyecektir

plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:, 0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:, 1].max() + 1), 1.0)))
plt.show()

Şimdi, kodu çalıştırdıktan sonra aşağıdaki çıktı olan lojistik regresyon sınıflandırıcısını alacağız -

Karar Ağacı Sınıflandırıcısı

Karar ağacı, temelde, her düğümün bir gözlem grubunu bazı özellik değişkenlerine göre böldüğü ikili bir ağaç akış şemasıdır.

Burada, erkek veya dişi tahmin etmek için bir Karar Ağacı sınıflandırıcısı oluşturuyoruz. 19 örnek içeren çok küçük bir veri seti alacağız. Bu örnekler iki özellikten oluşacaktır - 'yükseklik' ve 'saç uzunluğu'.

Önkoşul

Aşağıdaki sınıflandırıcıyı oluşturmak için yüklememiz gerekiyor pydotplus ve graphviz. Temel olarak, graphviz nokta dosyalarını kullanarak grafik çizmek için bir araçtır vepydotplusGraphviz'in Nokta dili için bir modüldür. Paket yöneticisi veya pip ile kurulabilir.

Şimdi, aşağıdaki Python kodunun yardımıyla karar ağacı sınıflandırıcısını oluşturabiliriz -

Başlangıç olarak, bazı önemli kitaplıkları aşağıdaki gibi içe aktaralım -

import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections

Şimdi, veri setini aşağıdaki gibi sağlamamız gerekiyor -

X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],
[169,9],[171,36],[116,25],[196,25]]

Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']
data_feature_names = ['height','length of hair']

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)

Veri setini sağladıktan sonra, yapılabilecek modeli aşağıdaki gibi uydurmamız gerekiyor -

clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)

Aşağıdaki Python kodunun yardımıyla tahmin yapılabilir -

prediction = clf.predict([[133,37]])
print(prediction)

Karar ağacını aşağıdaki Python kodunun yardımıyla görselleştirebiliriz -

dot_data = tree.export_graphviz(clf,feature_names = data_feature_names,
            out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)

for edge in graph.get_edge_list():
edges[edge.get_source()].append(int(edge.get_destination()))

for edge in edges: edges[edge].sort()

for i in range(2):dest = graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')

Yukarıdaki kod için tahmini verecek [‘Woman’] ve aşağıdaki karar ağacını oluşturun -

Tahmindeki özelliklerin değerlerini test etmek için değiştirebiliriz.

Rastgele Orman Sınıflandırıcısı

Topluluk yöntemlerinin, makine öğrenimi modellerini daha güçlü bir makine öğrenimi modelinde birleştiren yöntemler olduğunu biliyoruz. Karar ağaçlarından oluşan Random Forest, bunlardan biridir. Tek bir karar ağacından daha iyidir çünkü öngörücü güçleri korurken, sonuçların ortalamasını alarak fazla uyumu azaltabilir. Burada, rasgele orman modelini scikit learn kanser veri setine uygulayacağız.

Gerekli paketleri içe aktarın -

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np

Şimdi, aşağıdaki & eksi olarak yapılabilecek veri setini sağlamamız gerekiyor

cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)

Veri setini sağladıktan sonra, yapılabilecek modeli aşağıdaki gibi uydurmamız gerekiyor -

forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)

Şimdi, eğitimin yanı sıra test alt kümesinin doğruluğunu öğrenin: o zaman tahmin edicilerin sayısını artıracaksak, test alt kümesinin doğruluğu da artacaktır.

print('Accuracy on the training subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_test,y_test)))

Çıktı

Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965

Şimdi, karar ağacı gibi, rasgele orman, feature_importanceözellik ağırlığı için karar ağacına göre daha iyi bir görünüm sağlayacak modül. Aşağıdaki gibi arsa ve görselleştirilebilir -

n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_, align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()

Bir sınıflandırıcının performansı

Bir makine öğrenimi algoritması uyguladıktan sonra, modelin ne kadar etkili olduğunu bulmamız gerekiyor. Etkinliğin ölçülmesine yönelik kriterler, veri kümelerine ve ölçüye dayalı olabilir. Farklı makine öğrenimi algoritmalarını değerlendirmek için farklı performans ölçütleri kullanabiliriz. Örneğin, farklı nesnelerin görüntülerini ayırt etmek için bir sınıflandırıcı kullanılıyorsa, ortalama doğruluk, AUC, vb. Gibi sınıflandırma performansı ölçütlerini kullanabileceğimizi varsayalım. Bir anlamda makine öğrenimi modelimizi değerlendirmek için seçtiğimiz ölçüt şudur çok önemlidir çünkü ölçüm seçimi, bir makine öğrenimi algoritmasının performansının nasıl ölçüldüğünü ve karşılaştırıldığını etkiler. Aşağıda metriklerden bazıları verilmiştir -

Karışıklık Matrisi

Temel olarak, çıktının iki veya daha fazla sınıf türünden olabileceği sınıflandırma problemi için kullanılır. Bir sınıflandırıcının performansını ölçmenin en kolay yoludur. Karışıklık matrisi, temelde "Gerçek" ve "Öngörülen" olmak üzere iki boyutlu bir tablodur. Her iki boyutta da “Gerçek Pozitifler (TP)”, “Gerçek Negatifler (TN)”, “Yanlış Pozitifler (FP)”, “Yanlış Negatifler (FN)” vardır.

Yukarıdaki karışma matrisinde 1 pozitif sınıf ve 0 negatif sınıf içindir.

Karışıklık matrisi ile ilgili terimler aşağıdadır -

True Positives − TP'ler, gerçek veri noktası sınıfının 1 olduğu ve tahmin edilenin de 1 olduğu durumlardır.
True Negatives − TN'ler, veri noktasının gerçek sınıfının 0 ve tahmin edilenin de 0 olduğu durumlardır.
False Positives − FP'ler, gerçek veri noktası sınıfının 0 olduğu ve tahmin edilenin de 1 olduğu durumlardır.
False Negatives − FN'ler, veri noktasının gerçek sınıfının 1 ve tahmin edilenin de 0 olduğu durumlardır.

Doğruluk

Karışıklık matrisinin kendisi bir performans ölçüsü değildir, ancak neredeyse tüm performans matrisleri kafa karışıklığı matrisine dayanmaktadır. Bunlardan biri doğruluktur. Sınıflandırma problemlerinde, modelin yaptığı her türlü tahmin üzerinden yaptığı doğru tahmin sayısı olarak tanımlanabilir. Doğruluğu hesaplamak için formül aşağıdaki gibidir -

$$ Doğruluk = \ frac {TP + TN} {TP + FP + FN + TN} $$

Hassas

Çoğunlukla belge erişiminde kullanılır. İade edilen belgelerin kaç tanesinin doğru olduğu şeklinde tanımlanabilir. Kesinliği hesaplamak için formül aşağıdadır -

$$ Precision = \ frac {TP} {TP + FP} $$

Hatırlama veya Hassasiyet

Modelin pozitiflerin kaçının geri döndüğü şeklinde tanımlanabilir. Modelin geri çağırma / hassasiyetini hesaplamak için formül aşağıdadır -

$$ Recall = \ frac {TP} {TP + FN} $$

Özgüllük

Modelin negatiflerin kaçına döndüğü şeklinde tanımlanabilir. Hatırlamanın tam tersi. Modelin özgüllüğünü hesaplamak için formül aşağıdadır -

$$ Özgüllük = \ frac {TN} {TN + FP} $$

Sınıf Dengesizliği Sorunu

Sınıf dengesizliği, bir sınıfa ait gözlem sayısının diğer sınıflara ait olanlardan önemli ölçüde daha düşük olduğu senaryodur. Örneğin nadir görülen hastalıkları, bankadaki dolandırıcılık işlemlerini vb. Tespit etmemiz gereken senaryoda bu sorun öne çıkıyor.

Dengesiz sınıf örnekleri

Dengesiz sınıf kavramını anlamak için bir dolandırıcılık tespit veri kümesi örneğini ele alalım -

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Çözüm

Balancing the classes’dengesiz sınıflara bir çözüm görevi görür. Sınıfları dengelemenin temel amacı, ya azınlık sınıfının frekansını artırmak ya da çoğunluk sınıfının frekansını azaltmaktır. Dengesizlik sınıfları sorununu çözmek için yaklaşımlar aşağıdadır -

Yeniden Örnekleme

Yeniden örnekleme, örnek veri setlerini yeniden yapılandırmak için kullanılan bir dizi yöntemdir - hem eğitim setleri hem de test setleri. Modelin doğruluğunu artırmak için yeniden örnekleme yapılır. Aşağıda bazı yeniden örnekleme teknikleri verilmiştir -

Random Under-Sampling- Bu teknik, çoğunluk sınıf örneklerini rastgele eleyerek sınıf dağılımını dengelemeyi amaçlamaktadır. Bu, çoğunluk ve azınlık sınıfı örnekleri dengelenene kadar yapılır.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Bu durumda, sahtekarlık içermeyen örneklerden değiştirilmeden% 10 örnek alıyoruz ve ardından bunları sahtekarlık örnekleriyle birleştiriyoruz -

Rastgele örneklemeden sonra hileli olmayan gözlemler = 4950'nin% 10'u = 495

Sahte gözlemlerle birleştirildikten sonraki toplam gözlemler = 50 + 495 = 545

Dolayısıyla şimdi, alt örneklemeden sonra yeni veri kümesi için olay oranı =% 9

Bu tekniğin temel avantajı, çalışma süresini azaltması ve depolamayı iyileştirmesidir. Ancak diğer yandan, eğitim verisi örneklerinin sayısını azaltırken faydalı bilgileri atabilir.

Random Over-Sampling - Bu teknik, azınlık sınıfındaki örneklerin sayısını çoğaltarak artırarak sınıf dağılımını dengelemeyi amaçlamaktadır.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

50 sahte gözlemi 30 kez tekrarlamamız durumunda, azınlık sınıfı gözlemlerini tekrarladıktan sonra hileli gözlemler 1500 olacaktır. Ve daha sonra, yüksek hızda örneklemeden sonra yeni verilerdeki toplam gözlemler 4950 + 1500 = 6450 olacaktır. Dolayısıyla, yeni veri seti için olay oranı 1500/6450 =% 23 olacaktır.

Bu yöntemin temel avantajı, yararlı bilgi kaybının olmamasıdır. Ancak öte yandan, azınlık sınıfı olaylarını taklit ettiği için aşırı uyma şansı artmıştır.

Topluluk Teknikleri

Bu metodoloji temel olarak, mevcut sınıflandırma algoritmalarını dengesiz veri setlerine uygun hale getirmek için değiştirmek için kullanılır. Bu yaklaşımda, orijinal verilerden birkaç iki aşamalı sınıflandırıcı oluşturuyor ve ardından tahminlerini topluyoruz. Rastgele orman sınıflandırıcı, topluluk tabanlı sınıflandırıcıya bir örnektir.