Gegevens projecteren en reconstrueren vanuit componenten
Cursisten transformeren een dataset naar de ruimte van de hoofdcomponenten, visualiseren de 2D-projectie en reconstrueren de oorspronkelijke features om informatieverlies te kwantificeren.
Gegevens projecteren en reconstrueren vanuit componenten is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 2 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.
Projectie: van hoge naar lage dimensie
Nadat PCA de hoofdcomponenten heeft gevonden, transformeert projectie elk datapunt naar de nieuwe componentruimte. De geprojecteerde coördinaten heten scores. Als je slechts 2 componenten behoudt van 64 oorspronkelijke kenmerken, wordt elk punt met 64 dimensies een score met 2 dimensies. Dit bereik je door de gecentreerde datamatrix te vermenigvuldigen met de matrix van eigenvectoren (de matrix met ladingen).
De methode transform in sklearn
In scikit-learn leert pca.fit(X) de componenten en projecteert pca.transform(X) de gegevens. De handige methode pca.fit_transform(X) voert beide bewerkingen uit in één aanroep. Het resultaat is een matrix met vorm (n_samples, n_components) — elke rij is een punt in de gereduceerde ruimte.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, y = load_digits(return_X_y=True) # 1797 x 64
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=10)
X_reduced = pca.fit_transform(X_scaled)
print('Original shape:', X_scaled.shape)
print('Reduced shape:', X_reduced.shape)
print('Variance retained:', pca.explained_variance_ratio_.sum().round(4))De 2D-projectie visualiseren
Projectie naar 2 componenten levert een spreidingsdiagram op waarin de scheiding tussen klassen vaak zichtbaar is, ook al zijn de labels nooit gebruikt tijdens PCA. Dit is een belangrijk verkennend hulpmiddel: als klassen in de 2D-PCA-ruimte goed gescheiden zijn, kan een eenvoudige lineaire classifier goed presteren in de ruimte met alle dimensies.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, y = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca2 = PCA(n_components=2)
X_2d = pca2.fit_transform(X_scaled)
plt.figure(figsize=(8, 6))
for digit in range(10):
mask = y == digit
plt.scatter(X_2d[mask, 0], X_2d[mask, 1], label=str(digit), s=10, alpha=0.6)
plt.legend(title='Digit', bbox_to_anchor=(1, 1))
plt.title('MNIST digits in 2D PCA space')
plt.tight_layout()
plt.show()Reconstructie: terug naar de oorspronkelijke ruimte
Reconstructie keert de projectie om: vermenigvuldig de gereduceerde scores met de getransponeerde matrix met ladingen en tel het gemiddelde weer op. Het resultaat is een benadering van de oorspronkelijke gegevens in de oorspronkelijke kenmerkenruimte. Volmaakte reconstructie is alleen mogelijk als je alle componenten hebt behouden; als je er minder behoudt, ontstaat reconstructiefout.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import numpy as np
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=20)
X_reduced = pca.fit_transform(X_scaled)
# Reconstruct back to 64 dimensions
X_reconstructed = pca.inverse_transform(X_reduced)
print('Reconstruction shape:', X_reconstructed.shape)
# Mean squared reconstruction error
mse = np.mean((X_scaled - X_reconstructed) ** 2)
print(f'MSE: {mse:.4f}')De kwaliteit van de reconstructie visualiseren
Voor beeldgegevens kun je oorspronkelijke en gereconstrueerde afbeeldingen naast elkaar weergeven. Naarmate je meer componenten behoudt, ziet de reconstructie er scherper uit. Met zeer weinig componenten worden cijfers vage vlekken. Deze visuele vergelijking is een krachtig communicatiemiddel om belanghebbenden de afweging tussen compressie en informatieverlies te laten zien.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
fig, axes = plt.subplots(3, 5, figsize=(12, 7))
component_counts = [1, 2, 5, 10, 30]
for col, nc in enumerate(component_counts):
pca = PCA(n_components=nc)
X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
# Un-standardise for display (approximate)
axes[0, col].imshow(X[0].reshape(8, 8), cmap='gray')
axes[0, col].set_title(f'Original' if col == 0 else '')
axes[1, col].imshow(X_r[0].reshape(8, 8), cmap='gray')
axes[1, col].set_title(f'n={nc}')
plt.tight_layout()
plt.show()Reconstructiefout tegenover het aantal componenten
Maak een grafiek van de reconstructie-MSE tegenover het aantal componenten om de curve van het informatieverlies te zien. Dit is de kwantitatieve versie van de visuele vergelijking. Een sterke daling van de MSE wanneer je de eerste paar componenten toevoegt, komt overeen met de screeplot en bevestigt dat de meeste informatie in een kleine deelruimte zit.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import numpy as np
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
components = [1, 2, 5, 10, 20, 30, 40, 50, 64]
mse_values = []
for nc in components:
pca = PCA(n_components=nc)
X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
mse_values.append(np.mean((X_scaled - X_r) ** 2))
plt.plot(components, mse_values, marker='o')
plt.xlabel('Number of components')
plt.ylabel('Reconstruction MSE')
plt.title('Information Loss vs Compression')
plt.show()Reconstructiefout interpreteren
Bij nul componenten is de reconstructiefout gelijk aan de totale variantie van de gegevens. Bij alle componenten is de fout nul. De verhouding 1 - explained_variance_ratio.sum() geeft het deel van de variantie aan dat is weggegooid. Voor de meeste praktische ML-pijplijnen betekent het behouden van 95–99% van de variantie (en het weggooien van 1–5%) dat er zeer weinig voorspellende informatie verloren gaat, terwijl het aantal kenmerken en de trainingstijd aanzienlijk afnemen.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
for nc in [5, 10, 20, 30, 40]:
pca = PCA(n_components=nc)
pca.fit(X_scaled)
retained = pca.explained_variance_ratio_.sum()
print(f'n_components={nc:2d} retained={retained:.3f} discarded={1-retained:.3f}')inverse_transform in de praktijk gebruiken
pca.inverse_transform(X_reduced) is een methode van het gefitte PCA-object. De methode retourneert de gegevens in de oorspronkelijke kenmerkenruimte, maar de informatie uit weggegooide componenten is op nul gezet. Dit is nuttig voor anomaliedetectie: reconstrueer de trainingsgegevens en markeer punten met een hoge reconstructiefout als uitschieters die het PCA-model niet goed kon weergeven.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import numpy as np
# Simulated normal vs anomalous points
X_normal = np.random.randn(100, 10)
X_anomaly = np.random.randn(5, 10) * 10 # far from origin
X_all = np.vstack([X_normal, X_anomaly])
X_scaled = StandardScaler().fit_transform(X_all)
pca = PCA(n_components=5)
X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
errors = np.mean((X_scaled - X_r) ** 2, axis=1)
print('Max error index:', np.argmax(errors), '(anomalies start at index 100)')Whitening: gedecorreleerde componenten met eenheidsvariantie
Als je PCA(whiten=True) instelt, worden de geprojecteerde scores geschaald zodat elke component eenheidsvariantie heeft. Hierdoor verdwijnen correlaties tussen componenten. Dit kan de prestaties verbeteren van algoritmen zoals SVM's of neurale netwerken die gevoelig zijn voor de schaal van kenmerken. Whitening is een gebruikelijke voorbewerking voordat je een model traint op met PCA gereduceerde kenmerken.
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
import numpy as np
X, _ = load_iris(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca_white = PCA(n_components=3, whiten=True)
X_w = pca_white.fit_transform(X_scaled)
print('Component variances (should be 1.0):', np.var(X_w, axis=0).round(4))Beperkingen van PCA bij niet-lineaire gegevens
PCA vindt alleen lineaire projecties. Als gegevens op een gekromd oppervlak liggen — zoals een Swiss roll — projecteert PCA ze op een plat vlak, waardoor de structuur van de variëteit verloren gaat. Overweeg in zulke gevallen Kernel PCA met een RBF-kernel of niet-lineaire alternatieven zoals t-SNE of UMAP voor verkenning. Voor voorbewerking van modellen is lineaire PCA meestal echter voldoende en veel sneller.
Projecteren en reconstrueren: volledige werkwijze
Een goede PCA-pijplijn volgt altijd hetzelfde patroon: standaardiseer, fit PCA op de trainingsgegevens, transformeer de trainings- en testgegevens afzonderlijk en reconstrueer desgewenst de gegevens om de kwaliteit te controleren.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits
import numpy as np
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test) # use train scaler
pca = PCA(n_components=0.95)
X_train_r = pca.fit_transform(X_train_s) # fit only on train
X_test_r = pca.transform(X_test_s) # transform test
print(f'Reduced: {X_train_r.shape[1]} components from 64 features')Snelle controle
Test je begrip van PCA-projectie en reconstructie uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat pca.transform gegevens naar de componentruimte projecteert met vorm (n_samples, n_components), dat pca.inverse_transform gegevens reconstrueert in de oorspronkelijke kenmerkenruimte, waarbij informatie uit weggegooide componenten verloren gaat, en dat reconstructiefout informatieverlies kwantificeert en anomalieën kan signaleren. Hierna verkennen we t-SNE — een niet-lineaire techniek voor 2D-visualisatie van gegevens met veel dimensies.
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 “Gegevens projecteren en reconstrueren vanuit componenten” gratis?
Ja — de volledige tekst van “Gegevens projecteren en reconstrueren vanuit componenten” 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 “Gegevens projecteren en reconstrueren vanuit componenten”?
Cursisten transformeren een dataset naar de ruimte van de hoofdcomponenten, visualiseren de 2D-projectie en reconstrueren de oorspronkelijke features om informatieverlies te kwantificeren. 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 2 van 4.
Hoe lang duurt de les “Gegevens projecteren en reconstrueren vanuit componenten”?
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