Python ile Makine Öğrenmesine Giriş

Ünlü Iris veri kümesi üzerinde KNN uygulayacaksınız.

Not: Python ile Makine Öğrenmesi kursunu almayı düşünebilirsiniz veya ML’in nasıl evrildiğine dair arka plan ve çok daha fazlası için bu yazıyı okuyabilirsiniz.

Giriş

Makine Öğrenmesi, esasen deneyimden öğrenebilen algoritmaların tasarımını inceleyen bilgisayar bilimlerinden evrilmiştir. Öğrenebilmesi için, algoritmaların anlamlı öngörücü desenler bulmaya çalıştığı belirli özniteliklere sahip veriye ihtiyaç vardır. ML görevleri büyük ölçüde kavram öğrenme, kümeleme, öngörücü modelleme vb. olarak kategorize edilebilir. ML algoritmalarının nihai amacı, insan müdahalesi olmadan doğru kararlar alabilmektir. Hisse senedi veya hava durumu tahmini, makine öğrenmesi algoritmalarının birkaç uygulamasıdır.

Karar ağaçları, Naive Bayes, Rastgele orman, Destek vektör makineleri, En yakın komşu, K-means kümeleme vb. gibi çeşitli makine öğrenmesi algoritmaları vardır.

Makine öğrenmesi algoritmaları sınıfından, bugün kullanacağınız algoritma k-en yakın komşudur.

Şimdi soru şu: K-En Yakın Komşu algoritması tam olarak nedir, hadi keşfedelim!

k-En Yakın Komşu nedir?

KNN ya da k-en yakın komşu algoritması bir gözetimli öğrenme algoritmasıdır; gözetimli demek, öğrenme aşamasında eğitim verisinin sınıf etiketlerinden yararlandığı anlamına gelir. Bu, yeni veri noktalarının, saklanan ve etiketlenmiş örneklere (veri noktaları) göre sınıflandırıldığı örnek tabanlı bir makine öğrenmesi algoritmasıdır. KNN hem sınıflandırma hem de regresyon için kullanılabilir; ancak daha yaygın olarak sınıflandırma amaçlı kullanılır.

KNN’deki k, bir veri noktasını doğru sınıflandırmaya yardımcı olan ve hiperparametre olarak da bilinen kritik bir değişkendir. Daha açık ifade etmek gerekirse, k, yeni bir veri noktasını sınıflandırırken oy almak istediğiniz en yakın komşu sayısıdır.

k değeri 1’den 7’ye arttıkça, bazı veri noktalarına sahip iki sınıf arasındaki karar sınırının daha da yumuşadığını görebilirsiniz.

Peki tüm bu sihir nasıl gerçekleşiyor da her yeni veri noktası geldiğinde, saklanan veri noktalarına göre sınıflandırılıyor?

Hızlıca şu şekilde anlayalım:

• Öncelikle tüm veriyi yüklersiniz ve k değerini başlatırsınız,
• Ardından, saklanan veri noktaları ile sınıflandırmak istediğiniz yeni veri noktası arasındaki mesafe Manhattan mesafesi (L1), Öklidyen mesafe (L2), Kosinüs benzerliği, Bhattacharyya mesafesi, Chebyshev mesafesi vb. çeşitli benzerlik veya mesafe ölçütleri kullanılarak hesaplanır.
• Sonrasında mesafe değerleri azalan ya da artan şekilde sıralanır ve en üstteki ya da alttaki k en yakın komşu belirlenir.
• k en yakın komşunun etiketleri toplanır ve yeni veri noktasını sınıflandırmak için çoğunluk oyu veya ağırlıklı oy kullanılır. Yeni veri noktasına, saklanan tüm veri noktaları arasından en yüksek skora sahip veri noktası baz alınarak bir sınıf etiketi atanır.
• Son olarak, yeni örnek için tahmin edilen sınıf döndürülür.

Tahmin iki tür olabilir: Yeni bir veri noktasına bir sınıf etiketi atanan sınıflandırma veya yeni veri noktasına bir değer atanan regresyon. Sınıflandırmadan farklı olarak regresyonda, yeni veri noktasına tüm k en yakın komşunun ortalaması atanır.

