Kaggle Masterに学ぶ機械学習実践アプローチ 写経 05

```Python
import pandas as pd
from sklearn import metrics 
from sklearn import preprocessing
from sklearn import linear_model
import xgboost as xgb
import itertools

def feature_engineering(df, num_cols):
    """
    特徴量エンジニアリングの関数
    :param df: 学習用もしくは検証用のデータセット
    :param cat_cols: 質的変数の列のリスト
    :return:  新しい特徴量のデータセット
    """
    # リスト内のあらゆる2角組み合わせを生成
    combos = list(itertools.combinations(num_cols, 2))
    for c1, c2 in combos:
        df[c1+"_"+c2] = df[c1].astype(str) + "_" + df[c2].astype(str)
    return df


def run(fold):
    # データを読み込み
    df = pd.read_csv("../input/adult/adult_folds.csv")

    # 数値を含む列
    num_cols = ["fnlwgt", "age", "capital-gain", "capital-loss", "hours-per-week"]

    #目的変数を0, 1に変換
    target_mapping = {" <=50K": 0, " >50K": 1}
    df["income"] = df.income.map(target_mapping)

    # 質的変数の列
    cat_cols = [x for x in df.columns if x not in num_cols and x not in ["income", "k_fold"]]

    # 新しい特徴量を追加
    df = feature_engineering(df, cat_cols)

    # 目的変数とfold番号を除き特徴量とする
    features = [x for x in df.columns if x not in ["income", "k_fold"]]

    # 全ての列を文字列型に変換
    # 全ての欠損値をNoneで補完
    for col in features: 
        # 数値を含む文字列は変換しない
        if col not in num_cols:
            df[col] = df[col].astype(str).fillna("None")

    # 特徴量のラベルエンコーディング
    for col in features:
        lbl = preprocessing.LabelEncoder()
        lbl.fit(df[col])
        df[col] = lbl.transform(df[col])

    # 引数のfold番号と一致しないデータをtrainに、一致するデータをvalidに格納    
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    # 学習用と検証用のデータをOne-Hot Encoding
    x_train = df_train[features]
    x_valid = df_valid[features]

    # 初期化
    model = xgb.XGBClassifier(n_jobs=-1, map_deapth=7, n_estimators=200)
    model.fit(x_train, df_train.income)

    # 検証用データ・セットに対する予測
    # AUCを計算するために、予測値が必要
    # 1である予測値を利用
    valid_preds = model.predict_proba(x_valid)[:,1]
    # aucを計算
    auc = metrics.roc_auc_score(df_valid.income , valid_preds)
    print(auc)

if __name__ == "__main__":
    for fold in range(5):
        print(f"fold={fold}")
        run(fold)
```
```Python
import pandas as pd
from sklearn import ensemble
from sklearn import metrics 
from sklearn import preprocessing

def run(fold):
    df = pd.read_csv("../input/cat_train_folds.csv")
    print(df.dtypes)
    features = [x for x in df.columns if x not in ["id", "target", "k_fold"]]

    # すべての欠損値をNoneで補完
    # すべての値を文字列に変換
    # すべて質的変数なので問題がない
    for col in features: 
        df.loc[:, col] = df[col].astype(str).fillna("None")

    for col in features:
        lbl = preprocessing.LabelEncoder()
        lbl.fit(df[col])
        df.loc[:, col] = lbl.transform(df[col])
    print(df.dtypes)
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    df_valid = df[df.k_fold == fold].reset_index(drop=True)


    # 学習用と検証用のデータ
    x_train = df_train[features]
    x_valid = df_valid[features]

    # 初期化
    model = ensemble.RandomForestClassifier(n_jobs=-1)
    model.fit(x_train, df_train.target)

    # 検証用データ・セットに対する予測
    # AUCを計算するために、予測値が必要
    # 1である予測値を利用
    valid_preds = model.predict_proba(x_valid)[:,1]
    # aucを計算
    auc = metrics.roc_auc_score(df_valid.target , valid_preds)
    print(auc)

if __name__ == "__main__":
    for fold in range(5):
        print(f"fold={fold}")
        run(fold)
```
```Python
import pandas as pd
from sklearn import metrics 
from sklearn import preprocessing
from sklearn import linear_model 

def run(fold):
    df = pd.read_csv("../input/cat_train_folds.csv")
    features = [x for x in df.columns if x not in ["id", "target", "k_fold"]]

    # すべての欠損値をNoneで補完
    # すべての値を文字列に変換
    # すべて質的変数なので問題がない
    for col in features: 
        df.loc[:, col] = df[col].astype(str).fillna("None")

    df_train = df[df.k_fold != fold].reset_index(drop=True)
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    ohe = preprocessing.OneHotEncoder()
    full_data = pd.concat([df_train[features], df_valid[features]], axis=0)
    # 学習用、検証用どちらかにだけ出現するものがあると良くないので、
    # 全てのデータをfitする
    ohe.fit(full_data[features])

    # 学習用と検証用のデータをOne-Hot Encoding
    x_train = ohe.transform(df_train[features])
    x_valid = ohe.transform(df_valid[features])

    # 初期化
    model = linear_model.LogisticRegression()
    model.fit(x_train, df_train.target)

    # 検証用データ・セットに対する予測
    # AUCを計算するために、予測値が必要
    # 1である予測値を利用
    valid_preds = model.predict_proba(x_valid)[:,1]
    # aucを計算
    auc = metrics.roc_auc_score(df_valid.target , valid_preds)
    print(auc)

if __name__ == "__main__":
    for fold in range(5):
        print(f"fold={fold}")
        run(fold)
```
```Python
import copy 
import pandas as pd 

from sklearn import metrics 
from sklearn import preprocessing 
import xgboost as xgb 

def mean_target_encoding(data):
    # データセットのコピー
    df = copy.deepcopy(data)

    # 数値を含む列
    num_cols = ["fnlwgt", "age", "capital-gain", "capital-loss", "hours-per-week"]

    # 目的変数を0, 1に変換
    target_mapping = {" <=50K": 0, " >50K": 1}
    df["income"] = df.income.map(target_mapping)

    # 目的変数とfold番号の列を除き、特徴量とする
    features = [x for x in df.columns if x not in ["income", "k_fold"] and x not in num_cols]

    for col in features:
        if col not in num_cols:
            df[col] = df[col].astype(str).fillna("NONE")

    # 特徴量のラベルエンコード
    for col in features:
        if col not in num_cols:
            lbl = preprocessing.LabelEncoder()
            lbl.fit(df[col])
            df[col] = lbl.transform(df[col])
    
    # 検証用データを格納するリスト
    encoded_dfs = []

    # 全ての分割についてのループ
    for fold in range(5):
        df_train = df[df.k_fold != fold].reset_index(drop=True)
        df_valid = df[df.k_fold == fold].reset_index(drop=True)

        # 全ての特徴量についてループ
        for column in features:
            mapping_dict = dict(df_train.groupby(column)["income"].mean())
            # もとの列の末尾に"ENC"を加えた形で新しい列を作成
            df_valid[f"{column}_enc"] = df_valid[column].map(mapping_dict)
        # リストに格納
        encoded_dfs.append(df_valid)

    # 検証用データを結合
    df_encoded = pd.concat(encoded_dfs, axis=0)

    return df_encoded 

def run(df, fold):
    # 分割方法は以前と同じ
    # 引数のfoldと一致しないデータを学習に利用
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    # 引数のfoldと一致するデータを検証に利用
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    # 目的変数とfold番号の列を除き特徴量とする
    features = [f for f in df.columns if f not in ["income", "k_fold"]]

    # 学習用データセットの準備
    x_train = df_train[features]

    # 検証用データセットの準備
    x_valid = df_valid[features]

    # 初期化
    model = xgb.XGBClassifier(n_jobs=-1, max_depth=7)

    # モデルの学習
    model.fit(x_train, df_train.income)

    # 検証用データセットに対する予測
    valid_preds = model.predict_proba(x_valid)[:, 1]

    #aucを計算
    auc = metrics.roc_auc_score(df_valid.income, valid_preds)

    print(f"fold={fold}, auc={auc:.4f}")

if __name__ == "__main__":
    df = pd.read_csv("../input/adult/adult_folds.csv")

    df = mean_target_encoding(df)

    for fold in range(5):
        run(df, fold)

```
```Python
import pandas as pd
from scipy import sparse
from sklearn import decomposition
from sklearn import ensemble
from sklearn import metrics
from sklearn import preprocessing

def run(fold):
    # 学習用データセットの読み込み
    df = pd.read_csv("../input/cat_train_folds.csv")
    # インデックスの目的変数とfoldの番号の列を除き、特徴量とする
    features = [x for x in df.columns if x not in ["id", "target", "k_fold"]]

    # すべての欠損値をNoneで補完
    # すべての値を文字列に変換
    # すべて質的変数なので問題がない
    for col in features:
        df.loc[:, col] = df[col].astype(str).fillna("None")

    # 引数のfoldに対応するfoldのデータを学習用と検証用に分ける
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    # 初期化
    ohe = preprocessing.OneHotEncoder()

    # 学習用と検証用のデータセットを結合し、One-Hot Encoding
    full_data = pd.concat([df_train[features], df_valid[features]], axis=0)
    ohe.fit(full_data[features])

    # 学習用と検証用のデータをOne-Hot Encoding
    x_train = ohe.transform(df_train[features])
    x_valid = ohe.transform(df_valid[features])

    # 初期化
    # 120次元に圧縮
    svd = decomposition.TruncatedSVD(n_components=120)

    # 学習用と検証用のデータセットを結合し学習 
    full_sparse = sparse.vstack([x_train, x_valid])
    svd.fit(full_sparse)
    # 学習用データセットを変換
    x_train = svd.transform(x_train)
    # 検証用データセットを変換
    x_valid = svd.transform(x_valid)

    #初期化
    model = ensemble.RandomForestClassifier(n_jobs=-1)
    model.fit(x_train, df_train.target)
    valid_preds = model.predict_proba(x_valid)[:, 1]
    auc = metrics.roc_auc_score(df_valid.target, valid_preds)
    print(f"fold={fold}, auc={auc:.4f}")

if __name__ == "__main__":
    for fold in range(5):
        run(fold)
    
```
```Python
import pandas as pd
import xgboost as xgb
from sklearn import metrics, preprocessing

def run(fold):
    # 学習用データの読み込み
    df = pd.read_csv("../input/cat_train_folds.csv")
    # print(df.dtypes)
    # インデックスと目的変数とfold番号を削除
    features = [x for x in df.columns if x not in ["id", "k_fold", "target"]]
    # すべての欠損値をNoneで補完
    # 合わせて、すべての列を文字列型に変換
    # すべて質的変数なので問題ない
    for col in features:
        df.loc[:,col] = df[col].astype(str).fillna("None")
    
    # ラベルエンコード
    for col in features:
        # 初期化
        lbl = preprocessing.LabelEncoder()
        # ラベルエンコーダーの学習
        lbl.fit(df[col])
        # 変換
        df.loc[:,col] = lbl.transform(df[col])
        df[col] = df[col].astype(int)
    # print(df.dtypes)
    # 引数のfold番号と一致しないデータを学習に利用
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    # 引数のfold番号と一致するデータを学習に利用
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    # 学習用データの準備
    x_train = df_train[features].values
    # 検証用データの準備
    x_valid = df_valid[features].values 
    # 初期化　
    model = xgb.XGBClassifier(
        n_jobs=-1,
        max_depth=7,
        n_estimators=200
    )

    # モデルの学習
    model.fit(x_train, df_train.target)
    # 検証用データセットに対する予測
    # AUCを計算するために予測値が必要
    # 1である予測値を利用
    valid_preds = model.predict_proba(x_valid)[:,1]
    auc = metrics.roc_auc_score(df_valid.target, valid_preds)
    print(f"fold={fold}, AUC={auc:.4f}")

if __name__ == "__main__":
    for i in range(5):
        run(i)
```
```Python
import pandas as pd
from sklearn import model_selection

if __name__ == "__main__":
    df = pd.read_csv("../input/train.csv")
    df["k_fold"] = -1
    df = df.sample(frac=1).reset_index(drop=True)
    y = df.target 
    kf = model_selection.StratifiedKFold(n_splits=5)
    for f, (t_, v_) in enumerate(kf.split(X=df, y=y)):
        df.loc[v_, "k_fold"] = f 
    df.to_csv("../input/cat_train_folds.csv", index=False)
```
```Python
import pandas as pd
from sklearn import metrics 
from sklearn import preprocessing
from sklearn import linear_model
import xgboost as xgb

def run(fold):
    # データを読み込み
    df = pd.read_csv("../input/adult/adult_folds.csv")

    # 数値を含む列
    num_cols = ["fnlwgt", "age", "capital-gain", "capital-loss", "hours-per-week"]

    #目的変数を0, 1に変換
    target_mapping = {" <=50K": 0, " >50K": 1}
    df["income"] = df.income.map(target_mapping)

    # 目的変数とfold番号を除き特徴量とする
    features = [x for x in df.columns if x not in ["income", "k_fold"]]

    # 全ての列を文字列型に変換
    # 全ての欠損値をNoneで補完
    for col in features: 
        # 数値を含む文字列は変換しない
        if col not in num_cols:
            df[col] = df[col].astype(str).fillna("None")

    # 特徴量のラベルエンコーディング
    for col in features:
        lbl = preprocessing.LabelEncoder()
        lbl.fit(df[col])
        df[col] = lbl.transform(df[col])

    # 引数のfold番号と一致しないデータをtrainに、一致するデータをvalidに格納    
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    # 学習用と検証用のデータをOne-Hot Encoding
    x_train = df_train[features]
    x_valid = df_valid[features]

    # 初期化
    model = xgb.XGBClassifier(n_jobs=-1, map_deapth=7, n_estimators=200)
    model.fit(x_train, df_train.income)

    # 検証用データ・セットに対する予測
    # AUCを計算するために、予測値が必要
    # 1である予測値を利用
    valid_preds = model.predict_proba(x_valid)[:,1]
    # aucを計算
    auc = metrics.roc_auc_score(df_valid.income , valid_preds)
    print(auc)

if __name__ == "__main__":
    for fold in range(5):
        print(f"fold={fold}")
        run(fold)
```
```Python
import pandas as pd
from sklearn import metrics 
from sklearn import preprocessing
from sklearn import linear_model 

def run(fold):
    # データを読み込み
    df = pd.read_csv("../input/adult/adult_folds.csv")

    # 数値を含む列
    num_cols = ["fnlwgt", "age", "capital-gain", "capital-loss", "hours-per-week"]
    # 数値を含む列の削除
    df = df.drop(num_cols, axis=1)

    # 目的変数を0, 1に変換
    # target_mapping = {" <=50K": 0, " >50K": 1}
    # df.loc[:, "income"] = df.income.map(target_mapping)

    # 目的変数とfold番号を除き特徴量とする
    features = [x for x in df.columns if x not in ["income", "k_fold"]]

    # 全ての列を文字列型に変換
    # 全ての欠損値をNoneで補完
    # 全て質的変数なので問題ない
    for col in features: 
        df.loc[:, col] = df[col].astype(str).fillna("None")

    # 引数のfold番号と一致しないデータをtrainに、一致するデータをvalidに格納    
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    ohe = preprocessing.OneHotEncoder()
    full_data = pd.concat([df_train[features], df_valid[features]], axis=0)
    # 学習用、検証用どちらかにだけ出現するものがあると良くないので、
    # 全てのデータをfitする
    ohe.fit(full_data[features])

    # 学習用と検証用のデータをOne-Hot Encoding
    x_train = ohe.transform(df_train[features])
    x_valid = ohe.transform(df_valid[features])

    # 初期化
    model = linear_model.LogisticRegression()
    model.fit(x_train, df_train.income)

    # 検証用データ・セットに対する予測
    # AUCを計算するために、予測値が必要
    # 1である予測値を利用
    valid_preds = model.predict_proba(x_valid)[:,1]
    # aucを計算
    auc = metrics.roc_auc_score(df_valid.income , valid_preds)
    print(auc)

if __name__ == "__main__":
    for fold in range(5):
        print(f"fold={fold}")
        run(fold)
```
```Python
import pandas as pd
from sklearn import metrics 
from sklearn import preprocessing
from sklearn import linear_model
import xgboost as xgb

def run(fold):
    # データを読み込み
    df = pd.read_csv("../input/adult/adult_folds.csv")

    # 数値を含む列
    num_cols = ["fnlwgt", "age", "capital-gain", "capital-loss", "hours-per-week"]
    # 数値を含む列の削除
    df = df.drop(num_cols, axis=1)

    #目的変数を0, 1に変換
    target_mapping = {" <=50K": 0, " >50K": 1}
    df["income"] = df.income.map(target_mapping)
    # 目的変数とfold番号を除き特徴量とする
    features = [x for x in df.columns if x not in ["income", "k_fold"]]

    # 全ての列を文字列型に変換
    # 全ての欠損値をNoneで補完
    # 全て質的変数なので問題ない
    for col in features: 
        df[col] = df[col].astype(str).fillna("None")

    # 特徴量のラベルエンコーディング
    for col in features:
        lbl = preprocessing.LabelEncoder()
        lbl.fit(df[col])
        df[col] = lbl.transform(df[col])

    # 引数のfold番号と一致しないデータをtrainに、一致するデータをvalidに格納    
    df_train = df[df.k_fold != fold].reset_index(drop=True)
    df_valid = df[df.k_fold == fold].reset_index(drop=True)

    # 学習用と検証用のデータをOne-Hot Encoding
    x_train = df_train[features]
    x_valid = df_valid[features]

    # 初期化
    model = xgb.XGBClassifier(n_jobs=-1, map_deapth=7, n_estimators=200)
    model.fit(x_train, df_train.income)

    # 検証用データ・セットに対する予測
    # AUCを計算するために、予測値が必要
    # 1である予測値を利用
    valid_preds = model.predict_proba(x_valid)[:,1]
    # aucを計算
    auc = metrics.roc_auc_score(df_valid.income , valid_preds)
    print(auc)

if __name__ == "__main__":
    for fold in range(5):
        print(f"fold={fold}")
        run(fold)
```
```Python
import pandas as pd
from sklearn import model_selection

if __name__ == "__main__":
    df = pd.read_csv("../input/adult/adult.data", 
                    header=None, 
                    names=["age", "workclass", "fnlwgt", "education", "education-num", "marital-status", "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss", "hours-per-week", "native-country", "income"])
    df["k_fold"] = -1
    df = df.sample(frac=1).reset_index(drop=True)
    y = df.income 
    kf = model_selection.StratifiedKFold(n_splits=5)
    for f, (t_, v_) in enumerate(kf.split(X=df, y=y)):
        df.loc[v_, "k_fold"] = f 
    df.to_csv("../input/adult/adult_folds.csv", index=False)
```