分析目的

“你幸福吗”，“我姓福”。努力的意义究其根本就是为了获取幸福感，让自己愉悦。当阴雨连绵之后的太阳你会觉得幸福，拿到第一份工资会觉得幸福，与幸福感相关的因素成千上万、因人而异，每个人对幸福感都有自己的衡量标准，影响幸福感的因素主要会是什么呢，什么样的人幸福感更强呢？是否能预测出每个人的幸福值呢？

一、数据采集

1、 数据来源

数据来自于阿里云天池，下载链接：一起挖掘幸福感

2、 数据说明

考虑到变量个数较多，部分变量间关系复杂，数据分为完整版和精简版两类。可从精简版入手熟悉赛题后，使用完整版挖掘更多信息。complete文件为变量完整版数据，abbr文件为变量精简版数据。
index文件中包含每个变量对应的问卷题目，以及变量取值的含义。
survey文件是数据源的原版问卷，作为补充以方便理解问题背景。

二、数据传输

将数据导入到PYTHON软件：

train = pd.read_csv('D:\A\幸福感\happiness_train_complete.csv',encoding='ISO-8859-1')
test = pd.read_csv('D:\A\幸福感\happiness_test_complete.csv',encoding='ISO-8859-1')
test_sub=pd.read_csv('D:\A\幸福感\happiness_submit.csv',encoding='ISO-8859-1')

三、数据处理

1、查看数据

#查看数据有多少行，多少列
print(train.shape, test.shape)

输出结果：(8000, 140) (2968, 139)，即训练集8000行，140列，测试集2968行，139列。

2、缺失值处理

#查看缺失值
train.info(verbose=True,null_counts=True)

根据结果，一共有8000行数据，其中float型数据25个, int型111个, object型4个。在这些数值型数据中，有很多是实际上是分类数据，原数据集通过对其编码变成了数值型数据。对于分类型数据，将进行One-hot编码后再分析。
family_income有1条数据缺失。
而work_status,work_type, work_manage,work_yr列的数据缺失非常大。缺失较大的进行删除操作，少量缺失则用频繁出现数填充。

#列名class为Python保留字，要改名，不然在操作中很可能报错
train.rename(columns={'class': 'Class'}, inplace=True)
#列nationality为-8的值，将其替换为8表示其他。
train['nationality'] =train.nationality.replace(-8, 8)
#列religion和religion_freq为-8的值，将其替换为最频繁出现的值1。
train['religion'] = train.religion.replace(-8, 1)
train['religion_freq'] =train.religion_freq.replace(-8, 1)
#列religion和religion_freq为-8的值，将其替换为最频繁出现的值1。
train['religion'] = train.religion.replace(-8, 1)
train['religion_freq'] = train.religion_freq.replace(-8, 1)
#将income列为-1，-2，-3的值，先替换为空值，再用平均值替换
train['income'] = train.income.replace([-1, -2, -3], np.nan)
train['income'] =train.income.replace(np.nan, train['income'].mean())
#列nationality为-8的值，将其替换为最频繁出现的值1。
train['political'] = train.political.replace(-8, 1)
#列health，health_problem为-8的值，将其替换为3，表示一般。
train['health'] =train.health.replace(-8, 3)
train['health_problem'] = train.health_problem.replace(-8, 3)
#列depression为-8的值，将其替换为3，表示一般。
train['depression'] = train.depression.replace(-8, 3)
#列socialize，relax，learn为-8的值，将其替换为3，表示有时。
train['socialize'] = train.socialize.replace(-8, 3)
train['relax'] =train.relax.replace(-8, 3)
train['learn'] = train.learn.replace(-8, 3)
#列equity为-8的值，将其替换为3，表示中间态度。
train['equity'] = train.equity.replace(-8, 3)
#列class为-8的值，将其替换为最频繁出现的5。
train['Class'] = train.Class.replace(-8, 5)
#将family_income列为-1，-2，-3的值，先替换为空值，再用平均值替换
train['family_income'] = train.family_income.replace([-1, -2, -3], np.nan)
train['family_income'] = train.family_income.replace(np.nan, train['family_income'].mean())
#将family_m列为-1，-2，-3的值，替换为1
train['family_m'] = train.family_m.replace([-1, -2, -3], 1)
#列family_status为-8的值，将其替换为3，表示平均水平
train['family_status'] = train.family_status.replace(-8, 3)
#将house列为-1，-2，-3的值，替换为0
train['house'] = train.house.replace([-1, -2, -3], 0)
#将car列为-8的值，替换为最频繁出现的2
train['car'] = train.car.replace(-8, 2)
#将status_peer，status_3_before，view列为-8的值，替换为差不多（一般）
train['status_peer'] = train.status_peer.replace(-8, 2)
train['status_3_before'] = train.status_3_before.replace(-8, 2)
train['view'] = train.view.replace(-8, 3)
#inc_ability缺失值过多，将inc_ability列为-8的值，替换为0
train['inc_ability'] = train.inc_ability.replace(-8, 0)
#查看happiness的label分布
y_train_=train["happiness"]
y_train_.value_counts()
#将happiness列为-8的值，替换为3 "说不上幸福不幸福"
y_train_=y_train_.map(lambda x:3 if x==-8 else x)
train=train.drop(['work_status'，'work_type','work_manage','work_yr'], axis=1)

