Introductie tot Machine Learning in Python

Je gaat KNN toepassen op de beroemde Iris-dataset.

Let op: Misschien wil je de cursus Machine Learning met Python volgen, of voor achtergrond over hoe ML zich heeft ontwikkeld en veel meer, dit artikel lezen.

Introductie

Machine Learning is voortgekomen uit de informatica en richt zich primair op het ontwerpen van algoritmes die kunnen leren van ervaring. Om te leren hebben ze data nodig met bepaalde kenmerken, op basis waarvan algoritmes proberen betekenisvolle voorspellende patronen te vinden. ML-taken kunnen grofweg worden ingedeeld in conceptleren, clusteren, voorspellend modelleren, enzovoort. Het uiteindelijke doel van ML-algoritmes is om zelfstandig, zonder menselijke tussenkomst, correcte beslissingen te nemen. Het voorspellen van aandelenkoersen of het weer zijn twee toepassingen van machinelearningalgoritmes.

Er zijn verschillende machinelearningalgoritmes, zoals beslisbomen, Naive Bayes, random forest, support vector machine, k-nearest neighbor, k-means-clustering, enzovoort.

Het algoritme uit deze familie dat je vandaag gaat gebruiken, is k-nearest neighbor.

Nu is de vraag: wat is het K-Nearest Neighbor-algoritme precies? Laten we dat uitzoeken!

Wat is een k-Nearest Neighbor?

Het KNN- of k-nearest neighbor-algoritme is een supervised learning-algoritme; met supervised wordt bedoeld dat het tijdens de leerfase gebruikmaakt van de klasselabels van de trainingsdata. Het is een instance-based machinelearningalgoritme, waarbij nieuwe datapunten worden geclassificeerd op basis van opgeslagen, gelabelde instanties (datapunten). KNN kan zowel voor classificatie als voor regressie worden gebruikt; het wordt echter vaker toegepast voor classificatie.

De k in KNN is een cruciale variabele, ook wel een hyperparameter, die helpt een datapunt accuraat te classificeren. Preciezer: k is het aantal dichtstbijzijnde buren waarvan je een stem wilt meenemen bij het classificeren van een nieuw datapunt.

Je ziet dat naarmate de waarde van k toeneemt van 1 naar 7, de beslissingsgrens tussen twee klassen met enkele datapunten steeds vloeiender wordt.

De vraag is nu: hoe gebeurt al die magie, waarbij elke keer dat er een nieuw datapunt binnenkomt, het wordt geclassificeerd op basis van de opgeslagen datapunten?

Laten we het snel op de volgende manier begrijpen:

• Als eerste laad je alle data en initialiseer je de waarde van k,
• Vervolgens bereken je de afstand tussen de opgeslagen datapunten en een nieuw datapunt dat je wilt classificeren, met behulp van diverse gelijkenis- of afstandsmaatstaven zoals Manhattan-afstand (L1), Euclidische afstand (L2), cosinusgelijkenis, Bhattacharyya-afstand, Chebyshev-afstand, enzovoort.
• Daarna sorteer je de afstandswaarden in aflopende of oplopende volgorde en bepaal je de bovenste of onderste k dichtstbijzijnde buren.
• De labels van de k dichtstbijzijnde buren worden verzameld en een meerderheidsstemming of gewogen stemming wordt gebruikt om het nieuwe datapunt te classificeren. Het nieuwe datapunt krijgt een klasselabel toegewezen op basis van het datapunt dat de hoogste score heeft van alle opgeslagen datapunten.
• Tot slot wordt de voorspelde klasse voor het nieuwe voorbeeld teruggegeven.

De voorspelling kan twee vormen aannemen: ofwel classificatie, waarbij een klasselabel wordt toegewezen aan een nieuw datapunt, ofwel regressie, waarbij een waarde wordt toegewezen aan het nieuwe datapunt. In tegenstelling tot classificatie wordt bij regressie het gemiddelde van alle k dichtstbijzijnde buren aan het nieuwe datapunt toegekend.

Nadeel van KNN: Ten eerste de complexiteit van het zoeken naar de dichtstbijzijnde buur voor elk nieuw datapunt. Ten tweede kan het bepalen van de waarde van k soms een lastige klus zijn. En tot slot is het vaak niet duidelijk welk type afstandsmaatstaf je het best kunt gebruiken bij het bepalen van de dichtstbijzijnde buren.

Genoeg theorie, toch? Laten we de data laden, analyseren en begrijpen die je in deze korte tutorial gaat gebruiken.

