# Scikit-Learn Pipeline完全ガイド2026：特徴量エンジニアリングと面接対策

> Scikit-Learn Pipelineを使用した特徴量エンジニアリングの実践ガイド。ColumnTransformer、カスタムTransformer、GridSearchCVによるハイパーパラメータチューニング、本番デプロイメントのベストプラクティスを解説します。

- Published: 2026-09-02
- Updated: 2026-09-02
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

機械学習プロジェクトにおいて、特徴量エンジニアリングとモデル学習のワークフローを効率的に管理することは、再現性と本番環境へのデプロイメントの観点から極めて重要です。Scikit-Learn 1.5では、Pipelineクラスが強化され、より柔軟な前処理とモデルの統合が可能になりました。本記事では、sklearn Pipelineの基礎から高度な活用法、そして2026年の機械学習エンジニア面接で頻出する質問について解説します。

> **Pipelineとは何か**
>
> Scikit-LearnのPipelineは、データの前処理とモデル学習を単一のオブジェクトとして連結する仕組みです。これにより、データリーケージの防止、コードの再利用性向上、ハイパーパラメータの一括最適化が可能になります。Pipelineを使用しない場合、訓練データとテストデータに対して個別に前処理を適用する必要があり、エラーが発生しやすくなります。

## Pipelineの基本：前処理とモデルの統合

Pipelineの基本的な構造は、複数の「ステップ」を順番に実行するシーケンスです。各ステップは、変換器（Transformer）または推定器（Estimator）で構成されます。変換器は`fit`と`transform`メソッドを持ち、推定器は`fit`と`predict`メソッドを持ちます。

以下は、欠損値補完、標準化、ロジスティック回帰を組み合わせた基本的なPipelineの例です。

```python
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}")
```

このPipelineでは、`fit`メソッドを呼び出すと、各ステップが順番に訓練データに適合します。`predict`を呼び出すと、データは各変換器を通過し、最終的に分類器で予測が行われます。重要な点は、`fit`は訓練データのみで呼び出され、テストデータには`transform`のみが適用されることです。これにより、データリーケージが自動的に防止されます。

## ColumnTransformer：異なるデータ型の処理

実際のデータセットでは、数値特徴量とカテゴリ特徴量が混在することが一般的です。`ColumnTransformer`を使用すると、異なる列に対して異なる前処理を適用できます。

```python
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()}")
```

`ColumnTransformer`の`remainder`パラメータは重要です。`'drop'`は指定されていない列を削除し、`'passthrough'`は変換なしで保持します。本番環境では、明示的に処理する列を指定し、予期しない列が混入した場合にエラーを発生させることが推奨されます。

## カスタムTransformerの作成

Scikit-Learnの組み込み変換器では対応できない前処理ロジックが必要な場合、カスタムTransformerを作成します。`BaseEstimator`と`TransformerMixin`を継承することで、Pipeline互換のクラスを作成できます。

```python
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_}")
```

カスタムTransformerを作成する際の重要なポイントは、`fit`メソッドで学習したパラメータ（この例では`lower_bounds_`と`upper_bounds_`）をインスタンス変数として保存することです。これにより、訓練データで学習した統計量がテストデータにも適用されます。

## ハイパーパラメータチューニングとGridSearchCV

Pipelineの大きな利点の1つは、前処理のパラメータとモデルのハイパーパラメータを同時に最適化できることです。`GridSearchCV`や`RandomizedSearchCV`と組み合わせることで、最適な設定を効率的に探索できます。

```python
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}")
```

パラメータ名は`ステップ名__パラメータ名`の形式で指定します。この例では、`pca__n_components`はPCAステップの`n_components`パラメータを指します。ネストされたPipeline（ColumnTransformer内のPipelineなど）では、`preprocessor__num__imputer__strategy`のように複数のアンダースコアでパスを指定します。

## 特徴量選択とPipeline

特徴量選択は、モデルの性能向上と解釈性の改善に重要です。Scikit-Learnは複数の特徴量選択手法を提供しており、Pipelineに組み込むことで、クロスバリデーション中のデータリーケージを防止できます。

```python
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})")
```

特徴量選択をPipeline外で行うと、テストデータの情報が訓練プロセスにリークする可能性があります。Pipeline内に組み込むことで、各クロスバリデーションフォールドで独立して特徴量選択が行われ、汎化性能の正確な推定が可能になります。

## 面接でよく問われる質問と回答

2026年の機械学習エンジニア面接では、Pipelineに関する実践的な知識が評価されます。以下は頻出の質問と回答です。

**Q1: Pipelineを使用する主な利点は何ですか。使用しない場合と比較してください。**

Pipelineの主な利点は3つあります。第一に、**データリーケージの防止**です。前処理のパラメータ（例：標準化の平均と標準偏差）が訓練データのみから学習され、テストデータには適用のみが行われることが保証されます。Pipeline無しでは、開発者が手動でこれを管理する必要があり、誤ってテストデータで`fit_transform`を呼び出すミスが発生しやすくなります。第二に、**コードの簡潔性と再利用性**です。前処理とモデルが単一のオブジェクトとしてカプセル化されるため、本番環境へのデプロイメントが簡素化されます。第三に、**ハイパーパラメータの一括最適化**です。`GridSearchCV`と組み合わせることで、前処理パラメータとモデルパラメータを同時に最適化できます。