3、合并数据集

合并数据集，方便同时对两个数据集进行清洗

data= train.append(test, ignore_index = True, sort=False)
print (data.shape)

4、时间数据处理

规范时间格式：

data['survey_time'] = pd.to_datetime(data['survey_time'],format='%Y-%m-%d %H:%M:%S')
data["year"]=data["survey_time"].dt.year
data["quarter"]=data["survey_time"].dt.quarter
data["month"]=data["survey_time"].dt.month
data["weekday"]=data["survey_time"].dt.weekday
data["hour"]=data["survey_time"].dt.hour

时间分段：

#把一天的时间分段
def hour_cut(x):if 0<=x<6:return 0elif  6<=x<8:return 1elif  8<=x<12:return 2elif  12<=x<14:return 3elif  14<=x<18:return 4elif  18<=x<21:return 5elif  21<=x<24:return 6   
data["hour_cut"]=data["hour"].map(hour_cut)

做问卷调查时的年龄：

data["survey_age"]=data["year"]-data["birth"]

出生的年代：

#出生的年代
def birth_split(x):if 1920<=x<=1930:return 0elif  1930<x<=1940:return 1elif  1940<x<=1950:return 2elif  1950<x<=1960:return 3elif  1960<x<=1970:return 4elif  1970<x<=1980:return 5elif  1980<x<=1990:return 6elif  1990<x<=2000:return 7
data["birth_s"]=data["birth"].map(birth_split)

5、分组及One-hot编码处理

分组处理：

#收入分组
def income_cut(x):if x<0:return 0elif  0<=x<1200:return 1elif  1200<x<=10000:return 2elif  10000<x<24000:return 3elif  24000<x<40000:return 4elif  40000<=x:return 5   
data["income_cut"]=data["income"].map(income_cut)
#对教育程度分组，将分组结果放在edu_group字段
bins = [0, 3, 4, 8, 12, 13, 14]
eduLabels = [1, 2, 3, 4, 5, 6]
data['edu_group'] = pd.cut(data.edu,bins,labels=eduLabels)
#分类的标签不能重复，edu_group值为6的换乘1
data['edu_group'] = data.edu_group.replace(6, 1)
#受教育层次edu_group
edu_groupDf = pd.DataFrame()
#使用get_dummies进行one-hot编码，列名前缀是edu_group
edu_groupDf = pd.get_dummies( data['edu_group'] , prefix='edu_group' )

One-hot编码处理：
对于分类数据，用One-hot编码，产生虚拟变量（dummy variables），都用0-1表示。
edu的选项比较多，有14种，要对其分组后再做比较。
分如下成几组
1.小学及其他，包括原数据中的1，2，3，14
2.初中，对应原数据中的4
3.高中，对应原数据中的5，6，7，8
4.大学，对应原数据中的9，10，11，12
5.研究生，对应原数据中的13

