PCA: variantie, eigenvectoren en hoofdcomponenten
Cursisten trainen PCA op een hoogdimensionale dataset, bekijken de verklaarde variantieverhoudingen en kiezen het aantal componenten dat 95% van de totale variantie behoudt.
PCA: variantie, eigenvectoren en hoofdcomponenten is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Het probleem met gegevens met veel dimensies
Naarmate het aantal kenmerken groeit, worden gegevensverzamelingen steeds ijler — dit is de vloek van dimensionaliteit. Veel kenmerken zijn redundant of gecorreleerd en bevatten overlappende informatie. Principal Component Analysis (PCA) lost dit op door een nieuwe, kleinere verzameling assen (hoofdcomponenten) te vinden die met zo weinig mogelijk dimensies de maximale variantie in de gegevens vastlegt.
Variantie: wat PCA maximaliseert
PCA zoekt richtingen in de kenmerkruimte waarin de gegevens het meest variëren. Een richting met hoge variantie bevat veel informatie; een richting met bijna geen variantie is in feite ruis. De eerste hoofdcomponent (PC1) is de richting met maximale variantie, PC2 staat loodrecht op PC1 en heeft de op één na hoogste variantie, enzovoort.
Covariantiematrix en eigenvectoren
PCA werkt op de covariantiematrix van de gecentreerde gegevens. De eigenvectoren van deze matrix wijzen in de richtingen met maximale variantie, en de bijbehorende eigenwaarden meten hoeveel variantie elke richting vastlegt. De eigenvectoren zijn de hoofdcomponenten; als je ze aflopend op eigenwaarde sorteert, krijg je PC1, PC2, ... PCn.
import numpy as np
X = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9],
[1.9, 2.2], [3.1, 3.0], [2.3, 2.7]])
# Centre the data
X_centered = X - X.mean(axis=0)
# Compute covariance matrix
cov = np.cov(X_centered.T)
print('Covariance matrix:\n', cov)
# Eigenvectors and eigenvalues
eigenvalues, eigenvectors = np.linalg.eigh(cov)
idx = np.argsort(eigenvalues)[::-1]
print('Eigenvalues:', eigenvalues[idx])
print('PC1 direction:', eigenvectors[:, idx[0]])Verklaarde variantieverhouding
De verklaarde variantieverhouding van elke component is de eigenwaarde ervan gedeeld door de som van alle eigenwaarden. Als PC1 90% van de variantie verklaart en PC2 8%, behouden de eerste twee componenten samen 98% van alle informatie. Deze verhouding helpt bepalen hoeveel componenten je moet behouden — een veelgebruikte drempel is 95%.
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True) # 64 features
pca = PCA()
pca.fit(X)
cumulative_variance = pca.explained_variance_ratio_.cumsum()
n_95 = (cumulative_variance < 0.95).sum() + 1
print(f'Components to retain 95% variance: {n_95}')
print(f'Explained by first 10 components: {cumulative_variance[9]:.3f}')n_components kiezen
Stel n_components in als een geheel getal (bijvoorbeeld PCA(n_components=10)) om precies 10 componenten te behouden, of als een kommagetal tussen 0 en 1 (bijvoorbeeld PCA(n_components=0.95)) om automatisch genoeg componenten te behouden om dat deel van de variantie te verklaren. De laatste aanpak is het duidelijkst voor pijplijnen waarin je wilt afkappen op basis van variantie zonder vooraf het aantal te kennen.
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True)
# Retain 95% of variance automatically
pca = PCA(n_components=0.95)
pca.fit(X)
print('Number of components chosen:', pca.n_components_)
print('Total variance retained:', pca.explained_variance_ratio_.sum().round(4))De screeplot
Een screeplot toont de verklaarde variantieverhouding (of eigenwaarde) op de y-as en de componentindex op de x-as. De grafiek vertoont doorgaans eerst een sterke daling en daarna een vlak plateau. De elleboog — het punt waarop de daling geleidelijker wordt — is een andere vuistregel voor het aantal te behouden componenten, vergelijkbaar met de elleboogmethode in K-Means.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine
X, _ = load_wine(return_X_y=True)
pca = PCA()
pca.fit(X)
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.bar(range(1, 14), pca.explained_variance_ratio_)
plt.xlabel('Component')
plt.ylabel('Explained variance ratio')
plt.title('Scree Plot')
plt.subplot(1, 2, 2)
plt.plot(pca.explained_variance_ratio_.cumsum(), marker='o')
plt.axhline(0.95, color='red', linestyle='--')
plt.xlabel('Number of components')
plt.ylabel('Cumulative variance')
plt.tight_layout()
plt.show()Centreren en schalen vóór PCA
PCA is gevoelig voor de schaal van kenmerken. Een kenmerk dat in duizenden wordt gemeten, bepaalt de covariantiematrix. Standaardiseer altijd met StandardScaler vóór PCA om elk kenmerk een variantie van één te geven. Centreren (gemiddelde nul) is essentieel — PCA doet dit impliciet, maar als je een Pipeline gebruikt, moet de scaler eerst komen zodat PCA werkt met al gecentreerde kenmerken op dezelfde schaal.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine
X, _ = load_wine(return_X_y=True)
pipe = Pipeline([
('scaler', StandardScaler()),
('pca', PCA(n_components=0.95))
])
pipe.fit(X)
print('Original shape:', X.shape)
print('Reduced shape:', pipe.transform(X).shape)Wat stellen hoofdcomponenten voor?
Elke hoofdcomponent is een lineaire combinatie van de oorspronkelijke kenmerken — een gewogen som. Als je de ladingen van de componenten (de coëfficiënten) bekijkt, zie je welke oorspronkelijke kenmerken het meest bijdragen aan elke PC. Componenten zijn echter vaak niet direct interpreteerbaar, omdat ze kenmerken met elkaar vermengen. PCA is voornamelijk een compressietechniek en geen techniek voor kenmerkselectie.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_wine
import pandas as pd
X, _ = load_wine(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=2)
pca.fit(X_scaled)
feature_names = load_wine().feature_names
loadings = pd.DataFrame(pca.components_.T, index=feature_names,
columns=['PC1', 'PC2'])
print(loadings.round(2))SVD: de efficiënte implementatie
In de praktijk berekent scikit-learn PCA via Singular Value Decomposition (SVD) in plaats van via een expliciete eigendecompositie van de covariantiematrix, omdat SVD numeriek stabieler is en rechtstreeks op de datamatrix werkt zonder de covariantiematrix te vormen. Het resultaat is wiskundig identiek. Voor zeer grote datasets gebruikt PCA(svd_solver='randomized') een benaderende gerandomiseerde SVD voor extra snelheid.
PCA is lineair en orthogonaal
Belangrijke beperkingen: PCA vindt alleen lineaire relaties tussen kenmerken. Als de betekenisvolle structuur in je gegevens op een gekromde variëteit ligt (bijvoorbeeld een Swiss roll), zal PCA die niet effectief ontdekken — kernel-PCA of t-SNE zijn betere alternatieven. Bovendien zijn PCA-componenten per constructie orthogonaal, wat niet goed kan passen als je onderliggende factoren gecorreleerd zijn.
PCA op een echte dataset: snel van begin tot eind
Hier is de volledige werkwijze: schalen, PCA naar 2D uitvoeren en een spreidingsdiagram maken met kleuren per klasse om te controleren of de gereduceerde ruimte de klassen visueel nog steeds scheidt. Dit is een standaard verkennende stap voordat je een classificatiemodel op de volledige verzameling kenmerken traint.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
X, y = load_iris(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X_scaled)
plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set1', s=30)
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} var)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} var)')
plt.title('Iris in PCA space')
plt.colorbar(label='Class')
plt.show()Snelle controle
Test je begrip van PCA uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat PCA richtingen met maximale variantie vindt via de eigenvectoren van de covariantiematrix, dat de verhouding verklaarde variantie aangeeft hoeveel componenten je moet behouden (doorgaans streef je naar 95%) en dat je kenmerken altijd moet standaardiseren voordat je PCA uitvoert, zodat schaalverschillen de componenten niet vertekenen. Hierna projecteren we gegevens naar de ruimte van de hoofdcomponenten en reconstrueren we ze om het informatieverlies te kwantificeren.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “PCA: variantie, eigenvectoren en hoofdcomponenten” gratis?
Ja — de volledige tekst van “PCA: variantie, eigenvectoren en hoofdcomponenten” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “PCA: variantie, eigenvectoren en hoofdcomponenten”?
Cursisten trainen PCA op een hoogdimensionale dataset, bekijken de verklaarde variantieverhoudingen en kiezen het aantal componenten dat 95% van de totale variantie behoudt. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “PCA: variantie, eigenvectoren en hoofdcomponenten”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- PCA: variantie, eigenvectoren en hoofdcomponenten
- Gegevens projecteren en reconstrueren vanuit componenten
- t-SNE: buurten behouden voor visualisatie
- PCA als preprocessing: snelheid en ruisreductie in pipelines