メインコンテンツへスキップ
見出し画像

scikit-learn機械学習㉘パイプラインと便利ツール

    前回は、ニューラルネットワークを解説しました。これまで分類タスクを中心として、よく知られた教師あり学習のモデルを紹介してきました。

    これらのモデルを使って実験をすると、scikit-learnのモデルはどれも似たようなインターフェースを持っているのがわかります。また、どのモデルを使っても同じような訓練から評価への流れがあります。

    # 訓練データとテストデータの準備
    X_train, X_test, y_train, y_test  = ....
    
    # モデルの準備
    model = ModelXXXX(....)
    
    # モデルの訓練
    model.fit(X_train, y_train)
    
    # テストデータでの予測
    y_pred = model.predict(X_test)
    
    # モデルの評価 (他にも、model.score など)
    results = classification_report(y_test, y_pred)

    もちろん、これは scikit-learn の意図的なデザインによるものです。特にパイプライン(Pipeline)を利用することで、前処理やモデル選択などの一連の処理をパターン化して扱うことができ非常に便利になっています。

    また、scikit-learn には、前処理やモデル選択に関する便利ツールがあります。

    そんなわけで今回は、scikit-learn のパイプラインと便利ルールを紹介します。

    パイプラインで前処理を簡単に

    前処理をするところは、パイプラインを使うと便利です。

    データの読み込みと分割

    ここでは、乳がんのデータセットを扱います。

    from sklearn.datasets import load_breast_cancer
    from sklearn.model_selection import train_test_split
    
    # データの読み込み
    cancer = load_breast_cancer()
    X, y = cancer.data, cancer.target
    
    # データの分割
    X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                           test_size=0.2, random_state=42)

    ここでは、典型的なデータの読み込みをして、train_test_split で訓練データとテストデータに分割しています。

    なお、データ分割そのものには、パイプラインは使いません。

    パイプラインは、前処理、学習、評価、などの一連の流れで使います。

    よって、以下ではパイプライン無し有りを比較します。

    パイプライン無しの前処理

    以下は、モデルの訓練と評価を行うコードです。

    from sklearn.preprocessing import StandardScaler
    from sklearn.linear_model import LogisticRegression
    
    # スケーラーの初期化と訓練データへのfit_transform
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)  # 訓練データで fit + transform
    
    # テストデータへのtransform(訓練データで学習した平均と標準偏差を使用)
    X_test_scaled = scaler.transform(X_test)
    
    # モデルの訓練と評価
    model = LogisticRegression()
    model.fit(X_train_scaled, y_train)
    score = model.score(X_test_scaled, y_test)
    
    print(f"テストデータのスコア: {score}")
    

    次のような処理を行なっています。

    1. データを訓練用とテスト用に分割する。

    2. StandardScalerを訓練データにフィットし、訓練データを標準化する。

    3. 同じ平均と標準偏差を使って、テストデータも標準化する。

    4. モデルの訓練(フィット)を行う

    5. モデルの評価(スコアの計算)を行う

    注目して欲しいのは、StandardScalerに対して呼ばれるメソッドは訓練と評価で異なることです。

    • fit_transform(): 訓練データに対して一度にfit()とtransform()を行います。

    • transform(): テストデータはfit()せず、訓練データで学習した平均と標準偏差を使って変換します。

    次に、パイプラインを使って同じことを行います。

    パイプライン有りに前処理

    Pipelineを使用して、前処理とモデルの訓練を一つのワークフローにまとめます。

    from sklearn.pipeline import Pipeline
    from sklearn.preprocessing import StandardScaler
    from sklearn.linear_model import LogisticRegression
    
    # パイプラインの作成(標準化とモデルをまとめる)
    pipeline = Pipeline([
        ('scaler', StandardScaler()),  # 訓練データだけは fit + transform
        ('model', LogisticRegression())  # モデルの訓練
    ])
    
    # 訓練データでfit(StandardScalerはfit_transformを実行する)
    pipeline.fit(X_train, y_train)
    
    # テストデータでの評価(transformのみ適用)
    score = pipeline.score(X_test, y_test)
    
    print(f"テストデータのスコア: {score}")

    まず、パイプラインは前処理とモデル(ロジスティック回帰)の構築を一つにまとめています。

    # パイプラインの作成(標準化とモデルをまとめる)
    pipeline = Pipeline([
        ('scaler', StandardScaler()),  # 訓練データだけは fit + transform
        ('model', LogisticRegression())  # モデルの訓練
    ])

    こうすることで、パイプライン自体がモデルであるかのように振る舞います。なお、'scalar' や 'model' と言った名前は自由に決められます。

    よって、訓練データで学習(フィット)するには、pipeline.fit(X_train, y_train) を呼びます。これは、モデルの fit を呼び出すのと全く同じインターフェースになっています。

    # 訓練データでfit(StandardScalerはfit_transformを実行する)
    pipeline.fit(X_train, y_train)

    なお、fit が呼ばれた時に、パイプラインの内部では、StandardScalerに対して fit_transform() を呼んでいます。

    次に、テストデータで評価するために、パイプラインに対して score を呼びます。

    # テストデータでの評価(transformのみ適用)
    score = pipeline.score(X_test, y_test)

    この際には、StandardScalerには transform() だけが呼ばれます。よって、訓練データのスケール情報を使って、テストデータを変換することになります。パイプラインは、score が評価のためのメソッドであることから判断しています。

    よって、パイプラインを使うことで、コードがよりシンプルになるだけでなく、テストデータに対する標準化を忘れずに行うことができます。

    ハイパーパラメータのチューニング

    パイプラインを使用しても、そのままハイパーパラメータのチューニングを行うことができます。パイプラインに前処理を含めたまま、通常と同じようにGridSearchCVやRandomizedSearchCVなどを使うだけです。

    まずは、SVMの分類モデルを含めたパイプラインを準備します。

    from sklearn.pipeline import Pipeline
    from sklearn.preprocessing import StandardScaler
    from sklearn.svm import SVC
    
    pipeline = Pipeline([
        ('scaler', StandardScaler()),  # データの標準化
        ('svm', SVC())  # SVMモデル
    ])

    さらに、GridSearchCV や RandomizedSearchCVと組み合わせて、モデルのハイパーパラメータをチューニングできます。

    from sklearn.model_selection import GridSearchCV
    
    param_grid = {
        'svm__C': [0.1, 1, 10],
        'svm__gamma': [0.001, 0.01, 0.1]
    }
    
    grid = GridSearchCV(pipeline, param_grid, cv=5)
    grid.fit(X_train, y_train)

    見ての通り、パイプラインをモデルとして扱うので、通常の使い方と変わりません。ベストのモデルを取り出してテストデータで評価します。

    best_model = grid.best_estimator_
    
    score = best_model.score(X_test, y_test)
    
    print(f"テストデータのスコア: {score}")

    この際、前処理については、パイプラインを構築する段階で指定しただけです。

    前処理のための便利ツール

    データの下準備

    乳がんデータセットを、as_frame=True でPandasのデータフレームとして読み込みます。

    from sklearn.datasets import load_breast_cancer
    
    # データの読み込み
    cancer = load_breast_cancer(as_frame=True)
    X, y = cancer.data, cancer.target

    よって、次のように最初の数行を表形式で見ることがでいます。

    X.head()
    画像

    これにカテゴリー変数をランダムに追加します。

    import numpy as np
    
    # 数値特徴量に基づいて人工的なカテゴリ変数を追加
    X['gender'] = np.where(np.random.rand(X.shape[0]) > 0.5, 'male', 'female')
    X['city'] = np.random.choice(
                    ['New York', 'San Francisco', 'Tokyo'], size=X.shape[0])
    
    X.head()

    以下のようにランダムなカテゴリ値が最後の方に追加されました。

    画像

    これを訓練データとテストデータに分割します。

    # データの分割
    X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                           test_size=0.2, random_state=42)

    複数の前処理を組み合わせる

    次に、もともとある数値データには、StandardScaler で標準化をし、カテゴリ変数には、ワンホットエンコーディングを施すという前処理を ColumnTransformer を使って設定します。

    from sklearn.compose import ColumnTransformer
    from sklearn.preprocessing import StandardScaler, OneHotEncoder
    
    # 数値とカテゴリ変数を別々に処理するColumnTransformerの設定
    preprocessor = ColumnTransformer([
        ('num', StandardScaler(), cancer.feature_names),  # 数値データの標準化
        ('cat', OneHotEncoder(), ['gender', 'city'])  # カテゴリ変数のワンホットエンコーディング
    ])

    ここで、cancer.feature_names は、もともと乳がんデータセットにある変数の名前のリストで、それらに対して StandardScaler を適用する設定です。また、新しく追加した gender と city に対しては、OnehotEncoder を適用する設定をしました。

    これを訓練データへ適用します。

    # 訓練データへの適用(fit_transform)
    X_train_transformed = preprocessor.fit_transform(X_train)

    ワンホットエンコーディングでは、'gender' を [0, 1] あるいは [1, 0]として表現します。また、'city' は3つあるので、[0, 0, 1]、[0, 1, 0]、[1, 0, 0]で表現します。

    これを確認するために、最後の5つの変数(列)をプリントしてみます。

    X_train_transformed[:5, len(cancer.feature_names):]
    画像

    これを、テストデータに適用するには transform を呼びます。

    # テストデータへの適用(transformのみ)
    X_test_transformed = preprocessor.transform(X_test)

    ただし、追加した変数には特に意味はないので何の役にも立ちませんが。

    パイプラインで使う

    もちろん、この前処理の組み合わせをパイプラインに含めることも可能です。

    # パイプラインの構築(前処理 + モデル)
    pipeline = Pipeline([
        ('preprocessor', preprocessor),  # 前処理
        ('classifier', LogisticRegression())  # モデル
    ])

    これはモデルとして使うことができるので fit_transform や transform を個別に呼び出す必要がなくなります。

    さらに、グリッド・サーチなどのハイパーパラメータのチューニングと組み合わせることもできます。

    パイプラインで交差検証を行う

    交差検証をする

    cross_val_scoreを使えば、データを複数の分割に分け、訓練と評価を繰り返すことで過学習を防ぎつつ、モデルの汎化性能を評価できます。

    from sklearn.datasets import load_breast_cancer
    from sklearn.model_selection import cross_val_score
    
    # データの読み込み
    data = load_breast_cancer()
    X, y = data.data, data.target
    
    # ロジスティック回帰
    model = LogisticRegression()
    
    # 交差検証
    scores = cross_val_score(model, X, y, cv=5)  # 5分割クロスバリデーション
    
    print("平均スコア:", scores.mean())
    • cv=5と指定したので、データを5つの等しいグループに分割します。

    • 1つのグループをテストデータとし、残りの4つを訓練データとして使います。

    • この操作を5回繰り返すので、各グループが1回ずつテストデータになります。

    • 各回のテスト結果を集めて、平均スコアを計算します。

    つまり、訓練用とテスト用の2つに分割するのではなく、5つに分割した一つをテスト用とすることを、順番に繰り返します。よって、各グループが1回はテストデータとして使われ、他の回では訓練データになります。

    画像

    なお、交差検証では、各反復ごとにモデルが初期化されて再訓練されます。これにより、各分割でデータの偏りの影響を避け、モデルの汎化性能を正確に評価できます。

    ただし、前処理をどうするのかという問題が残ります。

    もし、データ全体に対して、標準化(StandardScaler)などの前処理を行い、その後にクロスバリデーションを実施すると、テストデータの情報が訓練データに漏れてしまいます。すると、過学習や不正確な評価につながります。

    そこで、パイプラインが役に立ちます。

    パイプラインを適用する

    Pipelineを使うことで、交差検証でも、前処理はそれぞれの訓練データで適用されるので、テストデータの情報が漏れるのを防ぐことができます。

    from sklearn.model_selection import cross_val_score
    from sklearn.pipeline import Pipeline
    from sklearn.preprocessing import StandardScaler
    
    # パイプラインの作成(前処理 + モデル)
    pipeline = Pipeline([
        ('scaler', StandardScaler()),  # データの標準化
        ('classifier', LogisticRegression())  # ロジスティック回帰
    ])
    
    # クロスバリデーションの実行
    scores = cross_val_score(pipeline, X, y, cv=5)
    
    # 結果の表示
    print("平均スコア:", scores.mean())

    つまり、各分割ごとに前処理が実行され、テストデータの情報は訓練データに影響しないようになります。パイプラインは、交差検証の各サイクルごとに独立してfit_transform()を実行し、スケールやパラメータを学習するため、情報漏洩が発生しないので安全です。

    多数決によるアンサンブル学習器

    VotingClassifier

    複数のモデルを使って、多数決のアンサンブル学習器を作ることができます。

    何度も繰り返していますが、まずは準備としてデータを読み込み分割します。

    from sklearn.datasets import load_breast_cancer
    from sklearn.model_selection import train_test_split
    
    cancer = load_breast_cancer()
    X, y = cancer.data, cancer.target
    
    # データの分割
    X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                           test_size=0.2, random_state=42)

    使うモデルは VotingClassifier で、複数のモデルによる予測で多数決を行います。

    from sklearn.linear_model import LogisticRegression
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.svm import SVC
    from sklearn.ensemble import VotingClassifier
    
    voting_clf = VotingClassifier(
        estimators=[
            ('lr', LogisticRegression()),
            ('svc', SVC()),
            ('rf', RandomForestClassifier())
        ], voting='hard')
    
    voting_clf.fit(X_train, y_train)
    
    print("アンサンブルモデルのスコア:", voting_clf.score(X_test, y_test))

    これを実行すると、アンサンブルモデルのスコアは、約0.96でした。

    ただし、上述のコードを実行すると、ロジスティック回帰が収束しないという警告が出てきます。

    /Users/naoki/workspace/kikaben/linear_regression/venv/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):
    STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.
    
    Increase the number of iterations (max_iter) or scale the data as shown in:
        https://scikit-learn.org/stable/modules/preprocessing.html
    Please also refer to the documentation for alternative solver options:
        https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
      n_iter_i = _check_optimize_result(

    これは、LogisticRegression(max_iter=10000)のように最大ループ数を増やすとなくなります。

    しかし、もっと良い方法は入力データに標準化などの前処理を行うことです。

    パイプラインで使う

    そこで、これに前処理を足してみます。

    # ロジスティック回帰、ランダムフォレスト、SVMのアンサンブルモデル
    pipeline = Pipeline([
        ('scaler', StandardScaler()),  # データの標準化
        ('voting_clf', VotingClassifier(
            estimators=[
                ('lr', LogisticRegression()),
                ('svc', SVC()),
                ('rf', RandomForestClassifier())
            ]))
    ])
    
    # アンサンブルモデルの訓練
    pipeline.fit(X_train, y_train)
    
    print("アンサンブルモデルのスコア:", pipeline.score(X_test, y_test))

    これを実行すると、アンサンブルモデルのスコアが0.98でした。スコアが良くなった上に、警告も出なくなりました。

    パイプラインのアンサンブル

    ランダムフォレストなどの決定木ベースのモデルでは、特徴量のスケールに影響されないため、標準化は不要です。一方で、SVMやロジスティック回帰などのモデルは、データのスケールが重要になるため、適切な標準化が必要です。

    つまり、モデルによって前処理を変えたいケースがあります。

    その場合は、以下のようにパイプラインをそれぞれのモデルに対して設定します。

    # アンサンブルモデルの定義
    voting_clf = VotingClassifier(
        estimators=[
            ('lr', Pipeline([('preprocessor', StandardScaler()), 
                             ('classifier', LogisticRegression())])),
            ('svc', Pipeline([('preprocessor', MinMaxScaler()), 
                              ('classifier', SVC())])),
            ('rf', RandomForestClassifier())  # 標準化なしで使用
        ])
    
    # モデルの学習と評価
    voting_clf.fit(X_train, y_train)
    
    print("アンサンブルモデルのスコア:", voting_clf.score(X_test, y_test))

    各モデルに適切な前処理を適用するため、パイプラインをモデルごとに構築し、それらを VotingClassifier に渡します。これにより、異なる前処理をモデルごとに適用しています。

    なお、ここではロジスティック回帰では標準化(StandardScaler)、SVCでは最小最大スケーリング(MinMaxScaler)を行なっています。また、ランダムフォレストでは前処理を行いません。

    繰り返しますが、パイプラインはモデルと同じように扱われるので、全体をパイプラインに入れるとか、個別のモデルに対してパイプラインを設定して組み合わせるなどいろんな使い方が可能になっています。

    複数モデルの出力から学習する

    StackingClassifier

    以下は、scikit-learnのStackingClassifierを使った例です。

    from sklearn.datasets import load_breast_cancer
    from sklearn.ensemble import StackingClassifier, RandomForestClassifier
    from sklearn.linear_model import LogisticRegression
    from sklearn.svm import SVC
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.pipeline import Pipeline
    
    # データの読み込みと分割
    data = load_breast_cancer()
    X, y = data.data, data.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                           test_size=0.2, random_state=42)
    
    # ベースモデルの定義(標準化が必要なモデルにはパイプラインを使用)
    estimators = [
        ('rf', RandomForestClassifier()),  # ランダムフォレスト
        ('svc', Pipeline([
            ('scaler', StandardScaler()),  # SVM用の標準化
            ('svc', SVC(probability=True))  # 確率を返す設定
        ]))
    ]
    
    # メタモデルとしてのロジスティック回帰
    stacking_clf = StackingClassifier(
        estimators=estimators,
        final_estimator=LogisticRegression(),
        cv=5  # 内部クロスバリデーション
    )
    
    # スタッキングモデルの学習と評価
    stacking_clf.fit(X_train, y_train)
    score = stacking_clf.score(X_test, y_test)
    
    print(f"スタッキングモデルのスコア: {score:.4f}")
    

    StackingClassifierは、複数のモデルを組み合わせて予測精度を向上させるアンサンブル手法です。各モデルが行った予測を特徴量として利用し、最終モデルが予測を行います。

    今回は、各モデルとしてランダムフォントとSVCを使っています。ランダムフォレストには標準化などの前処理が不要なため、前処理なしで使用しています。一方で、SVMはデータのスケールに敏感なため、StandardScalerで標準化を行っています。

    最終モデル(ここではロジスティック回帰)は、各モデルからの予測結果を入力として、クラスを予測します。デフォルトでは、StackingClassifierは各モデルのpredict_proba()の出力を使用します。そのため、SVC(probability=True)と指定し、predict_proba()が各クラスの確率を返すようにしています。

    StackingClassifierを生成するときに、stack_method='predict' を指定すると、各モデルのpredict()の出力を使用します。これは、例えば、クラス0や1などの値を出力します。確率の値よりも、各モデルからのラベル予測が有効なケースではこちらを使います。

    交差検証をする理由

    なお、cv=5 はデフォルトですが、ここでは明示的に指定してます。

    まず、訓練データを5つのフォールドに分割します。この5つの分割は、RandomForestとSVCなどの各モデルで共通して使用されます。それぞれのモデルが、この分割に基づいて交差検証を実行し、評価のために行った予測結果を集めて、最終モデルの訓練データとして使用します。

    その後、各モデルは訓練データ全体を使って新たに学習され、最終モデルの学習に必要な出力を生成します。このようにして、各モデルによって準備された特徴量は、未見データに基づいた予測結果となるため、最終モデルの訓練において過学習を抑え、汎化性能を向上させる効果があります。

    なお、VotingClassifierやStackingClassifierは分類モデルですが、回帰モデルとして、StackingRegressorとVotingRegressorがあります。

    次回予告

    これまで、教師あり学習のモデルを取り扱ってきましたが、次回からは教師なし学習のモデルを紹介します。

    お楽しみに!

     
     
    「わかりやすく、具体的に」AIとサイエンスの情報を発信中

    あなたへのおすすめ