交叉验证的基本思想是把在某种意义下将原始数据(dataset)进行分组,一部分做为训练集(train set),另一部分做为验证集(validation set or test set),首先用训练集对分类器进行训练,再利用验证集来测试训练得到的模型(model),以此来做为评价分类器的性能指标。

也就是说，我们把题目中所给的训练集当成一个原始数据，将这个数据切分成训练集和测试集。利用切分出的训练集进行训练，切分出的测试集进行验证。

1. 训练集中样本数量要足够多，一般至少大于总样本数的50%。
2. 训练集和测试集必须从完整的数据集中均匀取样。均匀取样的目的是希望减少训练集、测试集与原数据集之间的偏差。当样本数量足够多时，通过随机取样，便可以实现均匀取样的效果。（随机取样，可重复性差）

from sklearn.model_selection import cross_val_score
from sklearn import linear_model

#简单看看打分情况
clf = linear_model.LogisticRegression(C=1.0, penalty='l2', tol=1e-6)
X = train_df.values[:,1:]
y = train_df.values[:,0]
# 交叉验证的结果
cross_val_score(clf, X_train, Y_train, cv=5) # cv=5,5倍交叉验证

array([0.79888268, 0.80337079, 0.81460674, 0.78651685, 0.83146067])

我们已经进行了交叉验证，其实我们可以把交叉验证里预测错误的记录拿出来，通过人工审核，去帮助我们发现新的优化方向，继续探索。


对于以下方法对应的参数不了解的，可以参考官方文档说明:

linear_model.LogisticRegression官方文档说明

cross_validation.cross_val_score官方文档说明

cross_validation.train_test_split官方文档说明

from sklearn.model_selection import train_test_split

# 分割数据，按照 训练数据:cv数据 = 7:3的比例
split_train, split_cv = train_test_split(train_df, test_size=0.3, random_state=0) # test_size测试集占数据的比例
train_df = split_train

# 生成模型
clf = linear_model.LogisticRegression(C=1.0, penalty='l2', tol=1e-6)
clf.fit(train_df.values[:,1:], train_df.values[:,0])

# 对cross validation数据进行预测
cv_df = split_cv
predictions = clf.predict(cv_df.values[:,1:])

origin_data_train = pd.read_csv("../input/train.csv")

# 交叉验证没有预测对的记录
bad_cases = origin_data_train.loc[origin_data_train['PassengerId'].isin(split_cv[predictions != cv_df.values[:,0]]['PassengerId'].values)]
bad_cases

