Scikit-Learn Pipeline 완벽 가이드 2026: 특성 엔지니어링과 면접 대비

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np

# Sample data
X = pd.DataFrame({
    'age': [25, 30, np.nan, 45, 50],
    'income': [50000, 60000, 75000, np.nan, 90000],
    'score': [0.8, 0.6, 0.9, 0.7, 0.85]
})
y = np.array([0, 0, 1, 1, 1])

# Create pipeline
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression(random_state=42))
])

# Fit and predict
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)
print(f"Predictions: {predictions}")

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import numpy as np

# Mixed data types
X = pd.DataFrame({
    'age': [25, 30, 35, 40, np.nan],
    'income': [50000, 60000, np.nan, 80000, 90000],
    'education': ['bachelor', 'master', 'phd', 'bachelor', 'master'],
    'city': ['tokyo', 'osaka', 'tokyo', np.nan, 'osaka']
})
y = np.array([0, 0, 1, 1, 1])

# Define transformers for each column type
numeric_features = ['age', 'income']
numeric_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

categorical_features = ['education', 'city']
categorical_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])

# Combine with ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ],
    remainder='drop'  # Drop columns not specified
)

# Full pipeline with model
full_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

full_pipeline.fit(X, y)
print(f"Feature names: {full_pipeline.named_steps['preprocessor'].get_feature_names_out()}")

from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np
import pandas as pd

class OutlierClipper(BaseEstimator, TransformerMixin):
    """Clip outliers using IQR method."""
    
    def __init__(self, factor=1.5):
        self.factor = factor
        self.lower_bounds_ = None
        self.upper_bounds_ = None
    
    def fit(self, X, y=None):
        X_array = np.asarray(X)
        q1 = np.percentile(X_array, 25, axis=0)
        q3 = np.percentile(X_array, 75, axis=0)
        iqr = q3 - q1
        self.lower_bounds_ = q1 - self.factor * iqr
        self.upper_bounds_ = q3 + self.factor * iqr
        return self
    
    def transform(self, X):
        X_array = np.asarray(X).copy()
        X_clipped = np.clip(X_array, self.lower_bounds_, self.upper_bounds_)
        return X_clipped

# Usage in pipeline
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge

X = np.array([[1, 100], [2, 200], [3, 150], [100, 180], [5, 170]])  # 100 is outlier
y = np.array([10, 20, 15, 18, 17])

pipeline = Pipeline([
    ('outlier_clipper', OutlierClipper(factor=1.5)),
    ('scaler', StandardScaler()),
    ('regressor', Ridge())
])

pipeline.fit(X, y)
print(f"Coefficients: {pipeline.named_steps['regressor'].coef_}")

from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.datasets import make_classification

# Generate sample data
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10,
                           n_redundant=5, random_state=42)

# Pipeline with PCA and SVM
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA()),
    ('svm', SVC())
])

# Parameter grid using step__parameter notation
param_grid = {
    'pca__n_components': [5, 10, 15],
    'svm__C': [0.1, 1, 10],
    'svm__kernel': ['rbf', 'linear'],
    'svm__gamma': ['scale', 'auto']
}

# Grid search with cross-validation
grid_search = GridSearchCV(
    pipeline,
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X, y)

print(f"Best parameters: {grid_search.best_params_}")
print(f"Best cross-validation score: {grid_search.best_score_:.4f}")

from sklearn.feature_selection import SelectKBest, f_classif, RFE
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification

# Generate data with informative and noise features
X, y = make_classification(n_samples=500, n_features=30, n_informative=10,
                           n_redundant=5, n_classes=2, random_state=42)

# Method 1: Filter-based selection (SelectKBest)
filter_pipeline = Pipeline([
    ('selector', SelectKBest(score_func=f_classif, k=10)),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# Method 2: Wrapper-based selection (RFE)
rfe_pipeline = Pipeline([
    ('selector', RFE(estimator=RandomForestClassifier(n_estimators=50, random_state=42),
                     n_features_to_select=10, step=5)),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# Compare methods
for name, pipeline in [('Filter', filter_pipeline), ('RFE', rfe_pipeline)]:
    scores = cross_val_score(pipeline, X, y, cv=5, scoring='accuracy')
    print(f"{name}: {scores.mean():.4f} (+/- {scores.std() * 2:.4f})")

from sklearn.pipeline import Pipeline
from tempfile import mkdtemp

cachedir = mkdtemp()
pipeline = Pipeline([
    ('expensive_transform', SomeExpensiveTransformer()),
    ('model', SomeModel())
], memory=cachedir)

import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingClassifier
import numpy as np

# Train pipeline
X_train = np.random.randn(1000, 10)
y_train = np.random.randint(0, 2, 1000)

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', GradientBoostingClassifier(n_estimators=100, random_state=42))
])
pipeline.fit(X_train, y_train)

# Save trained pipeline
joblib.dump(pipeline, 'model_pipeline.joblib')

# Load and predict (in production)
loaded_pipeline = joblib.load('model_pipeline.joblib')
X_new = np.random.randn(5, 10)
predictions = loaded_pipeline.predict(X_new)
print(f"Predictions: {predictions}")