De Iris-data laden

De Iris-dataset bestaat uit 150 monsters met drie klassen, namelijk Iris-Setosa, Iris-Versicolor en Iris-Virginica. Vier features/attributen die helpen om iets eenduidig als één van de drie klassen te identificeren, zijn sepal-length, sepal-width, petal-length en petal-width.

Voel je vrij om een andere openbare dataset of je eigen dataset te gebruiken.

Sklearn is een Python-bibliotheek voor machine learning die veel wordt gebruikt voor data science-taken. Het bevat diverse algoritmes voor classificatie, regressie en clusteren, waaronder support vector machines, random forests, gradient boosting, k-means, KNN, enzovoort. In sklearn heb je een bibliotheek datasets met meerdere datasets die je voor verschillende taken kunt gebruiken, waaronder de Iris-dataset; al deze datasets kun je zo inladen. Het is behoorlijk intuïtief en rechttoe rechtaan. Laten we dus snel de iris-dataset laden.

from sklearn.datasets import load_iris

load_iris bevat zowel de data als de klasselabels voor elk monster. Laten we die snel extraheren.

data = load_iris().data

De variabele data zal een numpy-array zijn met vorm (150,4) met 150 monsters, elk met vier verschillende attributen. Elke klasse heeft 50 monsters.

data.shape

(150, 4)

Laten we de klasselabels extraheren.

labels = load_iris().target

labels.shape

(150,)

Vervolgens moet je de data en de klasselabels combineren; daarvoor gebruik je een uitstekende Python-bibliotheek genaamd NumPy. NumPy biedt ondersteuning voor grote, multidimensionale arrays en matrices, samen met een uitgebreide collectie wiskundige functies op hoog niveau om op deze arrays te werken. Laten we het snel importeren!

import numpy as np

Aangezien data een 2D-array is, moet je de labels ook herschikken naar een 2D-array.

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

Nu gebruik je de functie concatenate uit de numpy-bibliotheek, met axis=-1 om te concateneren over de tweede dimensie.

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

data.shape

(150, 5)

Vervolgens importeer je de Python-bibliotheek voor data-analyse, pandas, die handig is wanneer je je data in tabelvorm wilt ordenen en er bewerkingen en manipulaties op wilt uitvoeren. In het bijzonder biedt het datastructuren en operaties voor het manipuleren van numerieke tabellen en tijdreeksen.

In de tutorial van vandaag ga je pandas vrij intensief gebruiken.

import pandas as pd

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

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

Je hebt nu het dataset-dataframe met zowel data als de klasselabels die je nodig hebt!

Voordat je verdergaat: bedenk dat de variabele labels klasselabels als numerieke waarden heeft, maar je gaat de numerieke waarden omzetten naar bloemennamen of soorten.

Om dit te doen selecteer je alleen de kolom class en vervang je elk van de drie numerieke waarden door de bijbehorende soort. Je gebruikt inplace=True, waardoor het dataframe dataset wordt aangepast.

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

Laten we de eerste vijf rijen van het dataset afdrukken om te zien hoe het eruitziet!

dataset.head(5)

Analyseer je data

Laten we snel bekijken hoe de drie bloemen eruitzien als je ze visualiseert en hoe ze van elkaar verschillen, niet alleen in cijfers maar ook in het echt!

(Bron)

Laten we de data die je hierboven hebt geladen visualiseren met een scatterplot om te zien in welke mate de ene variabele door de andere wordt beïnvloed, oftewel hoeveel correlatie er tussen de twee variabelen is.

Je gebruikt de bibliotheek matplotlib om de data te visualiseren met een scatterplot.

import matplotlib.pyplot as plt

Tip: Wil je graag verschillende manieren leren om data in Python te visualiseren? Bekijk dan de cursus Introduction to data visualization with matplotlib.

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

Uit de bovenstaande plot blijkt duidelijk dat er een hoge correlatie is voor de Iris setosa-bloemen met betrekking tot sepal length en sepal width. Daarentegen is er minder correlatie tussen Iris versicolor en Iris virginica. De datapunten bij versicolor en virginica zijn meer verspreid, terwijl setosa dichter bij elkaar ligt.

Laten we ook snel de grafiek voor petal-length en petal-width plotten.

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

Ook voor petal-length en petal-width laat de bovenstaande grafiek een sterke correlatie zien voor setosa-bloemen, die dicht bij elkaar geclusterd zijn.

Om de bewering over de correlatie tussen petal-length en petal-width verder te onderbouwen, maken we een correlatiematrix voor alle drie de soorten.

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

