Iris Flower Classification

1. Overzicht

Doel: We bouwen onze eerste Machine Learning (ML) programma. We leren een computer te trainen om verschillende soorten Iris-bloemen te classificeren op basis van hun fysieke afmetingen.

Waarom dit onderwerp?

• Intuïtieve Data: De data bestaat uit fysieke metingen (lengte/breedte) die makkelijk te visualiseren zijn.
• Clean Dataset: We gebruiken de beroemde “Iris Dataset” die is ingebouwd in Python, waardoor we complexe data cleaning vermijden.
• Duidelijk Doel: De doelstelling is simpel: classificeer een bloem in één van de drie categorieën (Setosa, Versicolor of Virginica).

2. Kernconcepten

Voordat we gaan coderen, behandelen we de vier pijlers van Supervised Learning:

Note

• Petal: Bloesemblad
• Sepal: Kelkblad

1. Features (Inputs): De data die we hebben (Sepal Length, Sepal Width, Petal Length, Petal Width).
2. Labels (Outputs): Het antwoord dat we willen voorspellen (De naam van de soort).
3. Het Algoritme (K-Nearest Neighbors):
   • Concept: “Als het eruitziet als een eend en loopt als een eend, is het waarschijnlijk een eend.”
   • Wiskunde: Als een nieuwe bloem afmetingen heeft die lijken op de “Setosa” bloemen die we eerder hebben gezien, classificeert de computer deze als een Setosa.
4. Train/Test Split: De “Gouden Regel” van ML. We testen het model nooit op dezelfde vragen die ze bestudeerd hebben (de training data). We verbergen 20% van de data voor het eindexamen.

3. Deel I: De Core Logic

Doel

Het model trainen en de Accuracy Score berekenen.

pip install scikit-learn

import sklearn;

sklearn.show_versions()

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 1. Laad de Data
iris = load_iris()
f = iris.data   # De metingen (Features) [sepal lengte, sepal breedte, petal lengte, sepal breedte]
l = iris.target # De soort (Labels)

# 2. Split de Data (80% om te studeren, 20% voor het examen)
f_train, f_test, l_train, l_test = train_test_split(f, l, test_size=0.2, random_state=42)

# 3. Initialiseer het Model
# We kijken naar de 3 'nearest neighbors' om een beslissing te nemen
model = KNeighborsClassifier(n_neighbors=3)

# 4. Train het Model (Fit)
model.fit(f_train, l_train)

# 5. Maak Voorspellingen (Predictions)
predictions = model.predict(f_test)

# 6. Beoordeel het Model
score = accuracy_score(l_test, predictions)
print(f"Model Accuracy: {score * 100}%")

4. Deel II: Visualisatie

Doel

We plotten de twee meest uitgesproken features (Petal Length vs. Petal Width) om te laten zien hoe de soorten van nature ‘clusteren’.

• Het “Setosa” cluster (Rood) is ver verwijderd van de anderen, waardoor het heel makkelijk te identificeren is.
• Waar Groen en Blauw in het midden mengen - dit is waar de AI fouten zou kunnen maken (de Decision Boundary).

import matplotlib.pyplot as plot
from sklearn.datasets import load_iris

# 1. Laad Data
iris = load_iris()
f = iris.data
l = iris.target
names = iris.target_names

# 2. Creëer Plot
plot.figure(figsize=(10, 6))
colors = ['red', 'green', 'blue']

# 3. Loop door de soorten (species) en plot ze
for i in range(3):
    # Plot Petal Length (kolom 2) vs Petal Width (kolom 3)
    # f[l == i, 2] betekent: Selecteer rijen waar label 'i' is, pak kolom 2
    plot.scatter(f[l == i, 2], f[l == i, 3], color=colors[i], label=names[i])

plot.xlabel('Petal Length (cm)')
plot.ylabel('Petal Width (cm)')
plot.title('Iris Species Clusters')
plot.legend()
plot.show()

5. Deel III: De Interactieve App

Doel

Het abstracte model veranderen in een tool die we kunnen gebruiken. We voeren custom metingen in om live predictions te zien.