#political政治面貌
politicalDf = pd.DataFrame()
politicalDf = pd.get_dummies(data['political'] , prefix='political' )
#health健康状况
healthDf = pd.DataFrame()
healthDf = pd.get_dummies( data['health'] , prefix='health' )
#health_problem健康问题的影响
health_problemDf = pd.DataFrame()
health_problemDf = pd.get_dummies( data['health_problem'] , prefix='health_problem' )
#depression心情抑郁
depressionDf = pd.DataFrame()
depressionDf = pd.get_dummies( data['depression'] , prefix='depression' )
#hukou户口
hukouDf = pd.DataFrame()
hukouDf = pd.get_dummies( data['hukou'] , prefix='hukou' )
#socialize社交
socializeDf = pd.DataFrame()
socializeDf = pd.get_dummies( data['socialize'] , prefix='socialize' )
#relax放松
relaxDf = pd.DataFrame()
relaxDf = pd.get_dummies( data['relax'] , prefix='relax' )
#learn学习
learnDf = pd.DataFrame()
learnDf = pd.get_dummies( data['learn'] , prefix='learn' )
#equity公平
equityDf = pd.DataFrame()
equityDf = pd.get_dummies( data['equity'] , prefix='equity' )
#Class等级
ClassDf = pd.DataFrame()
ClassDf = pd.get_dummies( data['Class'] , prefix='Class' )
#work_exper工作经历
work_experDf = pd.DataFrame()
work_experDf = pd.get_dummies( data['work_exper'] , prefix='work_exper' )
#family_status家庭经济状况
family_statusDf = pd.DataFrame()
family_statusDf = pd.get_dummies( data['family_status'] , prefix='family_status' )
#car是否拥有小汽车，转变成0=没有，1=有
data['car'] = data.car.replace(2, 0)
#marital婚姻状况
maritalDf = pd.DataFrame()
maritalDf = pd.get_dummies( data['marital'] , prefix='marital' )
#status_peer经济社会地位
status_peerDf = pd.DataFrame()
status_peerDf = pd.get_dummies( data['status_peer'] , prefix='status_peer' )
#status_3_before，3年来社会经济地位的变化
status_3_beforeDf = pd.DataFrame()
status_3_beforeDf = pd.get_dummies( data['status_3_before'] , prefix='status_3_before' )
#view观点
viewDf = pd.DataFrame()
viewDf = pd.get_dummies( data['view'] , prefix='view' )
#inc_ability收入合理性
inc_abilityDf = pd.DataFrame()
inc_abilityDf = pd.get_dummies( data['inc_ability'] , prefix='inc_ability' )
#删除空值的列
inc_abilityDf.drop('inc_ability_0',axis=1,inplace=True)

四、数据分析

1、描述性统计

data.happiness.describe()

幸福感的均值为3.87，表明总体上幸福强。25%百分位数为4，表明有超过四分之三的受访者对幸福感给出4分或5分，觉得不幸福的人数不多。

happiness_count =data.groupby(['happiness'], as_index=False).id.agg('count')
print(happiness_count)

国民幸福度都较高，但这也只是一部分不能代表整体。给出一分两分的也有，可跟踪为什么给出极值的人员，找出原因。

#展示整体人群的幸福状况，各选项选择的人数
happiness_count =data.groupby(['happiness'], as_index=False).id.agg('count')
print(happiness_count)
#将结果绘图，分别用饼图和柱状图展示。
fig = plt.figure(figsize=(10, 5))
font = matplotlib.font_manager.FontProperties(size=13)
ax1 = fig.add_subplot(1, 2, 1)
plt.pie(happiness_count.id,labels=['1', '2', '3', '4', '5'],autopct='%.1f%%',textprops={'fontproperties': font},radius=1.2)
plt.title('觉得比较幸福的人占6成', size=13)
ax2 = fig.add_subplot(1, 2, 2)
plt.bar(happiness_count['happiness'], happiness_count['id'],color=['g', 'y', 'r', 'c', 'm'])
plt.xticks(size=13)
plt.yticks(size=13)
plt.xlabel('1 = 非常不幸福; 2 = 比较不幸福; 3 = 说不上幸福不幸福; 4 = 比较幸福; 5 = 非常幸福')
plt.title('整体人群的幸福状况', size=13)
plt.subplots_adjust(wspace=0.5)

2、探索性分析

1 是否与所在地是城市or农村有关

#查看城乡幸福感的平均情况
survey_type_mean = data.groupby(['survey_type']).happiness.mean()
print(survey_type_mean)
survey_type_result = data.pivot_table(values='id',index='happiness',columns='survey_type',aggfunc='count')
survey_type_result

总体上城市的幸福感比农村高，可能是城市娱乐设施多，比较热闹，且城市相对富裕没什么压力。但总体上两者差距不是很大。

