ColumnTransformer i en pipeline
Deltakere vil bygge inn ColumnTransformer for forhåndsbehandling av blandede numeriske og kategoriske data i en Pipeline, slik at heterogene rådata kan behandles direkte uten manuell oppdeling.
ColumnTransformer i en pipeline er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Problemet med blandede data
Tabulære datasett fra virkeligheten inneholder nesten alltid en blanding av numeriske kolonner (alder, lønn, temperatur) og kategoriske kolonner (by, produktkategori, kjønn). Hver type trenger ulik forhåndsbehandling: numeriske kolonner trenger skalering eller imputering, mens kategoriske kolonner trenger koding. ColumnTransformer lar Dem bruke ulike transformatorer på ulike delmengder av kolonner parallelt, slik at resultatet blir én ryddig egenskapsmatrise.
ColumnTransformer: den grunnleggende strukturen
ColumnTransformer tar imot en liste med tripler av typen (name, transformer, columns). columns kan være en liste med kolonnenavn, en liste med heltallsindekser, en boolsk maske eller en sklearn-selektor som make_column_selector. Etter transformasjonen settes resultatene fra alle transformatorene sammen horisontalt.
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
ct = ColumnTransformer([
('num', StandardScaler(), ['age', 'salary']),
('cat', OneHotEncoder(handle_unknown='ignore'), ['city', 'education'])
])
print('Transformers:', [name for name, _, _ in ct.transformers])Arbeide med et reelt datasett med blandede data
La oss opprette en liten blandet DataFrame og bruke en ColumnTransformer for å se formen og verdiene i resultatet. Dette viser hvordan numeriske og kategoriske resultater settes sammen til én NumPy-matrise som enhver sklearn-estimator kan bruke.
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
df = pd.DataFrame({
'age': [25, 40, 35, 55],
'salary': [50000, 80000, 65000, 90000],
'city': ['NYC', 'LA', 'NYC', 'SF'],
'education': ['BSc', 'MSc', 'BSc', 'PhD']
})
ct = ColumnTransformer([
('num', StandardScaler(), ['age', 'salary']),
('cat', OneHotEncoder(handle_unknown='ignore', sparse_output=False), ['city', 'education'])
])
X_transformed = ct.fit_transform(df)
print('Output shape:', X_transformed.shape)
print('Output:\n', X_transformed.round(2))Automatisk valg av kolonner
I stedet for å angi kolonnene manuelt kan De bruke make_column_selector til å velge kolonner automatisk etter datatype. dtype_include=np.number velger alle numeriske kolonner, mens dtype_exclude=np.number velger ikke-numeriske kolonner (kategoriske kolonner eller strenger). Dette er spesielt nyttig for brede datasett der det ville vært upraktisk å angi hvert kolonnenavn.
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer, make_column_selector
from sklearn.preprocessing import StandardScaler, OneHotEncoder
df = pd.DataFrame({
'age': [25, 40, 35], 'salary': [50000, 80000, 65000],
'city': ['NYC', 'LA', 'NYC']
})
ct = ColumnTransformer([
('num', StandardScaler(), make_column_selector(dtype_include=np.number)),
('cat', OneHotEncoder(), make_column_selector(dtype_exclude=np.number))
])
print(ct.fit_transform(df).shape)Bygge inn ColumnTransformer i en Pipeline
Den virkelige styrken ligger i å bygge inn ColumnTransformer som et forhåndsbehandlingstrinn i en Pipeline. Hele pipelinen – forhåndsbehandling og klassifikator – blir én enkelt estimator. Alle sklearn-verktøyene (cross_val_score, GridSearchCV, joblib-serialisering) fungerer på dette kombinerte objektet.
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer, make_column_selector
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
import numpy as np
preprocessor = ColumnTransformer([
('num', StandardScaler(), make_column_selector(dtype_include=np.number)),
('cat', OneHotEncoder(handle_unknown='ignore'),
make_column_selector(dtype_exclude=np.number))
])
pipe = Pipeline([
('preprocessor', preprocessor),
('clf', LogisticRegression(max_iter=300))
])
print('Pipeline steps:', [name for name, _ in pipe.steps])Eksempel fra start til slutt med Titanic-data
La oss bruke en ColumnTransformer-pipeline på et Titanic-lignende datasett. Numeriske kolonner (Age, Fare) får imputering med median og deretter standardskalering, mens kategoriske kolonner (Sex, Embarked) får imputering med den hyppigst forekommende verdien og deretter one-hot-koding. Til slutt tilpasses og evalueres pipelinen.
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
import numpy as np
# Simulated Titanic subset
df = pd.DataFrame({
'Age': [22, 38, None, 35, 28],
'Fare': [7.25, 71.83, 7.92, 53.1, 8.05],
'Sex': ['male', 'female', 'female', 'male', 'male'],
'Embarked': ['S', 'C', 'S', None, 'S'],
'Survived': [0, 1, 1, 1, 0]
})
X = df.drop('Survived', axis=1)
y = df['Survived']
num_pipe = Pipeline([('impute', SimpleImputer(strategy='median')),
('scale', StandardScaler())])
cat_pipe = Pipeline([('impute', SimpleImputer(strategy='most_frequent')),
('encode', OneHotEncoder(handle_unknown='ignore'))])
preprocessor = ColumnTransformer([
('num', num_pipe, ['Age', 'Fare']),
('cat', cat_pipe, ['Sex', 'Embarked'])
])
pipe = Pipeline([('prep', preprocessor), ('clf', LogisticRegression())])
pipe.fit(X, y)
print('Fitted successfully. Output features:', pipe['prep'].transform(X).shape[1])Parameteren remainder
Som standard fjerner ColumnTransformer kolonner som ikke er oppført eksplisitt. Angi remainder='passthrough' for å sende alle kolonner som ikke er oppført, videre uendret, eller remainder=StandardScaler() for å bruke en transformer på dem. Dette er nyttig når De har mange numeriske kolonner og bare vil behandle noen få kategoriske kolonner spesielt.
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
df = pd.DataFrame({
'age': [25, 40, 35],
'salary': [50000, 80000, 65000],
'city': ['NYC', 'LA', 'NYC']
})
# Only encode city; pass through numeric columns
ct = ColumnTransformer([
('cat', OneHotEncoder(), ['city'])
], remainder='passthrough')
print(ct.fit_transform(df))Hente feature-navn etter transformasjon
Etter tilpasning kan De kalle columntransformer.get_feature_names_out() for å hente navnene på alle utdat kolonner. OneHotEncoder bidrar med navn som cat__city_NYC, mens StandardScaler produserer navn som num__age. Disse navnene er avgjørende for å tolke feature-viktighet i trebaserte modeller som er trent på de transformerte dataene.
import pandas as pd
import numpy as np
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
df = pd.DataFrame({
'age': [25, 40, 35],
'salary': [50000, 80000, 65000],
'city': ['NYC', 'LA', 'NYC']
})
ct = ColumnTransformer([
('num', StandardScaler(), ['age', 'salary']),
('cat', OneHotEncoder(sparse_output=False), ['city'])
])
ct.fit(df)
print('Output feature names:')
print(ct.get_feature_names_out())Grid-søke en Pipeline med ColumnTransformer
For å justere parametere for trinn inne i en ColumnTransformer som er nøstet i en Pipeline, bruker De kjeden med doble understreker: preprocessor__num__scale__with_std eller preprocessor__cat__encode__drop. Navnekonvensjonen er pipeline_step__ct_step__substep__param. Det ser omstendelig ut, men er helt konsekvent.
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
# (assuming preprocessor and pipe are defined as above)
param_grid = {
'clf__C': [0.1, 1.0, 10.0],
# 'prep__num__scale__with_std': [True, False]
}
grid = GridSearchCV(pipe, param_grid, cv=3)
# grid.fit(X, y) # would run on real data
print('Grid ready with params:', list(param_grid.keys()))ColumnTransformer med imputeringstrinn
For hver kolonnetype kan De nøste inn en egen sub-Pipeline i ColumnTransformer for å håndtere flere sekvensielle operasjoner. Den numeriske sub-pipelinen imputere først og skalerer deretter, mens den kategoriske sub-pipelinen imputere først (for å håndtere manglende strenger) og koder deretter. Denne strukturen samler all forhåndsbehandlingslogikk i ett etterprøvbart objekt.
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
num_subpipe = Pipeline([
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())
])
cat_subpipe = Pipeline([
('imputer', SimpleImputer(strategy='most_frequent')),
('encoder', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
print('Numeric sub-pipeline steps:', [s[0] for s in num_subpipe.steps])
print('Categorical sub-pipeline steps:', [s[0] for s in cat_subpipe.steps])Validere hele pipelinen
Etter at De har bygget en kompleks pipeline, bør De kjøre en rask fornuftssjekk: tilpass den til et lite syntetisk datasett, bekreft at utdataformen samsvarer med forventningene, og kontroller at prediksjonene er rimelige. Hvis formfeil oppdages tidlig, sparer det tid ved senere feilsøking.
import pandas as pd
import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
X = pd.DataFrame({
'num1': np.random.randn(100),
'num2': np.random.randn(100),
'cat1': np.random.choice(['A', 'B', 'C'], 100)
})
y = np.random.randint(0, 2, 100)
ct = ColumnTransformer([
('num', Pipeline([('imp', SimpleImputer()), ('sc', StandardScaler())]), ['num1', 'num2']),
('cat', Pipeline([('imp', SimpleImputer(strategy='most_frequent')),
('enc', OneHotEncoder(sparse_output=False))]), ['cat1'])
])
pipe = Pipeline([('prep', ct), ('clf', LogisticRegression())])
pipe.fit(X, y)
print('Accuracy:', pipe.score(X, y).round(4))
print('Transformed shape:', ct.transform(X).shape)Rask sjekk
Test forståelsen Deres av ColumnTransformer fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at ColumnTransformer bruker ulike transformere på ulike delmengder av kolonner samtidig, at nøsting av ColumnTransformer i en Pipeline oppretter ett etterprøvbart objekt uten datalekkasjer for forhåndsbehandling av blandede datatyper, og at notasjon med doble understreker lar Dem justere alle nøstede parametere via GridSearchCV. Deretter skal vi kryssvalidere og grid-søke en hel pipeline for å finne optimale hyperparametere uten lekkasje.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «ColumnTransformer i en pipeline» gratis?
Ja – hele teksten i «ColumnTransformer i en pipeline» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «ColumnTransformer i en pipeline»?
Deltakere vil bygge inn ColumnTransformer for forhåndsbehandling av blandede numeriske og kategoriske data i en Pipeline, slik at heterogene rådata kan behandles direkte uten manuell oppdeling. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Machine Learning Academy?
Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «ColumnTransformer i en pipeline»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?
Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Bygge den første pipelinen: Skalerer pluss klassifikator
- ColumnTransformer i en pipeline
- Kryssvalidere og grid-søke i en full pipeline
- Lagre og laste inn en pipeline med joblib