D:\Anaconda3\lib\site-packages\sklearn\linear_model\_logistic.py:814: 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(

64 rows × 12 columns

观察这些预测错误的记录，提出新的优化方向，继续尝试挖掘，可能还可以想到更多可以细挖的部分。将新的特征和已有特征组合在一起，查看模型预测准确度是否有所提升。继续迭代下去。

问题14：观察这些预测错误的记录，你还能想到什么优化的方向？



仅供参考：

1. Fare细化处理，可能可以考虑将Fare与乘客等级Pclass相关连。
2. 可以考虑将除Age*Class之外的分类特征进行特征交叉。
3. 可能考虑加入Cabin特征，并进一步对其进行细化研究。

举个来说：

过拟合就像是你班那个学数学比较刻板的同学，老师讲过的题目，一字不漏全记下来了，于是老师再出一样的题目，分分钟精确出结果。but数学考试，因为总是碰到新题目，所以成绩不咋地。

欠拟合就像是连老师讲的练习题也记不住的同学，于是连老师出一样题目复习的周测都做不好，考试更是可想而知了。

经典解释

解释1
解释2

在机器学习的问题上，对于过拟合和欠拟合两种情形。我们优化的方式是不同的。

著名的learning curve可以帮我们判定我们的模型现在所处的状态。

我们以样本数为横坐标，训练和交叉验证集上的错误率作为纵坐标，我们也可以把错误率替换成准确率(得分)，得到另一种形式的learning curve(sklearn 里面是这么做的)。

回到我们的问题，我们用scikit-learn里面的learning_curve来帮我们分辨我们模型的状态。

举个例子，这里我们一起画一下我们最先得到的baseline model的learning curve。

# import numpy as np
# import matplotlib.pyplot as plt
# from sklearn.model_selection import learning_curve

# # 用sklearn的learning_curve得到training_score和cv_score，使用matplotlib画出learning curve
# def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None, n_jobs=1, 
#                         train_sizes=np.linspace(.05, 1., 20), verbose=0, plot=True): # train_sizes训练集占数据的比例
#     """
#     画出data在某模型上的learning curve.
#     参数解释
#     ----------
#     estimator : 你用的分类器。
#     title : 表格的标题。
#     X : 输入的feature，numpy类型
#     y : 输入的target vector
#     ylim : tuple格式的(ymin, ymax), 设定图像中纵坐标的最低点和最高点
#     cv : 做cross-validation的时候，数据分成的份数，其中一份作为cv集，其余n-1份作为training(默认为3份)
#     n_jobs : 并行的的任务数(默认1)
#     """
#     train_sizes, train_scores, test_scores = learning_curve(
#         estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes, verbose=verbose)

#     train_scores_mean = np.mean(train_scores, axis=1)
#     train_scores_std = np.std(train_scores, axis=1)
#     test_scores_mean = np.mean(test_scores, axis=1)
#     test_scores_std = np.std(test_scores, axis=1)

#     if plot:
#         plt.figure()
#         plt.title(title)
#         if ylim is not None:
#             plt.ylim(*ylim)
#         plt.xlabel(u"training_sample")
#         plt.ylabel(u"cv_sample")
#         plt.gca().invert_yaxis()
#         plt.grid()

#         plt.fill_between(train_sizes, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, 
#                          alpha=0.1, color="b")
#         plt.fill_between(train_sizes, test_scores_mean - test_scores_std, test_scores_mean + test_scores_std, 
#                          alpha=0.1, color="r")
#         plt.plot(train_sizes, train_scores_mean, 'o-', color="b", label=u"train_scores")
#         plt.plot(train_sizes, test_scores_mean, 'o-', color="r", label=u"cv_scores")

#         plt.legend(loc="best")

#         plt.draw()
#         plt.show()
#         plt.gca().invert_yaxis()

#     midpoint = ((train_scores_mean[-1] + train_scores_std[-1]) + (test_scores_mean[-1] - test_scores_std[-1])) / 2
#     diff = (train_scores_mean[-1] + train_scores_std[-1]) - (test_scores_mean[-1] - test_scores_std[-1])
#     return midpoint, diff

# plot_learning_curve(clf, u"learning curve", X, y)

在实际数据上看，我们得到的learning curve没有理论推导的那么光滑哈，但是可以大致看出来，训练集和交叉验证集上的得分曲线走势还是符合预期的。

目前的曲线看来，我们的model并不处于overfitting的状态(overfitting的表现一般是训练集上得分高，而交叉验证集上要低很多，中间的gap比较大)。因此我们可以再做些feature engineering的工作，添加一些新产出的特征或者组合特征到模型中。

模型融合是机器学习/数据挖掘中经常使用到的一个利器，它通常可以在各种不同的机器学习任务中使结果获得提升。顾名思义，模型融合就是综合考虑不同模型的情况，并将它们的结果融合到一起。


举个例子来说，你和你班某数学大神关系好，每次作业都『模仿』他的，于是绝大多数情况下，他做对了，你也对了。突然某一天大神脑子犯糊涂，手一抖，写错了一个数，于是…恩，你也只能跟着错了。

我们再来看看另外一个场景，你和你班5个数学大神关系都很好，每次都把他们作业拿过来，对比一下，再『自己做』，那你想想，如果哪天某大神犯糊涂了，写错了，but另外四个写对了啊，那你肯定相信另外4人的是正确答案吧？

最简单的模型融合大概就是这么个意思，比如分类问题，当我们手头上有一堆在同一份数据集上训练得到的分类器(比如logistic regression，SVM，KNN，random forest，神经网络)，那我们让他们都分别去做判定，然后对结果做投票统计，取票数最多的结果为最后结果。

from sklearn.ensemble import BaggingRegressor

# fit到BaggingRegressor之中
logreg = LogisticRegression() # 基于baseline逻辑回归的结果
bagging_clf = BaggingRegressor(logreg, n_estimators=25, max_samples=0.8, max_features=1.0, bootstrap=True, bootstrap_features=False, n_jobs=-1)
ensemble = bagging_clf.fit(X_train, Y_train)
predictions = bagging_clf.predict(X_test)

acc_BaggingRegressor = round(ensemble.score(X_train, Y_train) * 100, 2)
acc_BaggingRegressor

35.25

from sklearn.ensemble import BaggingClassifier

# fit到BaggingClassifier之中
logreg = LogisticRegression() # 基于baseline逻辑回归的结果
bagging_clf = BaggingClassifier(logreg, n_estimators=25, max_samples=0.8, max_features=1.0, bootstrap=True, bootstrap_features=False, n_jobs=-1)
ensemble = bagging_clf.fit(X_train, Y_train)
predictions = bagging_clf.predict(X_test)

acc_BaggingClassifier = round(ensemble.score(X_train, Y_train) * 100, 2)
acc_BaggingClassifier

81.03

# 保存预测结果
bagging_result = pd.DataFrame({"PassengerId": test_df["PassengerId"],"Survived": predictions})
bagging_result.to_csv('../input/logistic_regression_baggingRegressor_predictions.csv', index=False)
bagging_result.to_csv('../input/logistic_regression_baggingClassifier_predictions.csv', index=False)

需要理解清楚我们正在解决的问题和所需给出的答案要求的类型，然后进一步缩小范围，最终去选择一些算法用于解决问题，并进一步来评估算法的预测结果。


问题界定：

1. 分类和回归问题。
   我们需要解决的是输入的特征和是否获救这个输出结果之间的关系。
2. 监督学习问题。
   我们使用一个已经给出是否获救分类结果的数据集来训练模型。

通过以上两点，我们可以确定缩小范围，选择以下算法来预测结果：

- Logistic Regression
- KNN/k-Nearest Neighbors
- Support Vector Machines
- Naive Bayes classifier
- Decision Tree
- Random Forrest
- Perceptron
- RVM or Relevance Vector Machine
- Artificial neural network

根据大家已经学过的知识，不同的模型对放入模型中的特征值要求不同，处理方法不同。那么大家能不能基于上面我们已经完成的特征工程部分的思路，对数据进行相应的处理以适应不同算法，获得以上其他算法的预测结果，并验证是否过拟合进行相应的处理。

不同的模型对于放入模型中的特征有不同的要求，我们暂时先不管那么多，先暴力实现其他算法，开心开心。

说明：所得结果，均使用最终放入随机森林算法中的特征处理结果带入，仅供参考。

import sklearn.metrics as sm

# Support Vector Machines
svc = SVC()
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_train)
# acc_svc = round(svc.score(Y_pred, Y_train) * 100, 2)
# acc_svc
print(sm.classification_report(Y_pred, Y_train))

              precision    recall  f1-score   support

           0       0.92      0.83      0.87       606
           1       0.70      0.84      0.76       285

    accuracy                           0.83       891
   macro avg       0.81      0.83      0.82       891
