Kaggle-Data Science London + Scikit-learn（一）

大家好~Kaggle这个平台相信大家都知道，上面有各式各样的资料和题目，很多题目得到名次还有奖金。我是接触了资料分析之後才知道这个平台，在结训後找工作的闲暇时刻，想说上Kaggle找个题目来练习练习，但上面大部分题目都很难啊，後来找到了这个看似比较基础的题目Data Science London + Scikit-learn(连结在此)。

• 确认问题

里面总共有这四个CSV档，其中submission是你要上传给Kaggle的档案示范，train里面有1000笔资料，40个特徵；test有9000笔资料，40个特徵，而trainLabels则是train里面1000笔资料的label，也就是我们的应变数。而我们要做的事从train的1000笔资料，去预测test的9000笔资料的label是甚麽。

• 载入资料和观察资料

我们先载入资料，并且看一下资料的型态，以及检察缺失值。

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

train = pd.read_csv('./train.csv', header=None)
trainLabel = pd.read_csv('./trainLabels.csv', header=None)
test = pd.read_csv('./test.csv', header=None)
warnings.filterwarnings("ignore")

检查有无文字资料存在。

categorical = train.select_dtypes(include='object')
print(categorical)

发现并无文字资料，全为数值型的资料。

检查缺失值。

print(train.isna().sum())

此份资料没有缺失值。

这份资料算是满乾净的，并且她没有栏位的意思，我们就不做甚麽清洗，接下来做的是特徵筛选。

• 特徵筛选

这里我先用主成分分析（Principal Component Analysis,简称为 PCA）去做一个特徵的萃取，必须为连续变数且无缺失值。PCA是一种无监督学习，主要用途是在於降低维度，比方说我们有K个维度的特徵，透过PCA降维萃取出M个维度，且这K个维度的特徵在不损失太多资讯的情况下拥有K维特徵大部分的特性。
想对PCA深入了解推荐这篇文章(传送门)

现在我们就来对资料做PCA处理吧，train和test都要记得做PCA喔！！
那这里我们取保留15个特徵，然後再来看看PCA後的资料。

from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split

pca = PCA(n_components=15) 
pca_train = pca.fit_transform(train)
pca_test = pca.fit_transform(test)

train_pca_df = pd.DataFrame(pca_train).values
test_pca_df = pd.DataFrame(pca_test).values

train_pca_df

test_pca_df

train和test都变成15个特徵了，接下来再用之前用过的train_test_split来帮我们的train分割出训练集和测试集，我们取30%切为测试集。

X_train,X_test,y_train,y_test = train_test_split(train_pca_df,trainLabel,test_size=0.3, random_state=101)
print(X_train.shape,X_test.shape,y_train.shape,y_test.shape)

可以看到已经帮我们分割好了X_train有700笔资料，15个特徵，X_test有300笔资料，15个特徵。y_train和y_test是我们对应的label。

特徵工程筛选好了之後，我们直接丢进模型建模看看罗！！

• 模型建立

这里跟我们上一篇用的模型和方法一样，会需要做SKFold的交叉验证。
再提醒一次喔，StratifiedKFold跟KFold交叉验证差别在於，StratifiedKFold做交叉验证，相较於KFold，StratifiedKFold会照比例在每个data set中抽取资料作验证。

from sklearn.model_selection import cross_val_score,StratifiedKFold,GridSearchCV

sk_fold = StratifiedKFold(10,shuffle=True, random_state=42)

然後建立我们的模型。
先import SKlearn的模型套件。

# NAIBE BAYES
from sklearn.naive_bayes import GaussianNB
#KNN
from sklearn.neighbors import KNeighborsClassifier
#RANDOM FOREST
from sklearn.ensemble import RandomForestClassifier
#LOGISTIC REGRESSION
from sklearn.linear_model import LogisticRegression
#SVM
from sklearn.svm import SVC
#DECISON TREE
from sklearn.tree import DecisionTreeClassifier
#XGBOOST
from xgboost import XGBClassifier
#AdaBoosting Classifier
from sklearn.ensemble import AdaBoostClassifier
#GradientBoosting Classifier
from sklearn.ensemble import GradientBoostingClassifier
#HistGradientBoostingClassifier
from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier, StackingClassifier
from sklearn.metrics import confusion_matrix

g_nb = GaussianNB()
knn = KNeighborsClassifier()  # 参数:n_neighbors(邻居数:预设为5)、weights(权重,预设为uniform)、leaf_size(叶的大小:预设为30)
ran_for  = RandomForestClassifier()
# n_estimators:树的颗数、max_depth:最大深度，剪枝用，超过全部剪掉。
# min_samples_leaf:搭配max_depth使用，一个节点在分枝後每个子节点都必须包含至少min_samples_leaf个训练样本
# bootstrap:重新取样原有Data产生新的Data，取样的过程是均匀且可以重复取样
log_reg = LogisticRegression() #penalty:惩罚函数(预设L2)、Ｃ:正则强度倒数，预设为1.0、solver:解决器(默认='lbfgs')，saga对所有惩罚都可以使用
tree= DecisionTreeClassifier()
xgb = XGBClassifier()#https://www.itread01.com/content/1536594984.html 参数详解
ada_boost = AdaBoostClassifier() # https://ask.hellobi.com/blog/zhangjunhong0428/12405 参数详解
grad_boost = GradientBoostingClassifier(n_estimators=100) # https://www.itread01.com/content/1514358146.html 参数详解
hist_grad_boost = HistGradientBoostingClassifier() # https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.HistGradientBoostingClassifier.html