#用频数不容易比较相对百分比，所以要将组百分比归一化为1。
survey_type_result[0] = survey_type_result[0] / survey_type_result[0].sum()
survey_type_result[1] = survey_type_result[1] / survey_type_result[1].sum()
print(survey_type_result)
bar_width=0.4
plt.bar(x=survey_type_result.index - 0.5 * bar_width, height=survey_type_result[0], label='农村', width=bar_width)
plt.bar(x=survey_type_result.index + 0.5 * bar_width, height=survey_type_result[1], label='城市', width=bar_width)
plt.title('城乡幸福感对比', size=15)
plt.ylabel('比例')
plt.xlabel('1 = 非常不幸福; 2 = 比较不幸福; 3 = 说不上幸福不幸福; 4 = 比较幸福; 5 = 非常幸福')
plt.legend()
plt.show()

2 是否与性别有关

#查看男性、女性幸福感的平均情况
gender_mean = data.groupby(['gender']).happiness.mean()
print(gender_mean)
gender_result = data.pivot_table(values='id',index='happiness',columns='gender',aggfunc='count')
gender_result

在给出三分四分的人数里，男性幸福度比较高，而一分两分五分则是女性比较高。出现这一现象的原因可能是女性目前的社会地位造成及心理承受压力等。但总体上男性与女性幸福感的差异不明显。

#转换成百分比
gender_result[0] = gender_result[0] / gender_result[0].sum()
gender_result[1] = gender_result[1] / gender_result[1].sum()
print(gender_result)
bar_width=0.4
plt.bar(x=gender_result.index - 0.5 * bar_width, height=gender_result[0], label='女', width=bar_width)
plt.bar(x=gender_result.index + 0.5 * bar_width, height=gender_result[1], label='男', width=bar_width)
plt.title('性别幸福感对比', size=15)
plt.ylabel('比例')
plt.xlabel('1 = 非常不幸福; 2 = 比较不幸福; 3 = 说不上幸福不幸福; 4 = 比较幸福; 5 = 非常幸福')
plt.legend()
plt.show()

3 是否与年龄有关

首先对样本的年龄进行分类，分成5个年龄段。按照20%, 40%, 60%, 80%百分位数设置阈值，这样使每个组的样本数大致相等。

data.survey_age.describe(percentiles=[0.2, 0.4, 0.6, 0.8])
#对年龄分组，将分组结果放在age_group字段
bins = [17, 33, 45, 54, 65, 100]
ageLabels = ['33岁及以下', '34-45岁', '46-54岁', '55-65岁', '66岁及以上']
data['age_group'] = pd.cut(data.survey_age,bins,labels=ageLabels)
#查看各年龄层次幸福感的平均情况
age_mean = data.groupby(['age_group']).happiness.mean()
print(age_mean)
#各年龄段对幸福感评价的分布情况
age_result =data.pivot_table(values='id',index='happiness',columns='age_group',aggfunc='count')
age_result

感觉非常幸福的比例，66岁以上年龄段最多，33岁以下年龄段其次，46-54岁年龄段最少。感觉比较不幸福和非常不幸福，46-54岁年龄段的比例最大。老年人有更多的幸福感，年轻人的幸福感也相对较高，中年人的幸福感低。各个年龄段幸福感呈现先降后升的态势。

data.survey_age.describe(percentiles=[0.2, 0.4, 0.6, 0.8])
#对年龄分组，将分组结果放在age_group字段
bins = [17, 33, 45, 54, 65, 100]
ageLabels = ['33岁及以下', '34-45岁', '46-54岁', '55-65岁', '66岁及以上']
data['age_group'] = pd.cut(data.survey_age,bins,labels=ageLabels)
#查看各年龄层次幸福感的平均情况
age_mean = data.groupby(['age_group']).happiness.mean()
print(age_mean)
#各年龄段对幸福感评价的分布情况
age_result =data.pivot_table(values='id',index='happiness',columns='age_group',aggfunc='count')
print(age_result)
bar_width=0.17
plt.bar(x=age_result.index - 2 * bar_width, height=age_result['33岁及以下'], label='33岁及以下', width=bar_width)
plt.bar(x=age_result.index - 1 * bar_width, height=age_result['34-45岁'], label='34-45岁', width=bar_width)
plt.bar(x=age_result.index, height=age_result['46-54岁'], label='46-54岁', width=bar_width)
plt.bar(x=age_result.index + 1 * bar_width, height=age_result['55-65岁'], label='55-65岁', width=bar_width)
plt.bar(x=age_result.index + 2 * bar_width, height=age_result['66岁及以上'], label='66岁及以上', width=bar_width)
plt.title('年龄幸福感对比', size=15)
plt.ylabel('比例')
plt.xlabel('1 = 非常不幸福; 2 = 比较不幸福; 3 = 说不上幸福不幸福; 4 = 比较幸福; 5 = 非常幸福')
plt.legend()
plt.show()

