ColumnTransformer i en pipeline
De lærende indlejrer ColumnTransformer til blandet numerisk/kategorisk forbehandling i en Pipeline, så heterogene rådata kan gå direkte ind uden manuel opdeling.
ColumnTransformer i en pipeline er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Problemet med blandede data
Tabulære datasæt fra den virkelige verden indeholder næsten altid en blanding af numeriske kolonner (alder, løn, temperatur) og kategoriske kolonner (by, produktkategori, køn). Hver type kræver forskellig forbehandling: Numeriske kolonner skal skaleres eller have manglende værdier erstattet, mens kategoriske kolonner skal kodes. ColumnTransformer lader dig anvende forskellige transformere på forskellige delmængder af kolonner parallelt, så resultatet bliver én samlet, ren egenskabsmatrix.
ColumnTransformer: Den grundlæggende struktur
ColumnTransformer tager en liste med tripler af typen (name, transformer, columns). columns kan være en liste med kolonnenavne, en liste med heltalsindekser, en boolsk maske eller en sklearn-selektor som make_column_selector. Efter transformationen sammenkædes resultaterne fra alle transformere vandret.
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])Arbejde med et ægte datasæt med blandede data
Lad os oprette en lille blandet DataFrame og anvende en ColumnTransformer for at se outputtets form og værdier. Det illustrerer, hvordan numeriske og kategoriske output sammenkædes til ét NumPy-array, som enhver sklearn-estimator kan bruge.
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 af kolonner
I stedet for at angive kolonnerne manuelt kan du bruge make_column_selector til automatisk at vælge kolonner efter datatype. dtype_include=np.number vælger alle numeriske kolonner, mens dtype_exclude=np.number vælger ikke-numeriske kolonner (kategoriske kolonner eller tekstkolonner). Det er især nyttigt i brede datasæt, hvor det ville være upraktisk at angive hvert enkelt 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)Indlejring af ColumnTransformer i en Pipeline
Den virkelige styrke opstår, når du indlejrer ColumnTransformer som et forbehandlingstrin i en Pipeline. Hele pipelinen — forbehandling og klassifikator — bliver én samlet estimator. Alle sklearn-værktøjer (cross_val_score, GridSearchCV og joblib-serialisering) fungerer på dette kombinerede objekt.
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 slut med Titanic-data
Lad os anvende en ColumnTransformer-pipeline på et Titanic-lignende datasæt. Numeriske kolonner (Age, Fare) får først manglende værdier erstattet med medianen og bliver derefter standardskaleret; kategoriske kolonner (Sex, Embarked) får først manglende værdier erstattet med den hyppigste værdi og bliver derefter one-hot-kodet. Derefter 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, der ikke er angivet eksplicit. Angiv remainder='passthrough' for at føre kolonner, der ikke er angivet, videre uændret, eller remainder=StandardScaler() for at anvende en transformer på dem. Det er nyttigt, når du har mange numeriske kolonner og kun vil håndtere nogle få kategoriske kolonner særskilt.
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))Hentning af feature-navne efter transformation
Efter tilpasningen kan du kalde columntransformer.get_feature_names_out() for at hente navnene på alle outputkolonner. OneHotEncoder bidrager med navne som cat__city_NYC, og StandardScaler genererer navne som num__age. Disse navne er afgørende for at fortolke feature-vigtigheder i træmodeller, der er trænet på de transformerede data.
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())Gitterafprøvning af en proceskæde med ColumnTransformer
Hvis du vil justere parametre for trin i en ColumnTransformer, der er indlejret i en Pipeline, skal du bruge kæden med dobbelte understregninger: preprocessor__num__scale__with_std eller preprocessor__cat__encode__drop. Navngivningskonventionen er pipeline_step__ct_step__substep__param. Det ser omstændeligt ud, 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 imputeringstrin
For hver kolonnetype kan du indlejre din egen under-proceskæde i ColumnTransformer for at håndtere flere sekventielle operationer. Den numeriske underproces udfører imputering og derefter skalering; den kategoriske underproces udfører imputering (for at håndtere manglende strenge) og derefter kodning. Denne struktur samler al forbehandlingslogik i ét objekt, der kan revideres.
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])Validering af hele proceskæden
Efter opbygning af en kompleks proceskæde bør du udføre et hurtigt rimelighedstjek: tilpas den på et lille syntetisk datasæt, bekræft, at outputformen svarer til forventningerne, og kontrollér, at forudsigelserne er rimelige. Hvis du opdager formfejl tidligt, sparer du tid på fejlfinding senere.
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)Hurtigt tjek
Test din forståelse af ColumnTransformer fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du, at ColumnTransformer anvender forskellige transformere på forskellige kolonneudsnit samtidigt, at indlejring af ColumnTransformer i en Pipeline skaber ét objekt til blandet forbehandling, som kan revideres og forhindrer datalækage, og at notation med dobbelte understregninger lader dig justere enhver indlejret parameter via GridSearchCV. Dernæst krydsvaliderer vi og udfører gitterafprøvning af en hel proceskæde for at finde optimale hyperparametre uden datalækage.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “ColumnTransformer i en pipeline” gratis?
Ja — hele teksten til “ColumnTransformer i en pipeline” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “ColumnTransformer i en pipeline”?
De lærende indlejrer ColumnTransformer til blandet numerisk/kategorisk forbehandling i en Pipeline, så heterogene rådata kan gå direkte ind uden manuel opdeling. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “ColumnTransformer i en pipeline”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Opbygning af den første pipeline: Skaler plus klassifikator
- ColumnTransformer i en pipeline
- Krydsvalidering og grid-søgning i en komplet pipeline
- Lagring og indlæsning af en pipeline med joblib