De bovenstaande tabel geeft een sterke correlatie van 0.96 aan voor petal-length en petal-width wanneer alle drie de soorten gecombineerd worden.

Laten we ook de correlatie tussen alle drie de soorten afzonderlijk analyseren.

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

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

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

Uit de drie tabellen hierboven blijkt duidelijk dat de correlatie tussen petal-length en petal-width van setosa en virginica respectievelijk 0.33 en 0.32 is. Voor versicolor is dat 0.78.

Vervolgens visualiseren we de featureverdeling door histogrammen te plotten:

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

petal-length, petal-width en sepal-length vertonen een unimodale verdeling, terwijl sepal-width een soort Gauss-verdeling laat zien. Dit zijn nuttige analyses, omdat je dan kunt nadenken over een algoritme dat goed werkt met dit soort verdelingen.

Daarna ga je analyseren of alle vier de attributen op dezelfde schaal staan; dit is een essentieel aspect van ML. Het pandas-dataframe heeft een ingebouwde functie describe die je de count, mean, max, min van de data in tabelvorm geeft.

dataset.describe()

Je ziet dat alle vier de attributen een vergelijkbare schaal hebben tussen 0 en 8 en in centimeters zijn; als je wilt, kun je ze verder schalen naar tussen 0 en 1.

Hoewel je weet dat er 50 monsters per klasse zijn, dus ~33,3% van de totale verdeling, laten we het toch even opnieuw checken!

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

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

Je data preprocessen

Na het laden en uitgebreid analyseren van de data is het tijd om je data voor te bereiden, zodat je die aan je ML-model kunt voeren. In deze sectie preprocess je je data op twee manieren: je data normaliseren en je data splitsen in trainings- en testsets.

Je data normaliseren

Er zijn twee manieren waarop je je data kunt normaliseren:

• Voorbeeldnormalisatie, waarbij je elk monster afzonderlijk normaliseert,
• Featurenormalisatie, waarbij je elke feature op dezelfde manier normaliseert over alle monsters.

De vraag is nu: waarom of wanneer moet je je data normaliseren? En moet je de Iris-data standaardiseren?

Nou, het antwoord is: bijna altijd. Het is een goede gewoonte om je data te normaliseren, omdat dit alle monsters op dezelfde schaal en in hetzelfde bereik brengt. Data normaliseren is cruciaal wanneer je data niet consistent is. Je kunt inconsistentie controleren met de functie describe() die je hierboven hebt gezien; die geeft je max- en min-waarden. Als de max- en min-waarden van de ene feature aanzienlijk groter zijn dan die van een andere feature, is het erg belangrijk om beide features naar dezelfde schaal te normaliseren.

Stel dat X een feature is met een groter bereik en Y de tweede feature met een kleiner bereik. Dan kan de invloed van feature Y worden overschaduwd door de invloed van feature X. In zo’n geval is het belangrijk om zowel feature X als Y te normaliseren.

Voor de Iris-data is normaliseren niet nodig.

Laten we de functie describe() nog eens afdrukken en zien waarom je geen normalisatie nodig hebt.

dataset.describe()

Het attribuut sepal-length heeft waarden van 4,3 tot 7,9 en sepal-width bevat waarden van 2 tot 4,4, terwijl petal-length varieert van 1 tot 6,9 en petal-width van 0,1 tot 2,5. De waarden van alle features liggen tussen 0,1 en 7,9, wat je acceptabel kunt vinden. Daarom hoef je geen normalisatie toe te passen op de Iris-dataset.

De data splitsen

Dit is een ander belangrijk aspect van machine learning, want je doel is een model te maken dat in een testomgeving zelfstandig beslissingen kan nemen of data kan classificeren zonder menselijke tussenkomst. Daarom moet je, voordat je je ML-model in de praktijk inzet, zeker weten dat het model goed kan generaliseren naar de testdata.

Hiervoor heb je een trainings- en een testset nodig. Terug naar de Iris-data: je hebt 150 monsters; je traint je ML-model op 80% van de data en gebruikt de resterende 20% voor testen.

In data science kom je vaak de term overfitting tegen, wat betekent dat je model de trainingsdata heel goed heeft geleerd, maar slecht presteert op de testdata. Het splitsen van de data in een trainings- en test- of validatieset helpt je vaak om te bepalen of je model overfit of niet.

Voor het splitsen in trainings- en testset gebruik je de sklearn-bibliotheek, die een ingebouwde splitfunctie train_test_split heeft. Laten we de data splitsen.

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) 

