泰坦尼克号生存预测
学习
机器学习之特征工程
使用sklearn做单机特征工程
参考
kaggle 泰坦尼克号生存预测——六种算法模型实现与比较
Kaggle初体验-机器学习之泰坦尼克号乘客生存预测(上)
猴子数据分析之泰坦尼克号生存率预测
数据集：https://www.kaggle.com/c/titanic
字段
Age:年龄
Cabin:船舱号
Embarked:登船港口 C为Cherbourg Q为Queenstown S为Southampton
Fare:船票费用
Name:姓名
Parch:在船上的父母/孩子人数
PassengerId:乘客编号
Pclass:船票等级 1为一等舱 2为二等舱 3为三等舱
Sex:性别
Sibsp:在船上的兄弟姐妹人数
Ticket:船票编号
Survived:生存与否 预测值
导入数据
import warnings
warnings.filterwarnings('ignore')
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style='darkgrid',font_scale=1.5)
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = Falsetrain = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')
print ('训练数据集:',train.shape,'测试数据集:',test.shape)训练数据集: (891, 12) 测试数据集: (418, 11)#合并数据集 方便同时对两个数据集进行清洗
full = train.append(test,ignore_index=True)
数据清洗
缺失值统计
full.isnull().sum()
年龄 船舱的缺失数据较多
登船港口 船票价格的缺失数据较少
Survived的缺失是合并后的测试集
缺失值处理
很多机器学习算法为了训练模型，要求传入的特征中不能有空值：
1、如果是数值类型，用平均值代替
2、如果是分类数据，用最常见的类别取代
3、使用KNN等模型预测缺失值
#年龄缺失值处理
full['Age'] = full['Age'].fillna(full['Age'].mean())
#船票缺失值处理
full['Fare'] = full['Fare'].fillna(full['Fare'].mean())#embarked&cabin为字符串列
#查看最常见的港口类别
full['Embarked'].value_counts()
#用最常见的类别填充
full['Embarked'] = full['Embarked'].fillna('S')
#查看最常见的船舱类别
full['Cabin'].value_counts()
#缺失数据过多，且不同船舱号的数量差距不大
#船舱号（Cabin）缺失值填充为U，表示未知（Uknow）
full['Cabin'] = full['Cabin'].fillna( 'U' )
特征分析
相关系数矩阵
corr = train.corr()
#热度图可视化相关系数矩阵 只显示数字之间的
plt.subplots(figsize=(10,4)) # 可以先试用plt设置画布的大小，然后在作图，修改
sns.heatmap(corr, annot = True) # 使用热度图可视化这个相关系数矩阵
绝对值排序为pclass fare parch age sibsp passengerid
pclass 社会阶层
sns.countplot(x='Pclass',hue='Survived',data=train)
船舱等级为一等舱的乘客生存几率较高 pclass与生存率有关
sex 性别
sns.countplot(x='Sex',hue='Survived',data=train)
女性生存几率较高 女士优先原则 性别与生存率有关
age 年龄
train_age = sns.FacetGrid(train, col='Survived',height=5)
train_age.map(plt.hist, 'Age', bins=40)
fig = plt.figure(figsize=(10, 6))
sns.violinplot( x='Survived',y='Age', data=train,
split=True,palette={0: "r", 1: "g"} )
plt.title('乘客年龄与存活关系')
plt.ylabel('年龄')
年龄较小的乘客生存率较高，年龄较大的次之，20-40岁的青壮年明显生存率较低
符合儿童优先原则 年龄与生存率相关
sibsp 兄弟姐妹数
sns.countplot(x='SibSp',hue='Survived',data=train)
=0生存率低 1-2较高 >3低
parch 父母子女数
sns.countplot(x='Parch',hue='Survived',data=train)
=0生存率低 1-2较高 >3低
家庭成员数
sibsp与parch的分布相似 可结合起来看家庭成员数
家庭人数 ＝ Parch兄弟姐妹数+SibSp父母子女数+自己
train['members'] = train['Parch'] + train['SibSp']
sns.countplot(x='members',hue='Survived',data=train)
=0生存率低 1-3较高 >4低
fare 船票价格
train['Fare'].describe()
train_fare = sns.FacetGrid(train, col='Survived',height=5)
train_fare.map(plt.hist, 'Fare', bins=5)
#train_fare.set(xticks=[0,600])
# 按船舱等级分组
train.groupby('Pclass').agg('mean')['Fare'].plot(kind='bar', figsize=(10,6))
plt.title('船舱等级与船票价格关系')
plt.xlabel('船舱等级')
plt.ylabel('平均船票价格')
船票价格高-船舱等级高-与生存率有关
cabin 船舱编号
#有编号的的为y,没有的为n
train['Cabin']=train['Cabin'].map(lambda x:'y' if type(x)==str else 'n')
sns.countplot(x="Cabin", hue="Survived", data=train)
有编号的存活率更高【为啥？难道因为船员没编号？但这不是乘客名单吗 船还有无座的？
embarked 上船港口
sns.countplot(x="Embarked", hue="Survived", data=train)
C港口上船的存活率更高【这又是为啥 难道这个港口上船的人比较有钱？
特征提取
查看数据类型，将其分为三类
对类别数据进行处理：用数值代替类别，并进行one-hot编码
full.info()
1、数值类型：
乘客编号（PassengerId），年龄（Age），船票价格（Fare），同代直系亲属人数（SibSp），不同代直系亲属人数（Parch）
2、时间序列：无
3、分类数据：
1）有直接类别的
乘客性别（Sex）：男性male，女性female
登船港口（Embarked）：出发地点S=英国南安普顿Southampton，途径地点1：C=法国 瑟堡市Cherbourg，出发地点2：Q=爱尔兰 昆士敦Queenstown
客舱等级（Pclass）：1=1等舱，2=2等舱，3=3等舱
2）字符串类型：如果可以从这里面提取出特征来，也归到分类数据中
乘客姓名（Name）
客舱号（Cabin）
船票编号（Ticket）
分类数据-有直接类别的
sex 性别
full['Sex'].head()
#将性别的值映射为数值
#male对应1 female对应0
sex_mapDict = {'male':1,'female':0}
full['Sex'] = full['Sex'].map(sex_mapDict)
full['Sex'].head()
embarked 登船港口
full['Embarked'].head()
embarkedDf = pd.DataFrame()#新建
#使用get_dummies进行one-hot编码
#产生虚拟变量（dummy variables），列名前缀是Embarked
embarkedDf = pd.get_dummies(full['Embarked'],prefix='Embarked')
embarkedDf.head()
#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full = pd.concat([full,embarkedDf],axis=1)
#替代原embarked
full.drop('Embarked',axis=1,inplace=True)
full.head()pclass 客舱等级
full['Pclass'].head()
pclass_Df = pd.DataFrame()
pclass_Df = pd.get_dummies(full['Pclass'],prefix='Pclass')
pclass_Df.head()
#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full = pd.concat([full,pclass_Df],axis=1)
#替代原pclass
full.drop('Pclass',axis=1,inplace=True)
full.head()
分类数据-字符串类型
name 姓名
full['Name'].head()
乘客头衔每个名字当中都包含了具体的称谓或者说是头衔
将这部分信息提取出来后可以作为非常有用的一个新变量，可以帮助我们进行预测。
逗号前面的是“名”，逗号后面是‘头衔. 姓’
#定义函数 从姓名中获取头衔
def getTitle(name):
s1 = name.split(',')[1]
s2 = s1.split('.')[0]
s = s2.strip()#移除字符串头尾指定的字符（默认为空格）
return stitleDf = pd.DataFrame()
titleDf['Title'] = full['Name'].map(getTitle)
titleDf.groupby('Title').size()
定义以下几种头衔类别：
Officer政府官员
Royalty王室（皇室）
Mr已婚男士
Mrs已婚妇女
Miss年轻未婚女子
Master有技能的人/教师
#姓名中头衔字符串与定义头衔类别的映射关系
title_mapDict = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Royalty",
"Dona": "Royalty",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master",
"Lady" : "Royalty"
}
#map函数：对Series每个数据应用自定义的函数计算
titleDf['Title'] = titleDf['Title'].map(title_mapDict)
#使用get_dummies进行one-hot编码
titleDf = pd.get_dummies(titleDf['Title'])
titleDf.head()
#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full = pd.concat([full,titleDf],axis=1)
#删掉姓名这一列
full.drop('Name',axis=1,inplace=True)
full.head()
cabin 客舱号
full['Cabin'].head()
客舱号的首字母是客舱的类别
cabinDf = pd.DataFrame()
cabinDf['Cabin'] = full['Cabin'].map(lambda c : c[0])
cabinDf = pd.get_dummies(cabinDf['Cabin'],prefix='Cabin')
cabinDf.head()
full = pd.concat([full,cabinDf],axis=1)
full.drop('Cabin',axis=1,inplace=True)
家庭人数和家庭类别
家庭人数=同代直系亲属数（Parch）+不同代直系亲属数（SibSp）+乘客自己
家庭类别：
小家庭Family_Single：家庭人数=1
中等家庭Family_Small: 2<=家庭人数<=4
大家庭Family_Large: 家庭人数>=5
familyDf = pd.DataFrame()
#家庭人数=同代直系亲属数（Parch）+不同代直系亲属数（SibSp）+乘客自己
familyDf['FamilySize'] = full['Parch'] + full['SibSp'] + 1
#家庭类别
#if 条件为真的时候返回if前面内容，否则返回0
familyDf['Family_Single'] = familyDf['FamilySize'].map(lambda x: 1 if x==1 else 0)
familyDf['Family_Small'] = familyDf['FamilySize'].map(lambda x: 1 if 2 <= x <= 4 else 0)
familyDf['Family_Large:'] = familyDf['FamilySize'].map(lambda x: 1 if x >= 5 else 0)
familyDf.head()
full = pd.concat([full,familyDf],axis=1)
我们获得了33列经过one-hot编码后的数据
full.columns
特征选择
相关系数
corrDf = full.corr()
corrDf['Survived'].sort_values(ascending=False)根据相关系数排序与前面对特征的分析 选择以下特征作为模型输入
full_X = pd.concat([titleDf,#头衔
pclass_Df,#船舱等级
familyDf,#家庭大小
full['Fare'],#船票价格
cabinDf,#船舱号
embarkedDf,#登船港口
full['Sex']#性别
],axis=1)
使用模型
建立训练数据集与测试数据集
使用项目给出的train数据集作为原始数据集source
从source中拆分出训练数据集train用于模型训练 测试数据集test用于模型评估
#原始数据集有891行
sourceRow=891
#从特征集合full_X中提取原始数据集提取前891行数据时，我们要减去1，因为行号是从0开始的。
#原始数据集：特征
source_X = full_X.loc[0:sourceRow-1,:]
#原始数据集：生存标签
source_y = full.loc[0:sourceRow-1,'Survived']
#预测数据集：特征
pred_X = full_X.loc[sourceRow:,:]确保这里原始数据集取的是前891行的数据 以免模型出错
#原始数据集有多少行
print('原始数据集有多少行:',source_X.shape[0])
#预测数据集大小
print('原始数据集有多少行:',pred_X.shape[0])
从原始数据集（source）中拆分出训练数据集（用于模型训练train），测试数据集（用于模型评估test）
train_test_split是交叉验证中常用的函数，功能是从样本中随机的按比例选取train data和test data
train_data：所要划分的样本特征集
train_target：所要划分的样本结果
test_size：样本占比，如果是整数的话就是样本的数量
from sklearn.model_selection import train_test_split
train_X,test_X,train_y,test_y = train_test_split(source_X,source_y,train_size=0.8)
#输出数据集大小
print ('原始数据集特征：',source_X.shape,
'训练数据集特征：',train_X.shape ,
'测试数据集特征：',test_X.shape)
print ('原始数据集标签：',source_y.shape,
'训练数据集标签：',train_y.shape ,
'测试数据集标签：',test_y.shape)
训练模型&预测
例：逻辑回归logistic regression
#第1步：导入算法
from sklearn.linear_model import LogisticRegression
#第2步：创建模型：逻辑回归（logisic regression）
model = LogisticRegression()#第3步：训练模型
model.fit( train_X , train_y )
#分类问题，score得到的是模型的正确率
model.score(test_X , test_y )#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = model.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred.csv' , index = False )高斯朴素贝叶斯Gaussian Naive Bayes
from sklearn.naive_bayes import GaussianNB
#不需要调参
gnb = GaussianNB()
gnb.fit(train_X,train_y)
gnb.score(test_X,test_y)#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = model.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_gaussiannb.csv' , index = False )其他算法通用框架
from sklearn.metrics import make_scorer
from sklearn.metrics import accuracy_score,roc_auc_score
from time import time
from sklearn.model_selection import GridSearchCV#定义通用函数框架
def fit_model(alg,parameters):
X=source_X
y=source_y#由于数据较少，使用全部数据进行网格搜索
scorer=make_scorer(roc_auc_score) #使用roc_auc_score作为评分标准
grid = GridSearchCV(alg,parameters,scoring=scorer,cv=2) #使用网格搜索
start=time()#计时
grid=grid.fit(X,y)
end=time()
t=round(end-start,3)
print (grid.best_params_) #输出最佳参数
print('分数：',grid.best_score_)#查看最佳分数(此处为f1_score)
print ('searching time for {} is {} s'.format(alg.__class__.__name__,t)) #输出搜索时间
return grid #返回训练好的模型#列出需要使用的算法
alg1=DecisionTreeClassifier(random_state=0)
alg2=SVC(probability=True,random_state=0) #由于使用roc_auc_score作为评分标准，需将SVC中的probability参数设置为True
alg3=RandomForestClassifier(random_state=0)
alg4=AdaBoostClassifier(random_state=0)
alg5=KNeighborsClassifier(n_jobs=-1)
alg6=XGBClassifier(random_state=0,n_jobs=-1)
alg7=GradientBoostingClassifier(random_state=0)
#n_jobs 使用电脑的cpu数 -1代表全部使用
#设置random_state使结果能够重现 固定随机性以便调参决策树DecisionTreeClassifier
参数：https://www.cnblogs.com/lyxML/p/9575820.html
from sklearn.tree import DecisionTreeClassifier
#max_depth 树的深度 越深分裂越多 更能捕获有关数据的信息 更容易过拟合 推荐5-20之间
#min_samples_split 拆分内部节点所需最小样本数 样本数量小于此值时节点不再划分
#min_samples_leaf 叶节点所需最小样本数 若叶节点数目小于样本数 则会和兄弟节点一起被剪枝
#max_features 查找最佳拆分时要考虑的最大特征数量 None(所有) log2 sqrt N 特征<50时一般用所有的
#splitter 默认的best适合样本量不大的情况 若样本数量特别大则使用random
parameters1 = {
'max_depth':range(5,20),
'min_samples_split':range(5,10),
'min_samples_leaf':range(1,10)
}
tree = fit_model(alg1,parameters1)
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = tree.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_tree.csv' , index = False )支持向量机Support Vector Machines
参数：https://www.cnblogs.com/solong1989/p/9620170.html
from sklearn.svm import SVC, LinearSVC
#C 惩罚系数 即对误差的宽容度 C越高表示越不能容忍出现误差 容易过拟合 C太小 容易欠拟合
#gamma 越大支持向量越少 过拟合 越小支持向量越多 欠拟合 影响训练和预测的速度
parameters2 = {
'C':range(1,20),
'gamma':np.arange(0.01,0.3)
}
svm = fit_model(alg2,parameters2)
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = svm.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_svm.csv' , index = False )随机森林Random Forests Model
参数：
https://www.cnblogs.com/baby-lily/p/10657185.html
https://blog.csdn.net/R18830287035/article/details/89257857
from sklearn.ensemble import RandomForestClassifier
#n_estimators 树的数量 理论上越多子树模型性能越好 但会变慢 选择尽可能高的值
#max_features 随机森林允许单个决策树使用特征的最大数量 None(所有) log2 sqrt 0.2 特征<50时一般用所有的
parameters3 = {
'n_estimators':range(30,200,5)
}
forest = fit_model(alg3,parameters3)
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = forest.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_forest.csv' , index = False )Adaboost
参数：https://www.cnblogs.com/mdevelopment/p/9445090.html
from sklearn.ensemble import AdaBoostClassifier
#base_estimator 基分类器 默认为决策树
#n_estimators 基分类器循环次数 默认为50次 过大模型会过拟合
#learning_rate 学习率 梯度收敛速度，默认为1，如果过大，容易错过最优值，如果过小，则收敛速度会很慢；
# 该值需要和n_estimators进行一个权衡，当分类器迭代次数较少时，学习率可以小一些，当迭代次数较多时，学习率可以适当放大。
#可以调整基分类器的参数
parameters4 = {
'n_estimators':range(10,200,5),
'learning_rate':np.arange(0.5,2,0.1)
}
adaboost = fit_model(alg4,parameters4)
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = adaboost.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_adaboost.csv' , index = False )KNN K-nearest neighbors
参数：https://blog.csdn.net/qq_40195360/article/details/86714337
内存不足 分两次调参
from sklearn.neighbors import KNeighborsClassifier
#n_neighbors k值 默认为5 k值较小 训练误差&偏差小 泛化误差&方差大 欠拟合 较大过拟合
#weights 样本的近邻样本的权重 可选择uniform都一样/distance权重距离反比例/自定义
# 若样本成簇 则用默认的uniform 若样本分布较乱 则可以用distance
#leaf_size 控制使用kd树/球树时 停止建子树的叶节点数量 越小层数越深 随样本数量增加而增加 否则容易过拟合
parameters5 = {
'n_neighbors':range(2,10),
'leaf_size':range(10,100,10)
}
knn = fit_model(alg5,parameters5)
knn_1 = KNeighborsClassifier(weights='distance',n_neighbors=7,leaf_size=10)
knn_1.fit(source_X,source_y)
print(knn_1.score(source_X,source_y))
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = knn_1.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_knn_1.csv' , index = False )Xgboost
参数：
https://www.cnblogs.com/tan2810/p/11154708.html
https://blog.csdn.net/weixin_41580067/article/details/86514402
https://www.cnblogs.com/TimVerion/p/11436001.html
https://www.jianshu.com/p/7aab084b7f47
from xgboost.sklearn import XGBClassifier
#n_estimators 基分类器循环次数 默认为100
#一般参数 取决于提升器，通常是树或线性模型
#提升参数 取决于选择的提升器的相关参数
#learning_rate学习率 [0,1] 默认为0.3
#gamma 控制叶子 默认为0 该参数越大 越不容易过拟合
#max_depth 每棵树的最大深度 默认为6 越大越容易过拟合
#min_child_weight 每个叶子的最小权重和 默认为1 越大越不易过拟合
#subsample 样本采样比率 (0,1] 默认为1
#colsample_bytree 列采样比率 (0,1] 默认为1 对每棵树生成用的特征进行列采样
#lambda 正则化参数 >=0 默认为1 越大越不易过拟合
#alpha 正则化参数 >=0 默认为1 越大越不易过拟合
#学习参数 取决于指定学习任务和相应的学习目标
#内存不足 分四次调参
parameters6_1 = {
'n_estimators':range(10,200,5),
# 'max_depth':range(5,20),
# 'min_child_weight':range(2,10),
# 'subsample':np.arange(0.1,1,0.1),
# 'colsample_bytree':np.arange(0.1,1,0.1),
# 'reg_lambda':np.arange(0.2,2,0.1),
# 'reg_alpha':np.arange(0.2,2,0.1)
}
xgb1 = fit_model(alg6,parameters6_1)
parameters6_2 = {
'max_depth':range(2,20),
'min_child_weight':range(2,10),
}
alg6=XGBClassifier(n_estimators=15,random_state=0,n_jobs=-1)
xgb2 = fit_model(alg6,parameters6_2)
parameters6_4 = {
'reg_lambda':np.arange(0.2,2,0.1),
'reg_alpha':np.arange(0.2,2,0.1)
}
alg6=XGBClassifier(n_estimators=15,max_depth=5,min_child_weight=7,random_state=0,n_jobs=-1)
xgb4 = fit_model(alg6,parameters6_4)
在调subsample和colsample_bytree的时候发现score反而下降 就算了
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = xgb4.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_xgb.csv' , index = False )Gradient Boosting Classifier
参数：
https://blog.csdn.net/RuDing/article/details/78332192
https://blog.csdn.net/han_xiaoyang/article/details/52663170
from sklearn.ensemble import GradientBoostingClassifier
#初始值
parameters7_1 = {
'n_estimators':range(10,200,5)
}
gbc1 = fit_model(alg7,parameters7_1)
#先调整对结果影响较大的参数
#max_depth min_samples_split
parameters7_2 = {
'max_depth':range(2,20),
'min_samples_split':(5,10)
}
alg7=XGBClassifier(n_estimators=20,random_state=0,n_jobs=-1)
gbc2 = fit_model(alg7,parameters7_2)
#min_samples_leaf
parameters7_3 = {
'min_samples_leaf':(10,100,5)
}
alg7=XGBClassifier(max_depth=5,min_samples_split=5,n_estimators=20,random_state=0,n_jobs=-1)
gbc3 = fit_model(alg7,parameters7_3)
#max_features
parameters7_4 = {
'max_features':(2,100,5)
}
alg7=XGBClassifier(min_samples_leaf=10,max_depth=5,min_samples_split=5,n_estimators=20,random_state=0,n_jobs=-1)
gbc4 = fit_model(alg7,parameters7_4)
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = gbc4.predict(pred_X)
'''
生成的预测值是浮点数（0.0,1,0）
但是Kaggle要求提交的结果是整型（0,1）
所以要对数据类型进行转换
'''
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred_gbc.csv' , index = False )
预测结果
总结
再 次 入 门
1、熟悉常用模型&基本原理
2、学习调参姿势