ColumnTransformer dalam Saluran Paip
Pelajar akan menyarangkan ColumnTransformer untuk prapemprosesan angka/kategori bercampur dalam Pipeline supaya data mentah heterogen boleh dimasukkan terus tanpa pembahagian manual.
ColumnTransformer dalam Saluran Paip ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Masalah Data Bercampur
Set data jadual dunia sebenar hampir sentiasa mengandungi gabungan lajur berangka (umur, gaji, suhu) dan lajur kategori (bandar, kategori produk, jantina). Setiap jenis memerlukan prapemprosesan yang berbeza: lajur berangka memerlukan penskalaan atau imputasi, manakala lajur kategori memerlukan pengekodan. ColumnTransformer membolehkan anda menggunakan pengubah yang berbeza pada subset lajur yang berbeza secara selari, lalu menghasilkan satu matriks ciri yang bersih.
ColumnTransformer: Struktur Asas
ColumnTransformer menerima senarai tiga serangkai (name, transformer, columns). columns boleh berupa senarai nama lajur, senarai indeks integer, topeng boolean atau pemilih sklearn seperti make_column_selector. Selepas transformasi, hasil daripada semua pengubah digabungkan secara mendatar.
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])Bekerja dengan Set Data Bercampur Sebenar
Mari kita cipta DataFrame bercampur yang kecil dan gunakan ColumnTransformer untuk melihat bentuk serta nilai output. Ini menunjukkan cara output berangka dan kategori digabungkan menjadi satu tatasusunan NumPy yang boleh diterima oleh mana-mana penganggar sklearn.
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))Pemilihan Lajur Automatik
Daripada menyenaraikan lajur secara manual, gunakan make_column_selector untuk memilih lajur secara automatik mengikut dtype. dtype_include=np.number memilih semua lajur berangka; dtype_exclude=np.number memilih lajur bukan berangka (kategori/rentetan). Ini amat membantu untuk set data lebar yang menyenaraikan setiap nama lajur secara manual adalah tidak praktikal.
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)Menyarang ColumnTransformer dalam Pipeline
Kekuatan sebenar muncul apabila ColumnTransformer disarangkan sebagai langkah prapemprosesan di dalam Pipeline. Pipeline lengkap — prapemprosesan dan pengelas — menjadi satu penganggar. Semua alat sklearn (cross_val_score, GridSearchCV, penyirian joblib) berfungsi pada objek gabungan ini.
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])Contoh Menyeluruh dengan Data Titanic
Mari kita gunakan pipeline ColumnTransformer pada set data bergaya Titanic. Lajur berangka (Age, Fare) menerima imputasi median kemudian penskalaan piawai; lajur kategori (Sex, Embarked) menerima imputasi nilai paling kerap kemudian pengekodan one-hot. Pipeline itu kemudiannya dipasang dan diskorkan.
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])Parameter remainder
Secara lalai, ColumnTransformer menggugurkan lajur yang tidak disenaraikan secara jelas. Tetapkan remainder='passthrough' untuk meneruskan mana-mana lajur yang tidak disenaraikan tanpa perubahan, atau remainder=StandardScaler() untuk menggunakan pengubah padanya. Ini berguna apabila anda mempunyai banyak lajur angka dan hanya mahu mengendalikan beberapa lajur kategori secara khusus.
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))Mendapatkan Nama Ciri Selepas Transformasi
Selepas pemasangan, panggil columntransformer.get_feature_names_out() untuk mendapatkan nama bagi semua lajur output. OneHotEncoder menyumbangkan nama seperti cat__city_NYC; StandardScaler menghasilkan nama seperti num__age. Nama ini penting untuk mentafsir kepentingan ciri dalam model pepohon yang dilatih menggunakan data yang telah ditransformasikan.
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())Carian Grid pada Saluran Paip dengan ColumnTransformer
Untuk melaraskan parameter langkah-langkah di dalam ColumnTransformer yang bersarang dalam saluran paip, gunakan rantaian garis bawah berganda: preprocessor__num__scale__with_std atau preprocessor__cat__encode__drop. Konvensyen penamaan ialah pipeline_step__ct_step__substep__param. Namanya kelihatan panjang, tetapi sepenuhnya konsisten.
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 dengan Langkah Kecil Imputasi
Bagi setiap jenis lajur, anda boleh menyarangkan Saluran Paip kecilnya sendiri di dalam ColumnTransformer untuk mengendalikan beberapa operasi berjujukan. Saluran kecil angka melakukan imputasi kemudian penskalaan; saluran kecil kategori melakukan imputasi (untuk mengendalikan rentetan yang hilang) kemudian pengekodan. Struktur ini memastikan semua logik prapemprosesan berada dalam satu objek yang boleh diaudit.
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])Mengesahkan Saluran Paip Lengkap
Selepas membina saluran paip yang kompleks, jalankan pemeriksaan kewajaran ringkas: lakukan pemasangan pada set data sintetik yang kecil, pastikan bentuk output sepadan dengan jangkaan, dan sahkan bahawa ramalan adalah munasabah. Mengesan ralat bentuk lebih awal menjimatkan masa penyahpepijatan kemudian.
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)Pemeriksaan Ringkas
Uji pemahaman anda tentang ColumnTransformer daripada pelajaran ini.
Imbas Kembali Pelajaran
Dalam pelajaran ini, anda telah mempelajari bahawa: ColumnTransformer menggunakan pengubah yang berbeza pada subset lajur yang berbeza secara serentak, menyarangkan ColumnTransformer di dalam saluran paip menghasilkan satu objek yang boleh diaudit dan bebas kebocoran untuk prapemprosesan jenis campuran, dan notasi garis bawah berganda membolehkan anda melaraskan sebarang parameter bersarang melalui GridSearchCV. Seterusnya, kita akan melakukan pengesahan silang dan carian grid pada saluran paip lengkap untuk mencari hiperparameter optimum tanpa kebocoran.
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “ColumnTransformer dalam Saluran Paip” percuma?
Ya — teks penuh “ColumnTransformer dalam Saluran Paip” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “ColumnTransformer dalam Saluran Paip”?
Pelajar akan menyarangkan ColumnTransformer untuk prapemprosesan angka/kategori bercampur dalam Pipeline supaya data mentah heterogen boleh dimasukkan terus tanpa pembahagian manual. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.
Berapa lamakah pelajaran “ColumnTransformer dalam Saluran Paip” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Membina Saluran Paip Pertama Anda: Penskala serta Pengelas
- ColumnTransformer dalam Saluran Paip
- Mengesahkan Silang dan Mencari Grid bagi Saluran Paip Lengkap
- Menyimpan dan Memuatkan Saluran Paip dengan joblib