weighted avg       0.85      0.83      0.84       891

# KNN
knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_train)
# acc_knn = round(knn.score(X_train, Y_train) * 100, 2)
# acc_knn
print(sm.classification_report(Y_pred, Y_train))

              precision    recall  f1-score   support

           0       0.92      0.84      0.88       600
           1       0.72      0.85      0.78       291

    accuracy                           0.84       891
   macro avg       0.82      0.85      0.83       891
weighted avg       0.86      0.84      0.85       891

# Gaussian Naive Bayes
gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_train)
# acc_gaussian = round(gaussian.score(X_train, Y_train) * 100, 2)
# acc_gaussian
print(sm.classification_report(Y_pred, Y_train))

              precision    recall  f1-score   support

           0       0.78      0.85      0.81       504
           1       0.78      0.69      0.73       387

    accuracy                           0.78       891
   macro avg       0.78      0.77      0.77       891
weighted avg       0.78      0.78      0.78       891

# Perceptron
perceptron = Perceptron()
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_train)
# acc_perceptron = round(perceptron.score(X_train, Y_train) * 100, 2)
# acc_perceptron
print(sm.classification_report(Y_pred, Y_train,digits=4))

              precision    recall  f1-score   support

           0     0.8725    0.7983    0.8338       600
           1     0.6462    0.7595    0.6983       291

    accuracy                         0.7856       891
   macro avg     0.7593    0.7789    0.7660       891