KNN’in dezavantajı: İlk olarak, her yeni veri noktası için en yakın komşuyu arama karmaşıklığı. İkincisi, bazen k değerini belirlemek zahmetli bir görev haline gelir. Son olarak, en yakın komşular hesaplanırken hangi mesafe ölçütünün kullanılmasının uygun olduğu da her zaman net değildir.

Yeterince teori oldu, değil mi? O halde bugün kullanacağınız veriyi yükleyelim, analiz edelim ve anlayalım.

Iris Verisini Yükleme

Iris veri kümesi, Iris-Setosa, Iris-Versicolor ve Iris-Virginica adlı üç sınıfa ait 150 örnekten oluşur. Dört özellik/öznitelik, veriyi bu üç sınıftan biri olarak benzersiz biçimde tanımlamaya katkıda bulunur: sepal-length, sepal-width, petal-length ve petal-width.

Başka bir herkese açık veri kümesini veya özel veri kümenizi kullanmaktan çekinmeyin.

Sklearn, veri bilimi ile ilgili görevlerde yaygın olarak kullanılan bir makine öğrenmesi Python kütüphanesidir. support vector machines, random forests, gradient boosting, k-means, KNN vb. dahil olmak üzere çeşitli sınıflandırma, regresyon ve kümeleme algoritmaları sunar. sklearn altında, Iris veri kümesi de dahil olmak üzere farklı görevler için kullanabileceğiniz birden çok veri kümesinin bulunduğu datasets adlı bir kütüphane vardır; bu veri kümelerinin tümü kutudan çıktığı gibi yüklenebilir. Oldukça sezgisel ve doğrudandır. Hadi iris veri kümesini hızlıca yükleyelim.

from sklearn.datasets import load_iris

load_iris, hem veriyi hem de her örnek için sınıf etiketlerini içerir. Hızlıca hepsini çıkaralım.

data = load_iris().data

data değişkeni, 150 örneğin her birinde dört farklı öznitelik bulunan (150,4) şekline sahip bir numpy dizisi olacaktır. Her sınıfta 50 örnek vardır.

data.shape

(150, 4)

Hadi sınıf etiketlerini çıkaralım.

labels = load_iris().target

labels.shape

(150,)

Sonraki adımda, veri ve sınıf etiketlerini birleştirmeniz gerekiyor; bunun için NumPy adlı harika bir Python kütüphanesi kullanacaksınız. NumPy, büyük, çok boyutlu diziler ve matrisler için destek sağlar ve bu diziler üzerinde çalışmak üzere kapsamlı bir üst düzey matematiksel fonksiyon koleksiyonu sunar. Hadi hızlıca içe aktaralım!

import numpy as np

data 2 boyutlu bir dizi olduğundan, labels değişkenini de 2 boyutlu bir dizi olacak şekilde yeniden şekillendirmeniz gerekir.

labels = np.reshape(labels,(150,1))

Şimdi, numpy kütüphanesinde bulunan concatenate fonksiyonunu kullanacak ve ikinci boyuta göre birleştirecek olan axis=-1 seçeneğini kullanacaksınız.

data = np.concatenate([data,labels],axis=-1)

data.shape

(150, 5)

Sonraki adımda, veriyi tablo şeklinde düzenlemek ve üzerinde bazı işlemler ve manipülasyonlar yapmak istediğinizde faydalı olan Python’un veri analizi kütüphanesi pandas’ı içe aktaracaksınız. Özellikle, sayısal tablolar ve zaman serileriyle çalışmak için veri yapıları ve işlemler sunar.

Bugünkü eğitimde pandas’ı oldukça yoğun kullanacaksınız.

import pandas as pd

names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'species']

dataset = pd.DataFrame(data,columns=names)

Artık ihtiyacınız olan veri ve sınıf etiketlerini içeren dataset veri çerçevesine sahipsiniz!

Daha ileri gitmeden önce, labels değişkeninde sınıf etiketlerinin sayısal değerler olduğunu, ancak bu sayısal değerleri çiçek adları veya türlerine dönüştüreceğinizi unutmayın.

Bunu yapmak için yalnızca class sütununu seçecek ve üç sayısal değerin her birini karşılık gelen tür adıyla değiştireceksiniz. Veri çerçevesi dataset’i doğrudan değiştirecek olan inplace=True seçeneğini kullanacaksınız.