4 是否与经济收入地位有关

#查看社会经济地位不同的群体幸福感的平均情况
status_peer_mean =data.groupby(['status_peer']).happiness.mean()
print(status_peer_mean)
#社会经济地位与幸福感的数据透视表
status_peer_result = data.pivot_table(values='id',index='happiness',columns='status_peer',aggfunc='count')
status_peer_result

与同龄人相比，认为自身经济社会地位较高的人，有34.2%的认为非常幸福，有60.8%的认为比较幸福，这一群体的幸福感也高。认为自身经济社会地位与同龄人相比较低的人，更多地感到不幸福。

#转换成百分比
status_peer_result[1] = status_peer_result[1] / status_peer_result[1].sum()
status_peer_result[2] = status_peer_result[2] / status_peer_result[2].sum()
status_peer_result[3] = status_peer_result[3] / status_peer_result[3].sum()
print（status_peer_result）
bar_width=0.25
plt.bar(x=status_peer_result.index - 1 * bar_width, height=status_peer_result[1], label='较高', width=bar_width)
plt.bar(x=status_peer_result.index, height=status_peer_result[2], label='差不多', width=bar_width)
plt.bar(x=status_peer_result.index + 1 * bar_width, height=status_peer_result[3], label='较低', width=bar_width)
plt.title('对自身经济社会地位的评价与幸福感', size=15)
plt.ylabel('比例')
plt.xlabel('1 = 非常不幸福; 2 = 比较不幸福; 3 = 说不上幸福不幸福; 4 = 比较幸福; 5 = 非常幸福')
plt.legend()
plt.show()

5 是否与受教育程度有关

#查看各学历层次幸福感的平均情况
edu_mean = data.groupby(['edu_group']).happiness.mean()
print(edu_mean)
#各学历层次对幸福感评价的分布情况
edu_result = data.pivot_table(values='id',index='happiness',columns='edu_group',aggfunc='count')
edu_result

从幸福感评价的均值来看，受教育程度越高幸福感越高。在评价比较幸福和非常幸福的人群中，受教育程度越高的群体比例越高（但存在一个例外是小学文化的人感觉非常幸福的比例比初中文化的高）。而在评价“"说不上幸福不幸福”、“比较不幸福”、“非常不幸福”的人群中，受教育程度越低的的群体比例越高。可以看出，接受更多的教育，能使幸福感显著提升。或者说，受教育程度高的人幸福感更强。

#转换成百分比
edu_result[1] = edu_result[1] / edu_result[1].sum()
edu_result[2] = edu_result[2] / edu_result[2].sum()
edu_result[3] = edu_result[3] / edu_result[3].sum()
edu_result[4] = edu_result[4] / edu_result[4].sum()
edu_result[5] = edu_result[5] / edu_result[5].sum()
#用0填补空值
edu_result = edu_result.fillna(0)
print(edu_result)
bar_width=0.17
plt.bar(x=edu_result.index - 2 * bar_width, height=edu_result[1], label='小学及其他', width=bar_width)
plt.bar(x=edu_result.index - 1 * bar_width, height=edu_result[2], label='初中', width=bar_width)
plt.bar(x=edu_result.index, height=edu_result[3], label='高中', width=bar_width)
plt.bar(x=edu_result.index + 1 * bar_width, height=edu_result[4], label='大学', width=bar_width)
plt.bar(x=edu_result.index + 2 * bar_width, height=edu_result[5], label='研究生', width=bar_width)
plt.title('受教育程度幸福感对比', size=15)
plt.ylabel('比例')
plt.xlabel('1 = 非常不幸福; 2 = 比较不幸福; 3 = 说不上幸福不幸福; 4 = 比较幸福; 5 = 非常幸福')
plt.legend()
plt.show()

五、数据挖掘

1、构建模型

用训练数据和某个机器学习算法得到机器学习模型，用测试数据评估模型