weighted avg     0.7986    0.7856    0.7895       891

# Linear SVC
linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_train)
# acc_linear_svc = round(linear_svc.score(X_train, Y_train) * 100, 2)
# acc_linear_svc
print(sm.classification_report(Y_pred, Y_train,digits=4))

              precision    recall  f1-score   support

           0     0.8743    0.8421    0.8579       570
           1     0.7368    0.7850    0.7602       321

    accuracy                         0.8215       891
   macro avg     0.8056    0.8136    0.8090       891
weighted avg     0.8248    0.8215    0.8227       891



D:\Anaconda3\lib\site-packages\sklearn\svm\_base.py:1206: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.
  warnings.warn(

# Stochastic Gradient Descent
sgd = SGDClassifier(max_iter=5000)
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_train)
# acc_sgd = round(sgd.score(X_train, Y_train) * 100, 2)
# acc_sgd
print(sm.classification_report(Y_pred, Y_train,digits=4))

              precision    recall  f1-score   support

           0     0.8871    0.8144    0.8492       598
           1     0.6754    0.7884    0.7276       293

    accuracy                         0.8058       891
   macro avg     0.7813    0.8014    0.7884       891
weighted avg     0.8175    0.8058    0.8092       891

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipe_sgd = Pipeline([ ("scaler",StandardScaler() ),('sgd', SGDClassifier(loss="modified_huber",penalty="l1", max_iter=1000))])
pipe_sgd.fit(X_train,Y_train)
y_pre=pipe_sgd.predict(X_train)
y_pre_prob_=pipe_sgd.predict_proba(X_train)
y_pre_prob=[]
for i in range(len(y_pre)):
    if y_pre[i]==1:
        y_pre_prob.append(y_pre_prob_[i][1])
    else:
        y_pre_prob.append(1-y_pre_prob_[i][0])
        
print(sm.classification_report(Y_pred, Y_train,digits=4))
print(sm.mean_absolute_error(Y_pred_prob,Y_train))

              precision    recall  f1-score   support

           0     0.9290    0.8644    0.8955       590
           1     0.7661    0.8704    0.8149       301

    accuracy                         0.8664       891
   macro avg     0.8475    0.8674    0.8552       891
weighted avg     0.8739    0.8664    0.8683       891

0.22110828951156772

# xgb
from xgboost.sklearn import XGBClassifier
from sklearn.model_selection import RandomizedSearchCV


sample_weight=[]
for i in range(len(Y_train)):
    if Y_train[i]==0:
        sample_weight.append(1)
    else:
        sample_weight.append(2)