dataset['species'].replace(0, 'Iris-setosa',inplace=True)
dataset['species'].replace(1, 'Iris-versicolor',inplace=True)
dataset['species'].replace(2, 'Iris-virginica',inplace=True)

Hadi dataset’in ilk beş satırını yazdıralım ve nasıl göründüğüne bakalım!

dataset.head(5)

Verinizi Analiz Edin

Hadi, üç çiçeğin görselleştirildiğinde nasıl göründüğünü ve birbirlerinden sadece sayılarda değil, gerçekte de ne kadar farklı olduklarını hızlıca görelim!

(Kaynak)

Yukarıda yüklediğiniz veriyi bir scatterplot kullanarak görselleştirelim; böylece bir değişkenin diğerinden ne kadar etkilendiğini, yani iki değişken arasındaki korelasyonun ne kadar olduğunu görelim.

Veriyi saçılım grafiği ile görselleştirmek için matplotlib kütüphanesini kullanacaksınız.

import matplotlib.pyplot as plt

İpucu: Python’da veriyi farklı şekillerde görselleştirmeyi öğrenmek ister misiniz? O halde Matplotlib ile veri görselleştirmeye giriş kursuna göz atın.

plt.figure(4, figsize=(10, 8))

plt.scatter(data[:50, 0], data[:50, 1], c='r', label='Iris-setosa')

plt.scatter(data[50:100, 0], data[50:100, 1], c='g',label='Iris-versicolor')

plt.scatter(data[100:, 0], data[100:, 1], c='b',label='Iris-virginica')

