Titanic 泰坦尼克数据集 特征工程 机器学习建模

逻辑回归优化

交叉验证

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

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

常见类型的交叉验证

1. 重复随机子抽样验证

将数据集随机的划分为训练集和测试集。对每一个划分，用训练集训练分类器或模型，用测试集评估预测的精确度。进行多次划分，用均值来表示效能。

优点：与k倍交叉验证相比，这种方法的与k无关。

缺点：有些数据可能从未做过训练或测试数据；而有些数据不止一次选为训练或测试数据。

2. K倍交叉验证（K>=2）

将样本数据集随机划分为K个子集（一般是均分），将一个子集数据作为测试集，其余的K-1组子集作为训练集；将K个子集轮流作为测试集，重复上述过程，这样得到了K个分类器或模型，并利用测试集得到了K个分类器或模型的分类准确率。用K个分类准确率的平均值作为分类器或模型的性能指标。10-倍交叉证实是比较常用的。
优点：每一个样本数据都即被用作训练数据，也被用作测试数据。避免的过度学习和欠学习状态的发生，得到的结果比较具有说服力。

3. 留一法交叉验证

假设样本数据集中有N个样本数据。将每个样本单独作为测试集，其余N-1个样本作为训练集，这样得到了N个分类器或模型，用这N个分类器或模型的分类准确率的平均数作为此分类器的性能指标。

优点：每一个分类器或模型都是用几乎所有的样本来训练模型，最接近样本，这样评估所得的结果比较可靠。实验没有随机因素，整个过程是可重复的。

缺点：计算成本高，当N非常大时，计算耗时。

训练集和测试集的选取

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特征，并进一步对其进行细化研究。

模型状态判断(欠拟合or过拟合)

当我们不断地丰富特征时，模型对训练集拟合越来越好，有可能同时在丧失泛华能力，对测试集变现不佳，存在过拟合问题。而我们最终的目的是希望我们训练的出来的模型，不仅能对训练数据集有很好的预测效果，更希望它对测试数据集也有很好的预测效果。过拟合问题是机器学习建模过程中常见的问题。


实际上，如果模型在测试集上表现不佳，除了过拟合问题，也有可能出现欠拟合问题，也就是说在训练集上，其实拟合的也不是那么好。

什么是欠拟合/过拟合

举个来说：

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

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

经典解释

解释1
解释2

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

如何处理过拟合

对过拟合而言，通常以下策略对结果优化是有用的：

1. 进行特征选择，挑出较好的特征的子集进行训练。
2. 提供更多的数据，从而弥补原始数据的bias问题，学习到的模型也会更准确。

如何处理欠拟合

通常需要增加更多的特征，使模型变得更复杂来提高准确度。

如何判断模型状态

著名的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，神经网络)，那我们让他们都分别去做判定，然后对结果做投票统计，取票数最多的结果为最后结果。

模型融合的作用

模型融合可以比较好地缓解，训练过程中产生的过拟合问题，从而对于结果的准确度提升有一定的帮助。

问题15：模型融合实现：将逻辑回归和随机森林进行模型融合

思考题：

到目前为止，我们只实现了逻辑回归一个模型，这是时候如果我们想利用模型融合的思路提高模型的预测准确率，我们应该怎么做呢？

思路：

如果模型出现过拟合，一定是在我们的训练上出现拟合过度造成的对吧。

那我们干脆就不要用全部的训练集，每次取训练集的一个subset，做训练，这样，我们虽然用的是同一个机器学习算法，但是得到的模型却是不一样的；同时，因为我们没有任何一份子数据集是全的，因此即使出现过拟合，也是在子训练集上出现过拟合，而不是全体数据上，这样做一个融合，可能对最后的结果有一定的帮助。这就是常用的方法之一Bagging。

Bagging:

Bagging的特点在于随机采样，随机采样(bootsrap)就是从我们的训练集里面采集固定个数的样本，每采集一个样本后，都将样本放回，是有放回的随机抽样。

sklearn.ensemble.BaggingRegressor官方文档说明 回归器组合

sklearn.ensemble.BaggingClassifier官方文档说明 用于分类器组合


两个结果预测准确性效果差别很大，BaggingClassifier的结果更好一些，比最初的81.71提高了0.33.

代码参考如下：

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)

其他算法实现

实际上，除逻辑回归算法外，我们有60多个算法供我们选择。然而我们应该如何思考，今儿选择合适的算法进行尝试呢？

我们还可以使用mlxtend中的其他工具进行模型融合。

可以解决问题的算法

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


问题界定：

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

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

随机森林算法的特征工程

实际上，放入随机森林中的特征，只要根据上面特征工程部分进行相同的处理，最后一步不进行one-hot编码即可。在这里我们就不再给出具体代码了。

模型部分的代码实现参考

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

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

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中已经有了成熟的实现。

模型比较

我们将上面所有的模型结果进行排序，选择一个分数最高的模型作为最终预测结果。
决策树和随机森林的得分一样，我们最终选择随机森林，因为它也刚好修正了决策树对于训练集的过拟合问题。

models = pd.DataFrame({
    'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression', 
              'Random Forest', 'Naive Bayes', 'Perceptron', 
              'Stochastic Gradient Decent', 'Linear SVC', 
              'Decision Tree'],
    'Score': [acc_svc, acc_knn, acc_log, 
              acc_random_forest, acc_gaussian, acc_perceptron, 
              acc_sgd, acc_linear_svc, acc_decision_tree]})
models.sort_values(by='Score', ascending=False)

问题17：实现逻辑回归以外的其他算法

到这里，我们把解决Titanic数据集问题的思路，全部带领同学们过了一遍。希望大家可以把除了逻辑回归以外的其他模型，都认真地自己动手实现一遍，以更好的理解每一个算法和使用机器学习解决问题中需要应对的问题和处理的方法。

集成学习

sgd作为基学习器

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

神经网络作为基学习器

from sklearn.neural_network import MLPClassifier

sreg = StackingClassifier(verbose=2,classifiers=[xgb,decision_tree,gbdt,random_forest,pipe_sgd],
                          meta_classifier=MLPClassifier(solver='lbfgs', alpha=1e-5,
                     hidden_layer_sizes=(8,4,4),learning_rate="invscaling",random_state=1))

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=5, 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.9162    0.8733    0.8942       576
           1     0.7865    0.8540    0.8189       315

    accuracy                         0.8664       891
   macro avg     0.8514    0.8636    0.8565       891
weighted avg     0.8704    0.8664    0.8676       891

0.22000066108562064

输出预测结果

submission = pd.DataFrame({
        "PassengerId": test_df["PassengerId"],
        "Survived": Y_pred
    })
submission.to_csv('../input/submission.csv', index=False)

总结