xgb= XGBClassifier(n_estimators=5000,max_depth=10,scale_pos_weight =0.3,learning_rate =0.01,gamma =0.05,subsample=0.7,colsample_bytree=0.4,min_child_weight=0.2)

xgb.fit(X_train,Y_train)

Y_pred=xgb.predict(X_train)
Y_pred_prob_=xgb.predict_proba(X_train)
Y_pred_prob=[]
for i in range(len(Y_pred)):
    if Y_pred[i]==1:
        Y_pred_prob.append(Y_pred_prob_[i][1])
    else:
        Y_pred_prob.append(1-Y_pred_prob_[i][0])
    
print(sm.classification_report(Y_pred, Y_train,digits=4))
print(sm.mean_absolute_error(Y_pred_prob,Y_train))

              precision    recall  f1-score   support

           0     0.9891    0.7915    0.8794       686
           1     0.5819    0.9707    0.7276       205

    accuracy                         0.8328       891
   macro avg     0.7855    0.8811    0.8035       891
weighted avg     0.8954    0.8328    0.8444       891

0.19012825731208963

# Decision Tree
decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_train)
Y_pred_prob_=decision_tree.predict_proba(X_train)
Y_pred_prob=[]
for i in range(len(Y_pred)):
    if Y_pred[i]==1:
        Y_pred_prob.append(Y_pred_prob_[i][1])
    else:
        Y_pred_prob.append(1-Y_pred_prob_[i][0])
    
print(sm.classification_report(Y_pred, Y_train,digits=4))
print(sm.mean_absolute_error(Y_pred_prob,Y_train))

              precision    recall  f1-score   support

           0     0.9344    0.8607    0.8961       596
           1     0.7573    0.8780    0.8132       295

    accuracy                         0.8664       891
   macro avg     0.8459    0.8694    0.8546       891
weighted avg     0.8758    0.8664    0.8686       891

0.1870742685334913

# Random Forest
random_forest = RandomForestClassifier(n_estimators=1000) # 定义决策树的个数为100
random_forest.fit(X_train, Y_train)
Y_pred = random_forest.predict(X_train)
Y_pred_prob_=random_forest.predict_proba(X_train)
Y_pred_prob=[]
for i in range(len(Y_pred)):
    if Y_pred[i]==1:
        Y_pred_prob.append(Y_pred_prob_[i][1])
    else:
        Y_pred_prob.append(1-Y_pred_prob_[i][0])
    
print(sm.classification_report(Y_pred, Y_train,digits=4))
print(sm.mean_absolute_error(Y_pred_prob,Y_train))

              precision    recall  f1-score   support

           0     0.9253    0.8669    0.8952       586
           1     0.7719    0.8656    0.8161       305

    accuracy                         0.8664       891
   macro avg     0.8486    0.8662    0.8556       891
weighted avg     0.8728    0.8664    0.8681       891

0.19873776366870244

from sklearn.ensemble import AdaBoostClassifier,HistGradientBoostingRegressor,GradientBoostingClassifier

# gbdt
gbdt = GradientBoostingClassifier(criterion="friedman_mse",n_estimators=1000,learning_rate=0.05)
gbdt.fit(X_train,Y_train)
Y_pred=gbdt.predict(X_train)
Y_pred_prob_=gbdt.predict_proba(X_train)
Y_pred_prob=[]
for i in range(len(Y_pred)):
    if Y_pred[i]==1:
        Y_pred_prob.append(Y_pred_prob_[i][1])
    else:
        Y_pred_prob.append(1-Y_pred_prob_[i][0])
    
print(sm.classification_report(Y_pred, Y_train,digits=4))
print(sm.mean_absolute_error(Y_pred_prob,Y_train))

              precision    recall  f1-score   support

           0     0.9199    0.8707    0.8946       580
           1     0.7807    0.8585    0.8178       311

    accuracy                         0.8664       891
   macro avg     0.8503    0.8646    0.8562       891
weighted avg     0.8713    0.8664    0.8678       891

