Uw eerste pipeline bouwen: scaler plus classifier
Cursisten koppelen StandardScaler en LogisticRegression in een Pipeline, roepen fit en predict aan en bevestigen dat de scaler alleen op de trainingsgegevens is gefit.
Uw eerste pipeline bouwen: scaler plus classifier 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.
Wat is een scikit-learn Pipeline?
Een Pipeline koppelt meerdere verwerkingsstappen aan elkaar in één estimator-object. Elke stap behalve de laatste moet fit en transform implementeren; de laatste stap heeft alleen fit en predict nodig. Als je pipeline.fit(X, y) aanroept, worden alle stappen in volgorde uitgevoerd, en pipeline.predict(X) voert de gegevens door alle transformaties voordat de classificatie plaatsvindt. Dit voorkomt fouten bij het bijhouden van stappen en voorkomt gegevenslekken.
Waarom pipelines gegevenslekken voorkomen
Als je een StandardScaler op de volledige gegevensset aanpast en de gegevens daarna in training en test splitst, heeft de scaler statistieken van de testset gezien — dit is een gegevenslek. Een Pipeline lost dit automatisch op: wanneer je een Pipeline doorgeeft aan cross_val_score of GridSearchCV, wordt de volledige pipeline (inclusief de scaler) voor elke trainingsvouw opnieuw vanaf nul aangepast, zodat de testvouw nooit invloed heeft op de parameters van de scaler.
Je eerste Pipeline samenstellen
Maak een Pipeline door een lijst met tuples van (name, estimator) door te geven. De namen zijn willekeurige tekenreeksen die je zelf kiest — je gebruikt ze later om naar stappen te verwijzen, bijvoorbeeld voor hyperparameters in een rasterzoekopdracht. De meest gebruikelijke eerste pipeline bestaat uit een scaler gevolgd door een classificator.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(C=1.0, max_iter=200))
])
print('Steps:', [name for name, _ in pipe.steps])
print('Named steps:', list(pipe.named_steps.keys()))Aanpassen en voorspellen
Gebruik de Pipeline na het samenstellen precies zoals elke sklearn-estimator: fit op trainingsgegevens, predict op testgegevens en score voor de nauwkeurigheid. Intern roept fit fit_transform aan voor alle tussenliggende stappen en fit voor de laatste estimator.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(max_iter=300))
])
pipe.fit(X_train, y_train)
print('Test accuracy:', pipe.score(X_test, y_test).round(4))
y_pred = pipe.predict(X_test)
print('Predictions[:5]:', y_pred[:5])Controleren of de scaler alleen op trainingsgegevens is aangepast
Nadat je de Pipeline op trainingsgegevens hebt aangepast, kun je de aangepaste parameters van elke stap bekijken. De scaler in de pipeline heeft de attributen mean_ en scale_, berekend op basis van alleen de trainingsset — niet van de volledige gegevensset. Hiermee bevestig je dat de pipeline correct werkt.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=300))])
pipe.fit(X_train, y_train)
# Scaler mean from pipeline vs computed from X_train
print('Pipeline scaler mean[0]:', pipe.named_steps['sc'].mean_[0].round(4))
print('Direct train mean[0]: ', X_train[:, 0].mean().round(4))Tussenliggende uitvoer ophalen
Gebruik pipeline[:-1].transform(X) om de getransformeerde uitvoer van een specifieke stap op te halen, of benader afzonderlijke stappen via pipeline.named_steps['step_name']. Je kunt ook pipeline[:'step_name'] gebruiken met de slice-notatie van Python om een subpipeline tot en met die stap te krijgen. Dit is handig voor foutopsporing of om te bekijken hoe de gegevens eruitzien na het schalen.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
pipe.fit(X, y)
# Get scaled output (all steps except the last)
X_scaled = pipe[:-1].transform(X)
print('After scaling — mean per feature:', X_scaled.mean(axis=0).round(4))
print('After scaling — std per feature:', X_scaled.std(axis=0).round(4))make_pipeline: een snelkoppeling
make_pipeline maakt een Pipeline zonder dat je stapnamen handmatig hoeft op te geven — de functie genereert namen op basis van de klassennamen in kleine letters. Dit is handig voor snelle experimenten, maar minder leesbaar in productiecode, waar expliciete namen helpen om stappen te herkennen in parameterreeksen voor rasterzoekopdrachten.
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_iris(return_X_y=True)
# Auto-names: 'minmaxscaler' and 'kneighborsclassifier'
pipe = make_pipeline(MinMaxScaler(), KNeighborsClassifier(n_neighbors=5))
print('Step names:', list(pipe.named_steps.keys()))
print('CV accuracy:', cross_val_score(pipe, X, y, cv=5).mean().round(4))Pipeline met waarschijnlijkheidsvoorspellingen
Als de laatste estimator predict_proba ondersteunt, stelt de Pipeline die methode ook beschikbaar. Zo kun je een Pipeline gebruiken met elke functie die waarschijnlijkheidsuitvoer verwacht — zoals ROC-AUC-scores, kalibratiecurven of het afstellen van drempelwaarden — zonder de voorbewerking handmatig toe te passen voordat je het model aanroept.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=300))])
pipe.fit(X_train, y_train)
proba = pipe.predict_proba(X_test)[:, 1]
print('ROC-AUC:', roc_auc_score(y_test, proba).round(4))Parameters instellen na het samenstellen
Je kunt de parameter van elke stap na het opbouwen van de Pipeline bijwerken met set_params(step__param=value) en het scheidingsteken met dubbele underscores. Dit is dezelfde syntaxis als in GridSearchCV. Het is handig wanneer je met verschillende instellingen wilt experimenteren zonder de volledige pipeline opnieuw vanaf nul op te bouwen.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
# Change C and max_iter after construction
pipe.set_params(lr__C=10.0, lr__max_iter=500)
print('C after set_params:', pipe.named_steps['lr'].C)Pipelines serialiseren en delen
Een aangepaste Pipeline is één Python-object dat je kunt serialiseren met pickle of joblib. Als je de pipeline als één bestand deelt, weet je zeker dat tijdens het voorspellen precies dezelfde voorbewerkingsstappen — met exact dezelfde parameters van de scaler — worden toegepast. Zo voorkom je consistentiefouten tussen omgevingen voor training en beschikbaarstelling.
import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
pipe.fit(X, y)
# Save and reload
joblib.dump(pipe, '/tmp/iris_pipeline.pkl')
loaded_pipe = joblib.load('/tmp/iris_pipeline.pkl')
print('Predictions match:', (pipe.predict(X) == loaded_pipe.predict(X)).all())Beste werkwijze voor kruisvalidatie met een Pipeline
Wikkel je Pipeline altijd in cross_val_score in plaats van handmatig over vouwen te lussen. Zo wordt de scaler bij elke trainingsvouw opnieuw aangepast en raakt hij de validatievouw nooit aan, waardoor je een eerlijke schatting van de generalisatieprestaties krijgt.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_digits(return_X_y=True)
pipe = Pipeline([
('sc', StandardScaler()),
('svm', SVC(kernel='rbf', C=5.0, gamma='scale'))
])
scores = cross_val_score(pipe, X, y, cv=5, n_jobs=-1)
print(f'CV accuracy: {np.mean(scores):.4f} +/- {np.std(scores):.4f}')Korte controle
Test je begrip van scikit-learn Pipelines uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat een Pipeline stappen aan elkaar koppelt tot één estimator en gegevenslekken voorkomt door elke stap alleen aan te passen op de trainingsgegevens die deze te zien krijgt, dat make_pipeline automatisch benoemde snelkoppelingen biedt terwijl expliciete namen rasterzoekopdrachten leesbaarder maken, en dat een aangepaste Pipeline kan worden geserialiseerd en gedeeld als één artefact voor consistente voorbewerking tijdens beschikbaarstelling. Hierna voegen we ColumnTransformer toe aan een Pipeline om gemengde numerieke en categorische gegevens te verwerken.
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 “Uw eerste pipeline bouwen: scaler plus classifier” gratis?
Ja — de volledige tekst van “Uw eerste pipeline bouwen: scaler plus classifier” 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 “Uw eerste pipeline bouwen: scaler plus classifier”?
Cursisten koppelen StandardScaler en LogisticRegression in een Pipeline, roepen fit en predict aan en bevestigen dat de scaler alleen op de trainingsgegevens is gefit. 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 “Uw eerste pipeline bouwen: scaler plus classifier”?
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
- Uw eerste pipeline bouwen: scaler plus classifier
- ColumnTransformer in een pipeline
- Een volledige pipeline valideren en doorzoeken met grid search
- Een pipeline opslaan en laden met joblib