• Klassikale Activiteit: “De Onmogelijke Bloem”
• Voer onmogelijke getallen in (bijv. 100cm lengte, 0.1cm breedte).
• De AI zal nog steeds een antwoord geven! Dit leert ons dat AI zelfverzekerd is, zelfs als het fout zit.
• Het classificeert op basis van wiskundige nabijheid, niet op basis van gezond verstand.

from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier

# Setup
iris = load_iris()
model = KNeighborsClassifier(n_neighbors=3)
model.fit(iris.data, iris.target)

print("AI FLOWER PREDICTOR READY")

print("Voer metingen in (cm):")
val1 = input("Sepal Length: ")
val2 = input("Sepal Width:  ")
val3 = input("Petal Length: ")
val4 = input("Petal Width:  ")

# Input omzetten naar een 2D list voor het model
features = [[float(val1), float(val2), float(val3), float(val4)]]

pred = model.predict(features)
print(f"Prediction: {iris.target_names[pred[0]].upper()}")

6. Deel IV: Externe Datasets

In de praktijk zitten datasets niet ingebouwd in Python. Data Scientists downloaden vaak CSV-bestanden van platforms zoals Kaggle.

Om externe data in te laden, gebruiken we de bibliotheek Pandas.

Setup

Installeer pandas via je terminal:

pip install pandas

Hoe download je data van Kaggle?

1. Maak een account aan op Kaggle.com.
2. Zoek naar een dataset (bijv. “Heart Disease UCI”).
3. Ga naar Input tab en klik op de Download knop (meestal rechtsboven).
4. Je krijgt een .zip bestand. Unzip dit uit.
5. Zet het .csv bestand (bijv. heart.csv) in dezelfde map als je Python script.

Hier is een voorbeeld van hoe je een CSV-bestand zou inladen en gebruiken:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 1. Laad de CSV met Pandas
# Stel je hebt een bestand 'heart.csv' gedownload van Kaggle
df = pd.read_csv('heart.csv')

# Bekijk de eerste paar rijen
print(df.head())

# 2. Selecteer Features (f) en Target (l)
# Stel we willen voorspellen of iemand hartziekte heeft (kolom 'target')
# We droppen de target kolom uit f, zodat f alleen de features bevat
f = df.drop('target', axis=1)
l = df['target']

# 3. De standaard ML flow (hetzelfde als voorheen)
f_train, f_test, l_train, l_test = train_test_split(f, l, test_size=0.2, random_state=42)

model = KNeighborsClassifier(n_neighbors=5)
model.fit(f_train, l_train)

score = accuracy_score(l_test, model.predict(f_test))
print(f"Accuracy op externe data: {score * 100:.2f}%")

Assignment

Onderwerp: De Wijnkenner (The Wine Connoisseur)

Instructies:

1. Nu je bloemen onder de knie hebt, ben je ingehuurd door een wijngaard.
2. In plaats van load_iris, importeer je load_wine van sklearn.datasets.
3. De Wine dataset probeert de “Class” van een wijn te raden op basis van 13 ingrediënten (Alcohol, Malic Acid, Ash, etc.) in plaats van 4 bloemmetingen.
4. Taak: Pas de code van “Deel I” aan om de wijn-data te laden, te splitten, een KNN model te trainen en de Accuracy Score te printen.

Challenge

Voorspelt het model Wijn net zo nauwkeurig als Bloemen?
Als de accuracy lager is, probeer dan n_neighbors=3 te veranderen naar n_neighbors=5 of n_neighbors=1. Helpt dit?

Toy Datasets

Naam Dataset	Python Functie	Type Probleem	Beschrijving
Iris	load_iris()	Classificatie	Classificatie van 3 soorten bloemen op basis van bloembladmetingen.
Wine	load_wine()	Classificatie	Herkennen van 3 verschillende wijncultivars uit Italië.
Digits	load_digits()	Classificatie	Herkennen van handgeschreven cijfers (lage resolutie 8x8 afbeeldingen).
Breast Cancer	load_breast_cancer()	Classificatie	Medische diagnose (kwaadaardig vs. goedaardig) op basis van celkenmerken.
Diabetes	load_diabetes()	Regressie	Voorspellen van ziekteprogressie na één jaar.