Machine Learning met Python: Een Introductie

Wat is Machine Learning?

Machine Learning (ML) is een onderdeel van kunstmatige intelligentie (AI) waarbij computers leren patronen herkennen en voorspellingen maken zonder expliciet geprogrammeerd te worden voor elke specifieke taak. In plaats van regels te schrijven, trainen we modellen met data zodat ze zelf kunnen leren.

Denk aan het als het verschil tussen een traditioneel programma dat zegt "als de temperatuur boven 25°C is, draag een t-shirt" versus een ML-model dat kijkt naar duizenden foto's van mensen in verschillende weersomstandigheden en leert wanneer mensen t-shirts dragen.

Types Machine Learning

Er zijn drie hoofdcategorieën van machine learning:

1. Supervised Learning (Begeleid Leren)

Het model leert van gelabelde voorbeelden:

• Classification: Voorspelt categorieën (spam/niet-spam, hond/kat)
• Regression: Voorspelt numerieke waarden (huizenprijzen, temperatuur)

2. Unsupervised Learning (Onbegeleid Leren)

Het model zoekt patronen in data zonder labels:

• Clustering: Groepeert vergelijkbare data
• Dimensionality Reduction: Vereenvoudigt complexe data

3. Reinforcement Learning (Versterkingsleren)

Het model leert door trial-and-error met beloningen en straffen, zoals bij spellen of robotica.

Waarom Python voor Machine Learning?

Python is de meest populaire taal voor ML om verschillende redenen:

• Eenvoudige syntax: Focus op algoritmes, niet op complexe code
• Rijke ecosysteem: Vele gespecialiseerde libraries
• Sterke community: Veel hulp en resources beschikbaar
• Integratie: Werkt goed samen met web frameworks en databases
• Visualisatie: Uitstekende plotting capabilities

Belangrijke Python Libraries

Scikit-learn

De go-to library voor traditionele machine learning:

pip install scikit-learn

NumPy en Pandas

Voor data manipulatie en numerieke berekeningen:

pip install numpy pandas

Matplotlib en Seaborn

Voor data visualisatie:

pip install matplotlib seaborn

Je Eerste ML Project: Iris Classification

Laten we een klassiek ML probleem oplossen - het classificeren van Iris bloemen:

1. Data Laden en Verkennen

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# Iris dataset laden
iris = load_iris()
X = iris.data  # Features: sepal length, sepal width, petal length, petal width
y = iris.target  # Target: species (setosa, versicolor, virginica)

# Data in DataFrame voor makkelijkere manipulatie
df = pd.DataFrame(X, columns=iris.feature_names)
df['species'] = iris.target
df['species_name'] = df['species'].map({0: 'setosa', 1: 'versicolor', 2: 'virginica'})

print("Dataset overzicht:")
print(df.head())
print(f"\nDataset shape: {df.shape}")
print(f"\nSpecies verdeling:")
print(df['species_name'].value_counts())

2. Data Visualisatie

# Pairplot om relaties tussen features te zien
plt.figure(figsize=(12, 8))
sns.pairplot(df, hue='species_name', markers=["o", "s", "D"])
plt.suptitle('Iris Dataset - Feature Relationships', y=1.02)
plt.show()

# Correlatie matrix
plt.figure(figsize=(8, 6))
correlation_matrix = df[iris.feature_names].corr()
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', center=0)
plt.title('Feature Correlation Matrix')
plt.show()

# Boxplot voor feature distributie
plt.figure(figsize=(15, 10))
for i, feature in enumerate(iris.feature_names):
    plt.subplot(2, 2, i+1)
    sns.boxplot(data=df, x='species_name', y=feature)
    plt.title(f'{feature} by Species')
plt.tight_layout()
plt.show()

3. Data Preprocessing

# Features en target scheiden
X = iris.data
y = iris.target

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"Training set: {X_train.shape}")
print(f"Test set: {X_test.shape}")

# Optioneel: Feature scaling (voor sommige algoritmes belangrijk)
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

4. Model Training en Evaluatie

# Verschillende modellen proberen
models = {
    'Logistic Regression': LogisticRegression(random_state=42),
    'Decision Tree': DecisionTreeClassifier(random_state=42),
    'Random Forest': RandomForestClassifier(random_state=42, n_estimators=100)
}

results = {}

for name, model in models.items():
    # Model trainen
    if name == 'Logistic Regression':
        # Logistic Regression werkt beter met geschaalde data
        model.fit(X_train_scaled, y_train)
        y_pred = model.predict(X_test_scaled)
    else:
        model.fit(X_train, y_train)
        y_pred = model.predict(X_test)
    
    # Accuracy berekenen
    accuracy = accuracy_score(y_test, y_pred)
    results[name] = accuracy
    
    print(f"\n=== {name} ===")
    print(f"Accuracy: {accuracy:.3f}")
    print(f"Classification Report:")
    print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Beste model selecteren