0.19961541192640012

#mlp
from sklearn.ensemble import AdaBoostClassifier,HistGradientBoostingRegressor,GradientBoostingClassifier

# mlp
gbdt = MLPClassifier(solver='lbfgs', alpha=1e-5,
                     hidden_layer_sizes=(32,16,4),learning_rate="invscaling",random_state=1)
gbdt.fit(X_train,Y_train)
Y_pred=gbdt.predict(X_train)
Y_pred_prob_=gbdt.predict_proba(X_train)
Y_pred_prob=[]
for i in range(len(Y_pred)):
    if Y_pred[i]==1:
        Y_pred_prob.append(Y_pred_prob_[i][1])
    else:
        Y_pred_prob.append(1-Y_pred_prob_[i][0])
    
print(sm.classification_report(Y_pred, Y_train,digits=4))
print(sm.mean_absolute_error(Y_pred_prob,Y_train))

              precision    recall  f1-score   support

           0     0.9162    0.8672    0.8911       580
           1     0.7749    0.8521    0.8116       311

    accuracy                         0.8620       891
   macro avg     0.8455    0.8597    0.8513       891
weighted avg     0.8669    0.8620    0.8633       891

0.1949298895378452

问题16：神经网络实现

我们已经尝试使用这么多的算法来尝试解决问题，现在只差一个神经网络了。是时候自己动手，实现你的第一个神经网络了！
sklearn中已经有了成熟的实现。

from mlxtend.classifier import StackingClassifier
from sklearn.linear_model import SGDClassifier
sreg = StackingClassifier(verbose=2,classifiers=[xgb,decision_tree,gbdt,random_forest,pipe_sgd], 
                          meta_classifier=SGDClassifier( loss="log",penalty="l1", max_iter=5000)
)

sreg.fit(X_train, Y_train)
Y_pred = sreg.predict(X_train)

Y_pred_prob_= sreg.predict_proba(X_train)

Y_pred_prob=[]
for i in range(len(Y_pred)):
    if Y_pred[i]==1:
        Y_pred_prob.append(Y_pred_prob_[i][1])
    else:
        Y_pred_prob.append(1-Y_pred_prob_[i][0])
    
print(sm.classification_report(Y_pred, Y_train,digits=4))
print(sm.mean_absolute_error(Y_pred_prob,Y_train))

Fitting 5 classifiers...
Fitting classifier1: xgbclassifier (1/5)
XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,
              colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,
              early_stopping_rounds=None, enable_categorical=False,
              eval_metric=None, feature_types=None, gamma=0, gpu_id=-1,
              grow_policy='depthwise', importance_type=None,
              interaction_constraints='', learning_rate=0.300000012,
              max_bin=256, max_cat_threshold=64, max_cat_to_onehot=4,
              max_delta_step=0, max_depth=10, max_leaves=0, min_child_weight=1,
              missing=nan, monotone_constraints='()', n_estimators=3000,
              n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0, ...)
Fitting classifier2: decisiontreeclassifier (2/5)
DecisionTreeClassifier()
Fitting classifier3: mlpclassifier (3/5)
MLPClassifier(alpha=1e-05, hidden_layer_sizes=(32, 16, 4),
              learning_rate='invscaling', random_state=1, solver='lbfgs')

Fitting classifier4: randomforestclassifier (4/5)
RandomForestClassifier(n_estimators=1000)
Fitting classifier5: pipeline (5/5)
Pipeline(steps=[('scaler', StandardScaler()),
                ('sgd', SGDClassifier(loss='modified_huber', penalty='l1'))])
              precision    recall  f1-score   support

           0     0.9217    0.8694    0.8948       582
           1     0.7778    0.8608    0.8172       309

    accuracy                         0.8664       891
   macro avg     0.8497    0.8651    0.8560       891
weighted avg     0.8718    0.8664    0.8679       891

0.24045011034849822