Merk op dat random_state een seed is die een random_state als invoer neemt; als je het getal verandert, verandert ook de datasplit. Als je echter random_state gelijk houdt en de cel meerdere keren uitvoert, blijft de datasplit ongewijzigd.

Laten we snel de vorm van de trainings- en testdata en hun labels afdrukken.

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

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

Eindelijk is het tijd om de data aan het k-nearest neighbor-algoritme te voeren!

Het KNN-model

Na het laden, analyseren en preprocessen van de data is het nu tijd om de data in het KNN-model te voeren. Hiervoor gebruik je de ingebouwde functie neighbors van sklearn, met daarin een klasse KNeigborsClassifier.

Laten we beginnen met het importeren van de classifier.

from sklearn.neighbors import KNeighborsClassifier

Let op: de k-parameter (n_neighbors) is vaak oneven om gelijke standen in de stemmingsscores te vermijden.

Om de beste waarde voor hyperparameter k te bepalen, doe je iets dat grid-search heet. Je traint en test je model op 10 verschillende k-waarden en gebruikt uiteindelijk de waarde die de beste resultaten geeft.

Laten we een variabele neighbors(k) initialiseren met waarden van 1–9 en twee numpy nulmatrices, train_accuracy en test_accuracy, voor respectievelijk de trainings- en testnauwkeurigheid. Je hebt ze later nodig om een grafiek te plotten om de beste neighbor-waarde te kiezen.

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

In het volgende codeblok gebeurt alle magie. Je enumerate over alle negen neighbor-waarden en voor elke neighbor voorspel je zowel op de trainings- als testdata. Tot slot sla je de nauwkeurigheid op in de numpy-arrays train_accuracy en test_accuracy.

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)

Vervolgens plot je de trainings- en testnauwkeurigheid met matplotlib; met een grafiek accuracy vs. varying number of neighbors kun je de beste k-waarde kiezen waarop je model het best presteert.

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

Als we naar de bovenstaande grafiek kijken, lijkt het erop dat wanneer n_neighbors=3 is, beide modellen het best presteren. Laten we dus n_neighbors=3 aanhouden en de training opnieuw uitvoeren.

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)

Je model evalueren

In het laatste deel van deze tutorial evalueer je je model op de testdata met een paar technieken zoals confusion_matrix en classification_report.

Laten we eerst de nauwkeurigheid van het model op de testdata controleren.

test_accuracy

0.9666666666666667

Voilà! Het lijkt erop dat het model 96,66% van de testdata correct wist te classificeren. Best gaaf, toch? Met slechts een paar regels code heb je een ML-model getraind dat nu op basis van slechts vier features met 96,66% nauwkeurigheid kan vertellen welke bloem het is. Wie weet presteerde het zelfs beter dan een mens.

Confusion matrix

Een confusion matrix wordt vooral gebruikt om de prestaties van je model te beschrijven op testdata waarvan de echte waarden of labels bekend zijn.

Scikit-learn biedt een functie die de confusion matrix voor je berekent.

prediction = knn.predict(test_data)

De volgende functie plot_confusion_matrix() is aangepast en afkomstig van deze bron.

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

Uit de bovenstaande confusion_matrix-plot kun je aflezen dat het model alle bloemen correct classificeerde, op één virginica-bloem na die als versicolor werd geclassificeerd.

Classification report

Een classification report helpt je om de verkeerd geclassificeerde klassen veel gedetailleerder te identificeren door precision, recall en F1-score per klasse te geven. Je gebruikt de sklearn-bibliotheek om het classification report te genereren.

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

Ga verder!

Allereerst gefeliciteerd aan iedereen die het tot het einde heeft gehaald! Maar dit was nog maar het begin. Er is nog een lange weg te gaan!

Deze tutorial ging vooral over de basis van machine learning en de implementatie van één type ML-algoritme, namelijk KNN met Python. De Iris-dataset die je gebruikte was vrij klein en vrij eenvoudig.

Als deze tutorial je nieuwsgierigheid heeft gewekt om meer te leren, kun je andere datasets proberen of je verdiepen in andere ML-algoritmes en die misschien op de Iris-dataset toepassen om het effect op de nauwkeurigheid te zien. Zo leer je veel meer dan alleen de theorie begrijpen!

Als je genoeg hebt geëxperimenteerd met de basis uit deze tutorial en andere machinelearningalgoritmes, wil je misschien verder de diepte in met Python en data-analyse.