**Q2: `fit_transform`と`fit`+`transform`の違いは何ですか。いつ使い分けますか。**

`fit_transform`は`fit`と`transform`を連続して実行する便利なメソッドで、一部のTransformerでは計算効率のために最適化されています。例えば、PCAでは`fit_transform`は`fit`と`transform`を別々に呼び出すよりも高速です。使い分けとしては、訓練データには`fit_transform`を使用し、テストデータには`transform`のみを使用します。Pipelineを使用する場合、この使い分けは自動的に行われるため、手動で管理する必要はありません。面接では、「テストデータに`fit_transform`を使うとどうなるか」という質問がよくあります。答えは、テストデータの統計量が前処理に使用され、訓練データとテストデータで異なる変換が適用されることで、モデルの汎化性能が正しく評価できなくなります。

**Q3: ColumnTransformerで`remainder='passthrough'`と`remainder='drop'`の違いは何ですか。本番環境ではどちらを推奨しますか。**

`remainder='passthrough'`は、明示的に指定されていない列を変換なしでそのまま出力に含めます。`remainder='drop'`は、指定されていない列を削除します。本番環境では`remainder='drop'`を推奨します。理由は、データスキーマが変更された場合（例：新しい列が追加された場合）に、`passthrough`では予期しない列がモデルに入力され、予測結果に影響を与える可能性があるためです。`drop`を使用すると、想定外の列は自動的に無視され、モデルの動作が安定します。ただし、開発段階では`passthrough`を使用して、全ての特徴量の影響を評価することが有用な場合もあります。

**Q4: カスタムTransformerを作成する際に継承すべきクラスは何ですか。各クラスの役割を説明してください。**

カスタムTransformerは`BaseEstimator`と`TransformerMixin`の両方を継承します。`BaseEstimator`は`get_params`と`set_params`メソッドを提供し、これによりハイパーパラメータの取得と設定が可能になります。`GridSearchCV`などのメタ推定器はこれらのメソッドを使用してパラメータを操作します。`TransformerMixin`は`fit_transform`メソッドを提供し、これは`fit`と`transform`を連続して呼び出す便利なメソッドです。開発者は`fit`と`transform`メソッドのみを実装すれば、`fit_transform`は自動的に利用可能になります。また、`__init__`メソッドでは、全てのパラメータをインスタンス変数として同じ名前で保存する必要があります。これは`get_params`が正しく動作するために必要です。

**Q5: Pipelineでメモリキャッシュを使用する方法と利点を説明してください。**

Pipelineの`memory`パラメータにキャッシュディレクトリを指定することで、変換結果をキャッシュできます。

```python
from sklearn.pipeline import Pipeline
from tempfile import mkdtemp

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

これにより、同じデータと同じパラメータで`fit`が呼び出された場合、キャッシュされた結果が再利用されます。主な利点は、ハイパーパラメータチューニング中の計算時間の短縮です。例えば、モデルのパラメータのみを変更する場合、前処理ステップの結果はキャッシュから読み込まれます。注意点として、キャッシュはディスク容量を消費するため、大規模なデータセットでは適切なクリーンアップが必要です。

## 本番環境でのPipelineデプロイメント

本番環境では、学習済みのPipelineをシリアライズして保存し、推論時に読み込む必要があります。`joblib`は、NumPy配列を含むオブジェクトの効率的なシリアライズを提供します。

```python
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}")
```

本番環境では、モデルのバージョン管理も重要です。ファイル名にバージョン番号やタイムスタンプを含めることで、ロールバックが可能になります。また、[機械学習](/technologies/machine-learning)のベストプラクティスとして、モデルのメタデータ（学習日時、使用したデータセット、評価指標など）を別ファイルに保存することが推奨されます。

[Python](/technologies/python)でのデータ処理スキルは、効果的なPipelineの構築に不可欠です。[データサイエンス](/technologies/data-science)の実務では、Pipelineを使用して再現性のある実験を行い、本番環境への移行をスムーズに進めることが求められます。

## まとめ：Pipelineで機械学習ワークフローを最適化

Scikit-Learn Pipelineは、機械学習ワークフローを効率化し、再現性を確保するための重要なツールです。2026年の機械学習エンジニア面接では、Pipelineの実践的な知識が頻繁に評価されます。

本記事で学んだ主要なポイント:

- **基本構造**: Pipelineは変換器と推定器を順番に連結し、データリーケージを自動的に防止する
- **ColumnTransformer**: 異なるデータ型に対して異なる前処理を適用し、複雑なデータセットを効率的に処理する
- **カスタムTransformer**: `BaseEstimator`と`TransformerMixin`を継承して、ドメイン固有の前処理ロジックを実装する
- **ハイパーパラメータチューニング**: `GridSearchCV`と組み合わせて、前処理とモデルのパラメータを同時に最適化する
- **本番デプロイメント**: `joblib`でPipelineをシリアライズし、推論環境で再利用する

Pipelineを効果的に活用することで、機械学習プロジェクトの品質と保守性が大幅に向上します。面接対策としても、Pipelineの概念とベストプラクティスを深く理解することが、2026年の機械学習エンジニア職において重要な差別化要因となります。

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/ja/blog/data-science/scikit-learn-pipelines-feature-engineering-interview-2026