plt.xlabel('Sepal length',fontsize=20)
plt.ylabel('Sepal width',fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.title('Sepal length vs. Sepal width',fontsize=20)
plt.legend(prop={'size': 18})
plt.show()

Yukarıdaki grafikten, sepal uzunluğu ve sepal genişliği açısından Iris setosa çiçekleri arasında yüksek bir korelasyon olduğu oldukça açıktır. Öte yandan, Iris versicolor ve Iris virginica arasında korelasyon daha düşüktür. Versicolor ve virginica’daki veri noktaları, daha yoğun olan setosa’ya kıyasla daha fazla yayılmıştır.

Hızlıca petal-length ve petal-width için de grafiği çizelim.

plt.figure(4, figsize=(8, 8))

plt.scatter(data[:50, 2], data[:50, 3], c='r', label='Iris-setosa')

plt.scatter(data[50:100, 2], data[50:100, 3], c='g',label='Iris-versicolor')

plt.scatter(data[100:, 2], data[100:, 3], c='b',label='Iris-virginica')
plt.xlabel('Petal length',fontsize=15)
plt.ylabel('Petal width',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.title('Petal length vs. Petal width',fontsize=15)
plt.legend(prop={'size': 20})
plt.show()

petal-length ve petal-width söz konusu olduğunda da, yukarıdaki grafik, sıkı şekilde kümelenmiş setosa çiçekleri için güçlü bir korelasyona işaret ediyor.

Sonraki adımda, petal-length ile petal-width’ün nasıl korele olduğuna dair iddiayı daha da doğrulamak için, üç türün tamamı için bir korelasyon matrisi çizelim.

dataset.iloc[:,2:].corr()

Yukarıdaki tablo, üç tür birleştirildiğinde petal-length ile petal-width için 0.96 gibi güçlü bir korelasyonu ifade eder.

Üç türün her biri için korelasyonu ayrı ayrı da analiz edelim.

dataset.iloc[:50,:].corr() #setosa

dataset.iloc[50:100,:].corr() #versicolor

dataset.iloc[100:,:].corr() #virginica

Yukarıdaki üç tablodan, setosa ve virginica için petal-length ile petal-width arasındaki korelasyonun sırasıyla 0.33 ve 0.32 olduğu; versicolor için ise 0.78 olduğu net biçimde anlaşılmaktadır.

Şimdi de histogramlar çizerek özellik dağılımını görselleştirelim:

fig = plt.figure(figsize = (8,8))
ax = fig.gca()
dataset.hist(ax=ax)
plt.show()

petal-length, petal-width ve sepal-length tek tepe noktalı bir dağılım gösterirken, sepal-width bir tür Gauss dağılımı gösterir. Bunların tümü faydalı analizlerdir; çünkü bu tür dağılımlarla iyi çalışan bir algoritma kullanmayı düşünebilirsiniz.

Sonraki adımda, dört özniteliğin de aynı ölçekte olup olmadığını analiz edeceksiniz; bu, ML’in önemli bir yönüdür. pandas veri çerçevesinde, verinin count, mean, max, min değerlerini tablo formatında veren yerleşik bir describe fonksiyonu vardır.

dataset.describe()

Dört özniteliğin tümünün 0 ile 8 arasında benzer bir ölçekte olduğunu ve santimetre cinsinden olduğunu görebilirsiniz; isterseniz bunu 0 ile 1 arasına daha da ölçekleyebilirsiniz.

Her sınıf başına 50 örnek, yani toplam dağılımın ~%33,3’ü olduğunu biliyor olsanız da, yine de bir kontrol edelim!

print(dataset.groupby('species').size())

species
Iris-setosa        50
Iris-versicolor    50
Iris-virginica     50
dtype: int64

Verinizi Ön İşleme

Veriyi yükleyip kapsamlı biçimde analiz ettikten sonra, artık verinizi ML modelinize besleyebilmek için hazırlama zamanı. Bu bölümde, verinizi iki şekilde ön işleyeceksiniz: verinizi normalize etmek ve verinizi eğitim ve test setlerine ayırmak.

Verinizi normalize etme

Verinizi normalize etmenin iki yolu olabilir:

• Her örneği tek tek normalize ettiğiniz örnek normalizasyonu,
• Tüm örnekler arasında her özelliği aynı şekilde normalize ettiğiniz özellik normalizasyonu.

Peki verinizi neden veya ne zaman normalize etmeniz gerekir? Ve Iris verisini standartlaştırmanız gerekir mi?

Cevap çoğu zaman evettir. Verinizi normalize etmek iyi bir pratiktir; çünkü tüm örnekleri aynı ölçeğe ve aralığa getirir. Elinizdeki veri tutarlı değilse veriyi normalize etmek kritik öneme sahiptir. Yukarıda incelediğiniz describe() fonksiyonunu kullanarak tutarsızlığı kontrol edebilirsiniz; bu fonksiyon size max ve min değerlerini verir. Bir özelliğin max ve min değerleri diğer bir özelliğinkinden önemli ölçüde büyükse, her iki özelliği de aynı ölçeğe normalize etmek çok önemlidir.

Diyelim ki X daha büyük bir aralığa sahip bir özellik, Y ise daha küçük aralığa sahip ikinci özellik. O zaman Y özelliğinin etkisi, X özelliğinin etkisi tarafından bastırılabilir. Bu durumda X ve Y özelliklerini normalize etmek önem kazanır.

Iris verisinde normalize etme gerekli değildir.

Hadi describe() fonksiyonunu tekrar yazdıralım ve neden normalize etmeye gerek olmadığını görelim.

dataset.describe()

sepal-length özniteliği 4.3 ile 7.9 arasında değerlere sahipken sepal-width 2 ile 4.4 arasında değerler içerir; petal-length 1 ile 6.9 arasında, petal-width ise 0.1 ile 2.5 arasında değişir. Tüm özelliklerin değerleri 0.1 ile 7.9 aralığındadır ve bu kabul edilebilir sayılabilir. Dolayısıyla, Iris veri kümesine herhangi bir normalizasyon uygulamanız gerekmez.

Veriyi ayırma

Bu, makine öğrenmesinin bir diğer önemli yönüdür; çünkü amacınız, modelinizi, test ortamında insan müdahalesi olmaksızın karar verebilecek veya veriyi sınıflandırabilecek kadar yetkin hale getirmektir. Bu nedenle, ML modelinizi üretime almadan önce, modelin test verisi üzerinde iyi genelleme yapabildiğinden emin olmanız gerekir.

Bu amaçla, bir eğitim ve bir test setine ihtiyacınız vardır. Iris verisine dönersek, 150 örneğiniz var; verinizin %80’i üzerinde ML modelinizi eğitecek, kalan %20’yi ise test için kullanacaksınız.

Veri biliminde sıkça karşınıza Overfitting terimi çıkar; bu, modelinizin eğitim verisini çok iyi öğrendiği, ancak test verisi üzerinde performans gösteremediği anlamına gelir. Bu yüzden veriyi eğitim ve test veya doğrulama setlerine ayırmak, modelinizin aşırı uyum yapıp yapmadığını anlamanıza sıklıkla yardımcı olur.

Eğitim ve test seti ayrımı için, train_test_split adlı yerleşik bir ayırma fonksiyonuna sahip sklearn kütüphanesini kullanacaksınız. Hadi veriyi ayıralım.

from sklearn.model_selection import train_test_split

train_data, test_data, train_label, test_label = train_test_split(dataset.iloc[:,:3], dataset.iloc[:,3], test_size=0.2, random_state=42) 

random_state’in, bir random_state (tohum) aldığını ve sayıyı değiştirirseniz verinin ayrımının da değişeceğini unutmayın. Ancak random_state aynı tutulur ve hücre birden çok kez çalıştırılırsa veri ayrımı değişmeden kalır.

Hadi eğitim ve test verisinin şeklini, etiketleriyle birlikte hızlıca yazdıralım.

train_data.shape,train_label.shape,test_data.shape,test_label.shape

((120, 3), (120,), (30, 3), (30,))

Sonunda veriyi k-en yakın komşu algoritmasına besleme zamanı!

KNN Modeli

Tüm yükleme, analiz ve ön işleme adımlarından sonra, şimdi veriyi KNN modeline besleyeceksiniz. Bunu yapmak için, sklearn’ün yerleşik neighbors fonksiyonunu kullanacaksınız; bunun içinde KNeigborsClassifier adlı bir sınıf bulunur.

Önce sınıflandırıcıyı içe aktaralım.

from sklearn.neighbors import KNeighborsClassifier

Not: k (n_neighbors) parametresi, oy skorlarında eşitlikleri önlemek için sıklıkla tek sayı seçilir.

Hiperparametre k için en iyi değeri belirlemek amacıyla grid-search benzeri bir şey yapacaksınız. Modelinizi 10 farklı k değeri üzerinde eğitip test edecek ve size en iyi sonucu vereni kullanacaksınız.

1-9 aralığında değerler alacak bir neighbors(k) değişkeni ve eğitim ile test doğrulukları için iki adet numpy sıfır matrisi train_accuracy ve test_accuracy başlatalım. Bunlara, en iyi neighbor değerini seçmek için grafik çizerken ihtiyaç duyacaksınız.

neighbors = np.arange(1,9)
train_accuracy =np.zeros(len(neighbors))
test_accuracy = np.zeros(len(neighbors))

Sıradaki kod parçasında tüm sihir gerçekleşecek. Dokuz komşu değerin her biri üzerinde enumerate edeceksiniz ve her komşu için hem eğitim hem de test verisi üzerinde tahmin yapacaksınız. Son olarak doğruluk değerlerini train_accuracy ve test_accuracy numpy dizilerine kaydedeceksiniz.

for i,k in enumerate(neighbors):
    knn = KNeighborsClassifier(n_neighbors=k)

    #Fit the model
    knn.fit(train_data, train_label)

    #Compute accuracy on the training set
    train_accuracy[i] = knn.score(train_data, train_label)

    #Compute accuracy on the test set
    test_accuracy[i] = knn.score(test_data, test_label)

Sonraki adımda, matplotlib kullanarak eğitim ve test doğruluğunu çizeceksiniz; farklı komşu sayıları vs. doğruluk grafiği ile modelinizin en iyi performans gösterdiği en uygun k değerini seçebileceksiniz.

plt.figure(figsize=(10,6))
plt.title('KNN accuracy with varying number of neighbors',fontsize=20)
plt.plot(neighbors, test_accuracy, label='Testing Accuracy')
plt.plot(neighbors, train_accuracy, label='Training accuracy')
plt.legend(prop={'size': 20})
plt.xlabel('Number of neighbors',fontsize=20)
plt.ylabel('Accuracy',fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.show()

Yukarıdaki grafiğe bakınca, n_neighbors=3 olduğunda her iki modelin de en iyi performansı gösterdiği anlaşılıyor. O halde n_neighbors=3 ile devam edelim ve eğitimi yeniden çalıştıralım.

knn = KNeighborsClassifier(n_neighbors=3)

#Fit the model
knn.fit(train_data, train_label)

#Compute accuracy on the training set
train_accuracy = knn.score(train_data, train_label)

#Compute accuracy on the test set
test_accuracy = knn.score(test_data, test_label)

Modelinizi Değerlendirme

Bu eğitimin son bölümünde, modelinizi confusion_matrix ve classification_report gibi birkaç teknik kullanarak test verisi üzerinde değerlendireceksiniz.

Önce modelin test verisi üzerindeki doğruluğunu kontrol edelim.

test_accuracy

0.9666666666666667

Harika! Görünüşe göre model, test verisinin %96,66’sını doğru sınıflandırmış. Etkileyici değil mi? Sadece birkaç satır kodla, artık yalnızca dört özelliği kullanarak çiçeğin adını %96,66 doğrulukla söyleyebilen bir ML modeli eğittiniz. Kim bilir, belki bir insandan çok daha iyi performans göstermiştir.

Karmaşıklık Matrisi

Karmaşıklık matrisi, esasen, gerçek değerleri veya etiketleri bilinen test verisi üzerindeki model performansınızı tanımlamak için kullanılır.

Scikit-learn, sizin için karmaşıklık matrisini hesaplayan bir fonksiyon sağlar.

prediction = knn.predict(test_data)

Aşağıdaki plot_confusion_matrix() fonksiyonu, bu kaynaktan uyarlanmış ve değiştirilmiştir.

import itertools
def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):


    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    fmt = '.2f' if normalize else 'd'
    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.ylabel('True label',fontsize=30)
    plt.xlabel('Predicted label',fontsize=30)
    plt.tight_layout()
    plt.xticks(fontsize=18)
    plt.yticks(fontsize=18)
class_names = load_iris().target_names


# Compute confusion matrix
cnf_matrix = confusion_matrix(test_label, prediction)
np.set_printoptions(precision=2)

# Plot non-normalized confusion matrix
plt.figure(figsize=(10,8))
plot_confusion_matrix(cnf_matrix, classes=class_names)
plt.title('Confusion Matrix',fontsize=30)
plt.show()

Yukarıdaki confusion_matrix grafiğinden, modelin bir virginica çiçeği dışında tüm çiçekleri doğru sınıflandırdığını; o bir virginica’nın ise versicolor olarak sınıflandırıldığını gözlemleyebilirsiniz.

Sınıflandırma Raporu

Sınıflandırma raporu, her sınıf için precision, recall ve F1 score vererek yanlış sınıflandırılan sınıfları çok daha ayrıntılı belirlemenize yardımcı olur. Sınıflandırma raporunu görselleştirmek için sklearn kütüphanesini kullanacaksınız.

from sklearn.metrics import classification_report

print(classification_report(test_label, prediction))

                 precision    recall  f1-score   support

    Iris-setosa       1.00      1.00      1.00        10
Iris-versicolor       0.90      1.00      0.95         9
 Iris-virginica       1.00      0.91      0.95        11

      micro avg       0.97      0.97      0.97        30
      macro avg       0.97      0.97      0.97        30
   weighted avg       0.97      0.97      0.97        30

Daha da İleri Gidin!

Öncelikle, sonuna kadar başarıyla gelen herkesi tebrikler! Ama bu sadece bir başlangıçtı. Gidilecek daha uzun bir yol var!

Bu eğitim, ağırlıklı olarak makine öğrenmesinin temelleri ve Python ile KNN olarak bilinen bir ML algoritmasının uygulanmasıyla ilgilendi. Kullandığınız Iris veri kümesi oldukça küçük ve nispeten basitti.

Bu eğitim sizde daha fazlasını öğrenme isteği uyandırdıysa, başka veri kümeleri kullanmayı deneyebilir veya daha fazla ML algoritması hakkında bilgi edinip bunları Iris veri kümesine uygulayarak doğruluk üzerindeki etkiyi gözlemleyebilirsiniz. Bu şekilde yalnızca teoriyi anlamaktan çok daha fazlasını öğrenirsiniz!

Bu eğitimde sunulan temeller ve diğer makine öğrenmesi algoritmalarıyla yeterince deneme yaptıysanız, Python ve veri analizinde daha da derine inmeyi düşünebilirsiniz.