best_model = max(results, key=results.get)
print(f"\nBeste model: {best_model} (Accuracy: {results[best_model]:.3f})")

5. Model Evaluatie en Visualisatie

# Confusion matrix voor beste model
best_clf = models[best_model]
if best_model == 'Logistic Regression':
    y_pred_best = best_clf.predict(X_test_scaled)
else:
    y_pred_best = best_clf.predict(X_test)

# Confusion matrix
cm = confusion_matrix(y_test, y_pred_best)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
            xticklabels=iris.target_names, 
            yticklabels=iris.target_names)
plt.title(f'Confusion Matrix - {best_model}')
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()

# Feature importance (voor tree-based models)
if best_model in ['Decision Tree', 'Random Forest']:
    feature_importance = best_clf.feature_importances_
    feature_names = iris.feature_names
    
    plt.figure(figsize=(10, 6))
    indices = np.argsort(feature_importance)[::-1]
    plt.bar(range(len(feature_importance)), feature_importance[indices])
    plt.xticks(range(len(feature_importance)), 
               [feature_names[i] for i in indices], rotation=45)
    plt.title(f'Feature Importance - {best_model}')
    plt.tight_layout()
    plt.show()

Praktisch Voorbeeld: Huizenprijzen Voorspellen

Laten we een regression probleem aanpakken:

from sklearn.datasets import fetch_california_housing
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score

# California housing dataset
housing = fetch_california_housing()
X, y = housing.data, housing.target

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Random Forest Regressor
rf_regressor = RandomForestRegressor(n_estimators=100, random_state=42)
rf_regressor.fit(X_train, y_train)

# Voorspellingen
y_pred = rf_regressor.predict(X_test)

# Evaluatie
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"Mean Squared Error: {mse:.2f}")
print(f"R² Score: {r2:.3f}")

# Voorspellingen vs werkelijke waarden
plt.figure(figsize=(10, 6))
plt.scatter(y_test, y_pred, alpha=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Werkelijke Prijzen')
plt.ylabel('Voorspelde Prijzen')
plt.title('Voorspelde vs Werkelijke Huizenprijzen')
plt.show()

# Feature importance
feature_importance = rf_regressor.feature_importances_
feature_names = housing.feature_names

plt.figure(figsize=(10, 6))
indices = np.argsort(feature_importance)[::-1]
plt.bar(range(len(feature_importance)), feature_importance[indices])
plt.xticks(range(len(feature_importance)), 
           [feature_names[i] for i in indices], rotation=45)
plt.title('Feature Importance - Huizenprijzen Model')
plt.tight_layout()
plt.show()

Model Optimalisatie

Verbetering van model prestaties:

Cross-Validation

from sklearn.model_selection import cross_val_score, GridSearchCV

# K-fold cross-validation
rf = RandomForestClassifier(random_state=42)
cv_scores = cross_val_score(rf, X_train, y_train, cv=5)

print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV score: {cv_scores.mean():.3f} (+/- {cv_scores.std() * 2:.3f})")

Hyperparameter Tuning

# Grid Search voor beste parameters
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 7, None],
    'min_samples_split': [2, 5, 10]
}

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)

grid_search.fit(X_train, y_train)

print(f"Beste parameters: {grid_search.best_params_}")
print(f"Beste CV score: {grid_search.best_score_:.3f}")

# Beste model evalueren
best_rf = grid_search.best_estimator_
y_pred_tuned = best_rf.predict(X_test)
tuned_accuracy = accuracy_score(y_test, y_pred_tuned)
print(f"Test accuracy met tuned model: {tuned_accuracy:.3f}")

Clustering: Unsupervised Learning

Laten we kijken naar clustering zonder labels:

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Data voor clustering (zonder labels)
X_cluster = iris.data

# Data schalen voor clustering
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_cluster)

# K-Means clustering
kmeans = KMeans(n_clusters=3, random_state=42)
cluster_labels = kmeans.fit_predict(X_scaled)

# Resultaten visualiseren
plt.figure(figsize=(12, 5))

# Originele labels
plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis')
plt.title('Werkelijke Species')
plt.xlabel('Sepal Length')
plt.ylabel('Sepal Width')

# Cluster labels
plt.subplot(1, 2, 2)
plt.scatter(X[:, 0], X[:, 1], c=cluster_labels, cmap='viridis')
plt.title('K-Means Clusters')
plt.xlabel('Sepal Length')
plt.ylabel('Sepal Width')