clf = [("Naive Bayes", g_nb, {}), \
       ("K Nearest", knn, {"n_neighbors": [3, 5, 6, 7, 8, 9, 10], "leaf_size": [25, 30, 35]}), \
       ("Random Forest", ran_for,
        {"n_estimators": [10, 50, 100, 200, 400], "max_depth": [3, 10, 20, 40], "random_state": [99],
         "min_samples_leaf": [5, 10, 20, 40, 50], "bootstrap": [False]}), \
       ("Logistic Regression", log_reg, {"penalty": ['l2'], "C": [100, 10, 1.0, 0.1, 0.01], "solver": ['saga']}), \
       ("Decision Tree", tree, {}), \
       ("XGBoost", xgb,
        {"n_estimators": [200], "max_depth": [3, 4, 5], "learning_rate": [.01, .1, .2], "subsample": [.8],
         "colsample_bytree": [1], "gamma": [0, 1, 5], "lambda": [.01, .1, 1]}), \
 \
       ("Adapative Boost", ada_boost, {"n_estimators": [100], "learning_rate": [.6, .8, 1]}), \
       ("Gradient Boost", grad_boost, {}), \
 \
       ("Histogram GB", hist_grad_boost,
        {"loss": ["binary_crossentropy"], "min_samples_leaf": [5, 10, 20, 40, 50], "l2_regularization": [0, .1, 1]})]

前置作业都准备好之後，我们可以来训练模型了，我透过GridSearchCV这个套件一次训练多个模型让他找出最佳参数组合。

stack_list = []
train_scores = pd.DataFrame(columns=["Name", "Train Score", "Test Score"])

i = 0
for name, clf1, param_grid in clf:
    clf = GridSearchCV(clf1, param_grid=param_grid, scoring="accuracy", cv=sk_fold, return_train_score=True)
    clf.fit(X_train, y_train)  # .reshape(-1,1)
    y_pred = clf.best_estimator_.predict(X_test)

    cm = confusion_matrix(y_test, y_pred)
    print(cm)
    print("=====================================")

    train_scores.loc[i] = [name, clf.best_score_, (cm[0, 0] + cm[1, 1,]) / (cm[0, 0] + cm[0, 1] + cm[1, 0] + cm[1, 1])]
    stack_list.append(clf.best_estimator_)
    i = i + 1

est = [("g_nb", stack_list[0]), \
       ("knn", stack_list[1]), \
       ("ran_for", stack_list[2]), \
       ("log_reg", stack_list[3]), \
       ("dec_tree", stack_list[4]), \
       ("XGBoost", stack_list[5]), \
       ("ada_boost", stack_list[6]), \
       ("grad_boost", stack_list[7]), \
       ("hist_grad_boost", stack_list[8])]

最後我一样会用集成学习的方法stacking堆叠法来做一次建模。

sc = StackingClassifier(estimators=est,final_estimator = None,cv=sk_fold,passthrough=False)
sc.fit(X_train,y_train)
y_pred = sc.predict(X_test)
cm1 = confusion_matrix(y_test,y_pred)
y_pred_train = sc.predict(X_train)
cm2 = confusion_matrix(y_train,y_pred_train)
train_scores.append(pd.Series(["Stacking",(cm2[0,0]+cm2[1,1,])/(cm2[0,0]+cm2[0,1]+cm2[1,0]+cm2[1,1]),(cm1[0,0]+cm1[1,1,])/(cm1[0,0]+cm1[0,1]+cm1[1,0]+cm1[1,1])],index=train_scores.columns),ignore_index=True)

这边发现stacking的test score最高，我这边就选择用stacking模型去预测我最後的结果。

sc.fit(train_pca_df,trainLabel)
y_submit = sc.predict(test_pca_df)
y_submit= pd.DataFrame(y_submit)
y_submit.index +=1
y_submit.columns = ['Solution']
y_submit['Id'] = np.arange(1,y_submit.shape[0]+1)
y_submit = y_submit[['Id', 'Solution']]
y_submit.to_csv('./Submission.csv',index=False)

这分数并没有很好看，排名也在中後段，於是我後来参考了一个热心提供code和降维方法的大神，明天来把他的code带给大家做参考，我的code有些也是抓他的code下来做修改的喔！！今天就先到这边罗～

• 今日小结

今天也是带大家做一个SKlearn的练习，以及做一个特徵工程降维的动作，让大家熟悉建模的流程，希望有帮助到需要的人喔～！明天见啦～