2、导入算法

采用LGBOOST与XGBOOST算法预测幸福值

#自定义评价函数
def myFeval(preds, xgbtrain):label = xgbtrain.get_label()score = mean_squared_error(label,preds)return 'myFeval',score

##### xgb
xgb_params = {"booster":'gbtree','eta': 0.005, 'max_depth': 5, 'subsample': 0.7, 'colsample_bytree': 0.8, 'objective': 'reg:linear', 'eval_metric': 'rmse', 'silent': True, 'nthread': 8}
folds = KFold(n_splits=5, shuffle=True, random_state=2018)
oof_xgb = np.zeros(len(train))
predictions_xgb = np.zeros(len(test))
for fold_, (trn_idx, val_idx) in enumerate(folds.split(X_train, y_train)):print("fold n°{}".format(fold_+1))trn_data = xgb.DMatrix(X_train[trn_idx], y_train[trn_idx])val_data = xgb.DMatrix(X_train[val_idx], y_train[val_idx])watchlist = [(trn_data, 'train'), (val_data, 'valid_data')]clf = xgb.train(dtrain=trn_data, num_boost_round=20000, evals=watchlist, early_stopping_rounds=200, verbose_eval=100, params=xgb_params,feval = myFeval)oof_xgb[val_idx] = clf.predict(xgb.DMatrix(X_train[val_idx]), ntree_limit=clf.best_ntree_limit)predictions_xgb += clf.predict(xgb.DMatrix(X_test), ntree_limit=clf.best_ntree_limit) / folds.n_splits
print("CV score: {:<8.8f}".format(mean_squared_error(oof_xgb, y_train_)))

##### lgb
param = {'boosting_type': 'gbdt','num_leaves': 20,'min_data_in_leaf': 20, 'objective':'regression','max_depth':6,'learning_rate': 0.01,"min_child_samples": 30,        "feature_fraction": 0.8,"bagging_freq": 1,"bagging_fraction": 0.8 ,"bagging_seed": 11,"metric": 'mse',"lambda_l1": 0.1,"verbosity": -1}
folds = KFold(n_splits=5, shuffle=True, random_state=2018)
oof_lgb = np.zeros(len(X_train_))
predictions_lgb = np.zeros(len(X_test_))
for fold_, (trn_idx, val_idx) in enumerate(folds.split(X_train, y_train)):print("fold n°{}".format(fold_+1))trn_data = lgb.Dataset(X_train[trn_idx], y_train[trn_idx])   val_data = lgb.Dataset(X_train[val_idx], y_train[val_idx])num_round = 10000clf = lgb.train(param, trn_data, num_round, valid_sets = [trn_data, val_data], verbose_eval=200, early_stopping_rounds = 100)oof_lgb[val_idx] = clf.predict(X_train[val_idx], num_iteration=clf.best_iteration)predictions_lgb += clf.predict(X_test, num_iteration=clf.best_iteration) / folds.n_splits
print("CV score: {:<8.8f}".format(mean_squared_error(oof_lgb, y_train_)))

3、评估模型

from sklearn import linear_model
# 将lgb和xgb的结果进行stacking
train_stack = np.vstack([oof_lgb,oof_xgb,oof_cb]).transpose()
test_stack = np.vstack([predictions_lgb, predictions_xgb,predictions_cb]).transpose()
folds_stack = RepeatedKFold(n_splits=5, n_repeats=2, random_state=2018)
oof_stack = np.zeros(train_stack.shape[0])
predictions = np.zeros(test_stack.shape[0])
for fold_, (trn_idx, val_idx) in enumerate(folds_stack.split(train_stack,y_train)):print("fold {}".format(fold_))trn_data, trn_y = train_stack[trn_idx], y_train[trn_idx]val_data, val_y = train_stack[val_idx], y_train[val_idx]  clf_3 = linear_model.BayesianRidge()#clf_3 =linear_model.Ridge()clf_3.fit(trn_data, trn_y) oof_stack[val_idx] = clf_3.predict(val_data)predictions += clf_3.predict(test_stack) / 10
print("CV score: {:<8.8f}".format(mean_squared_error(oof_stack, y_train_)))

4、方案实施

#将结果保存为csv文件
result=list(predictions)
result=list(map(lambda x: x + 1, result))
test_sub["happiness"]=result
test_sub.to_csv("happiness.csv", index=False)