plt.tight_layout()
plt.show()

# Cluster prestatie evalueren
from sklearn.metrics import adjusted_rand_score
ari_score = adjusted_rand_score(y, cluster_labels)
print(f"Adjusted Rand Index: {ari_score:.3f}")

Best Practices voor ML Projects

1. Data Quality

• Controleer op ontbrekende waarden
• Identificeer en behandel outliers
• Zorg voor representative data
• Valideer data consistency

2. Feature Engineering

# Voorbeelden van feature engineering
# Nieuwe features maken
df['sepal_ratio'] = df['sepal length (cm)'] / df['sepal width (cm)']
df['petal_ratio'] = df['petal length (cm)'] / df['petal width (cm)']
df['sepal_area'] = df['sepal length (cm)'] * df['sepal width (cm)']

# Categorische encoding
from sklearn.preprocessing import LabelEncoder, OneHotEncoder

# Feature selection
from sklearn.feature_selection import SelectKBest, f_classif

selector = SelectKBest(score_func=f_classif, k=2)
X_selected = selector.fit_transform(X, y)
selected_features = selector.get_support(indices=True)
print(f"Geselecteerde features: {[iris.feature_names[i] for i in selected_features]}")

3. Model Evaluation

# Meer evaluatie metrics
from sklearn.metrics import precision_score, recall_score, f1_score

# Voor classification
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')

print(f"Precision: {precision:.3f}")
print(f"Recall: {recall:.3f}")
print(f"F1-score: {f1:.3f}")

# Learning curves
from sklearn.model_selection import learning_curve

train_sizes, train_scores, val_scores = learning_curve(
    RandomForestClassifier(random_state=42),
    X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 10)
)

plt.figure(figsize=(10, 6))
plt.plot(train_sizes, np.mean(train_scores, axis=1), 'o-', label='Training score')
plt.plot(train_sizes, np.mean(val_scores, axis=1), 'o-', label='Validation score')
plt.xlabel('Training Set Size')
plt.ylabel('Accuracy Score')
plt.title('Learning Curves')
plt.legend()
plt.grid(True)
plt.show()

Common Pitfalls en Hoe Ze te Vermijden

1. Overfitting

Model werkt goed op training data maar slecht op nieuwe data:

• Gebruik cross-validation
• Implementeer regularisatie
• Verzamel meer training data
• Reduceer model complexiteit

2. Data Leakage

Toekomstige informatie lekt naar het model:

• Zorgvuldige feature selection
• Correct train-validation-test split
• Time-aware splits voor temporele data

3. Imbalanced Data

# Technieken voor imbalanced datasets
from sklearn.utils.class_weight import compute_class_weight
from imblearn.over_sampling import SMOTE

# Class weights
class_weights = compute_class_weight(
    'balanced', 
    classes=np.unique(y_train), 
    y=y_train
)

# SMOTE voor oversampling
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

Volgende Stappen in ML

Nu je de basics kent, kun je verder gaan met:

Geavanceerde Algoritmes

• Support Vector Machines (SVM): Voor complexe classificatie
• Gradient Boosting: XGBoost, LightGBM voor competities
• Neural Networks: TensorFlow, PyTorch voor deep learning

Specialized Domains

• Natural Language Processing: Tekstanalyse met NLTK, spaCy
• Computer Vision: Beeldherkenning met OpenCV
• Time Series: Forecasting met statsmodels

MLOps en Productie

• Model Deployment: Flask, FastAPI voor APIs
• Model Monitoring: Drift detection en performance tracking
• Version Control: MLflow, DVC voor model versioning

Praktische Tips voor Beginners

1. Start Klein: Begin met eenvoudige datasets en problemen
2. Begrijp je Data: Spendeer tijd aan exploratory data analysis
3. Experimenteer: Probeer verschillende algoritmes en parameters
4. Documenteer: Houd bij wat werkt en wat niet
5. Valideer: Gebruik altijd proper validation technieken
6. Itereer: ML is een cyclisch proces van verbetering

Conclusie

Machine Learning met Python opent een wereld van mogelijkheden. Van het voorspellen van huizenprijzen tot het herkennen van afbeeldingen, de toepassingen zijn eindeloos. De combinatie van Python's simpliciteit en de kracht van libraries zoals scikit-learn maakt ML toegankelijk voor iedereen.

Het belangrijkste is om te beginnen met echte problemen en geleidelijk complexere technieken te leren. Elke ML-expert begon ooit met hun eerste "Hello World" model.

Klaar om je ML-reis te beginnen? Bekijk onze Data Science & AI cursus of neem contact met ons op voor persoonlijke begeleiding!