# coding: utf-8
# In[142]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# In[143]:
# 导入数据
titanic = pd.read_csv('train.csv')
titanic.head(5)
# print(titanic.describe())
# In[144]:
titanic['Age'] = titanic['Age'].fillna(titanic['Age'].median())
print(titanic.describe())
# In[145]:
print(titanic['Sex'].unique())
# Replace all the occurences of male with the number 0.
# 将字符值转换成 数值
# 进行一个属性值转换
titanic.loc[titanic['Sex'] == 'male', 'Sex'] = 0
titanic.loc[titanic['Sex'] == 'female', 'Sex'] = 1
# In[146]:
# 登船地址
print(titanic['Embarked'].unique())
titanic['Embarked'] = titanic['Embarked'].fillna('S')
titanic.loc[titanic['Embarked'] == 'S', 'Embarked'] = 0
titanic.loc[titanic['Embarked'] == 'C', 'Embarked'] = 1
titanic.loc[titanic['Embarked'] == 'Q', 'Embarked'] = 2
# In[147]:
# Import the linear regression class (线性回归)
from sklearn.linear_model import LinearRegression
# Sklearn also has a helper that makes it easy to do cross validation(交叉验证)
from sklearn.cross_validation import KFold
# The Columns we'll use to predict the target
predictors = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']
# Initialize our algorithm class
alg = LinearRegression()
# Generate(生成) cross validation folds(交叉验证) for the titanic dataset.
# We set random_state to ensure we get the same splits(相同的分割) every time we run this.
kf = KFold(titanic.shape[0], n_folds=3, random_state=1)
# 预测结果
predictions = []
# 训练集, 测试集, 交叉验证
for train, test in kf:
# The predictors we're using the train the algorithm.
# Note how we only take the rows in the train folds (只在训练集中进行)
train_predictors = (titanic[predictors].iloc[train, :])
# The target we're using to train the algorithm
train_target = titanic['Survived'].iloc[train]
# Training the algorithm using the prodictors and target
# 训练数据的 X, Y ==> 让他能进行判断的操作
alg.fit(train_predictors, train_target)
# we can now make predictions on the test fold
test_predictions = alg.predict(titanic[predictors].iloc[test, :])
predictions.append(test_predictions)
# In[148]:
import numpy as np
# The Predictions are in three separate numpy arrays. Concatenate them into one.
# We concatenate them on axis 0, as they only have one axis.我们将它们连接在轴0上，因为它们只有一个轴
predictions = np.concatenate(predictions, axis = 0)
# Map predictions to outcomes (only possible outcome are 1 and 0)
predictions[predictions > 0.5] = 1
predictions[predictions <> .5] = 0
# 进行评估模型
accuracy = sum(predictions[predictions == titanic['Survived']]) / len(predictions)
print(accuracy)
# In[149]:
from sklearn import cross_validation
from sklearn.linear_model import LogisticRegression
# Initialize our algorithm
alg = LogisticRegression(random_state=1)
# Compute the accuracy score for all the cross validation folds. (计算所有交叉验证折叠的精度分数。)
# (much simpler than what we did before !)
scores = cross_validation.cross_val_score(alg, titanic[predictors], titanic['Survived'], cv=3)
# Take the mean of the scores (because we have one for each fold)
print(scores.mean())
# ### 随机森林
# In[150]:
titanic_test = pd.read_csv('test.csv')
titanic_test['Age'] = titanic_test['Age'].fillna(titanic['Age'].median())
titanic_test['Fare'] = titanic_test['Fare'].fillna(titanic_test['Fare'].median())
titanic_test.loc[titanic_test['Sex'] == 'male', 'Sex'] = 0
titanic_test.loc[titanic_test['Sex'] == 'female', 'Sex'] = 1
titanic_test['Embarked'] = titanic_test['Embarked'].fillna('S')
titanic_test.loc[titanic_test['Embarked'] == 'S', 'Embarked'] = 0
titanic_test.loc[titanic_test['Embarked'] == 'C', 'Embarked'] = 1
titanic_test.loc[titanic_test['Embarked'] == 'Q', 'Embarked'] = 2
# In[151]:
from sklearn import cross_validation
from sklearn.ensemble import RandomForestClassifier
#选中一些特征
predictors = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']
# Initialize our algorithm with the default paramters
# random_state = 1 表示此处代码多运行几次得到的随机值都是一样的，如果不设置，两次执行的随机值是不一样的
# n_estimators 指定有多少颗决策树，树的分裂的条件是:
# min_samples_split 代表样本不停的分裂，某一个节点上的样本如果只有2个了 ，就不再继续分裂了
# min_samples_leaf 是控制叶子节点的最小个数
alg = RandomForestClassifier(random_state=1, n_estimators=10, min_samples_split=2, min_samples_leaf=1)
# Compute the accuracy score for all the cross validation folds (nuch simpler than what we did before)
# 进行交叉验证
kf = cross_validation.KFold(titanic.shape[0], n_folds=3, random_state=1)
scores = cross_validation.cross_val_score(alg, titanic[predictors], titanic['Survived'], cv=kf)
# Take the mean of the scores (because we have one for each fold)
print(scores.mean())
# In[152]:
# 建立100多个决策树
alg = RandomForestClassifier(random_state=1, n_estimators=100, min_samples_split=4, min_samples_leaf=2)
# Compute the accuracy score
kf = cross_validation.KFold(titanic.shape[0], n_folds=3, random_state=1)
scores = cross_validation.cross_val_score(alg, titanic[predictors], titanic['Survived'], cv=kf)
# Take the mean of the scores (because we have one for each fold)
print(scores.mean())
# ## 关于特征提取问题 (非常关键)
# - 尽可能多的提取特征
# - 看不同特征的效果
# - 特征提取是数据挖掘里很- 要的一部分
# - 以上使用的特征都是数据里已经有的了，在真实的数据挖掘里我们常常没有合适的特征，需要我们自己取提取
#
# In[153]:
# Generating a familysize column
# 合并数据 ：自己生成一个特征，家庭成员的大小:兄弟姐妹+老人孩子
titanic['FamilySize'] = titanic['SibSp'] + titanic['Parch']
# The .apply method generates a new series 名字的长度(据说国外的富裕的家庭都喜欢取很长的名字)
titanic['NameLength'] = titanic['Name'].apply(lambda x: len(x))
# In[154]:
import re
# A function to get the title from a name
def get_title(name):
# Use a regular expression to search for a title.
# Titles always consist of capital and lowercase letters.
title_search = re.search(' ([A-Za-z]+)\.', name)
# If the title exists extract and return it.
if title_search:
return title_search.group(1)
return ''
# Get all the titles and print how often each one occurs.
titles = titanic['Name'].apply(get_title)
print(pd.value_counts(titles)) # 输出看看, 相同数量的,设置相同映射
# 国外不同阶层的人都有不同的称呼
# Map each title to an integer. Some titles are very rare. and are compressed into the same codes as other
title_mapping = {'Mr': 1, 'Miss': 2, 'Mrs': 3, 'Master': 4, 'Dr': 5, 'Rev': 6, 'Major': 7, 'Col': 7, 'Mlle': 8,
'Mme': 8, 'Don': 9, 'Lady': 10, 'Countess': 10, 'Jonkheer': 10, 'Sir': 9, 'Capt': 7, 'Ms': 2 }
for k, v in title_mapping.items():
#将不同的称呼替换成机器可以计算的数字
titles[titles == k] = v
# Verify that we converted everything
print(pd.value_counts(titles))
# Add in the title column
titanic['Title'] = titles
# In[155]:
# 进行特征选择
# 特征重要性分析
# 分析 不同特征对 最终结果的影响
# 例如 衡量age列的重要程度时，什么也不干，得到一个错误率error1，
# 加入一些噪音数据，替换原来的值(注意，此时其他列的数据不变)，又得到一个一个错误率error2
# 两个错误率的差值 可以体现这一个特征的重要性
import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
import matplotlib.pylab as plt
# 选中一些特征
predictors = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked',
'FamilySize', 'Title', 'NameLength']
# Perform feature selection 选择特性
selector = SelectKBest(f_classif, k = 5)
selector.fit(titanic[predictors], titanic['Survived'])
# Get the raw p-values(P 值) for each feature, and transform from p-values into scores
scores = -np.log10(selector.pvalues_)
# Plot the scores. See how 'Plcass', 'Sex', 'Title', and 'Fare' are the best ?
plt.bar(range(len(predictors)), scores)
plt.xticks(range(len(predictors)), predictors, rotation='vertical')
plt.show()
# 通过以上的特征重要性分析, 选择出4个最重要的特性，重新进行随机森林的算法
# Pick only the four best features.
predictors = ['Pclass', 'Sex', 'Fare', 'Title']
alg = RandomForestClassifier(random_state=1, n_estimators=50, min_samples_split=8, min_samples_leaf=4)
# 进行交叉验证
kf = cross_validation.KFold(titanic.shape[0], n_folds=3, random_state=1)
scores = cross_validation.cross_val_score(alg, titanic[predictors], titanic['Survived'],cv=kf)
#目前的结果是没有得到提高，本处的目的是为了练习在随机森林中的特征选择，它对于实际的数据挖掘具有重要意义
print (scores.mean())
# ### 集成多种算法(减少过拟合)
# In[156]:
# 在竞赛中常用的耍赖的办法:集成多种算法，取最后每种算法的平均值，来减少过拟合
from sklearn.ensemble import GradientBoostingClassifier
import numpy as np
# GradientBoostingClassifier也是一种随机森林的算法，可以集成多个弱分类器，然后变成强分类器
# The algorithm we want to ensemble
# We're using the more linear predictors for the logistic regression
# and everything with the gradient boosting
algorithms = [
[GradientBoostingClassifier(random_state=1, n_estimators=25, max_depth=3),['Pclass','Sex','Age','Fare','Embarked','FamilySize','Title']],
[LogisticRegression(random_state=1), ['Pclass','Sex','Age','Fare','Embarked','FamilySize','Title']]
]
# Initialize the cross validation folds
kf = KFold(titanic.shape[0], n_folds=3, random_state=1)
predictions = []
for train, test in kf:
train_target = titanic['Survived'].iloc[train]
full_test_predictions = []
# Make predictions for each algorithm on each folds
for alg, predictors in algorithms:
# Fit the algorithm on the training data.
alg.fit(titanic[predictors].iloc[train, :], train_target)
# Select and predict on the test fold.
# The astype(float) is necessary to convert the dataframe
test_predictions = alg.predict_proba(titanic[predictors].iloc[test, :].astype(float))[:, 1]
full_test_predictions.append(test_predictions)
# Use a simple ensembling scheme - just average the predictions to get the final classification
# 两个算法, 分别算出来的 预测值, 取平均
test_predictions = (full_test_predictions[0] + full_test_predictions[1]) / 2
# Any value over 5 is assumed to be a 1 prediction, and below 5 is a 0 prediction
test_predictions[test_predictions <> 0.5] = 0
test_predictions[test_predictions > .5] = 1
predictions.append(test_predictions)
# Put all the predictions together into one array
predictions = np.concatenate(predictions, axis=0)
accuracy = sum(predictions[predictions == titanic['Survived']]) / len(predictions)
print(accuracy)
# In[157]:
titles = titanic['Name'].apply(get_title)
print(pd.value_counts(titles)) # 输出看看, 相同数量的,设置相同映射
# 国外不同阶层的人都有不同的称呼
# Map each title to an integer. Some titles are very rare. and are compressed into the same codes as other
title_mapping = {'Mr': 1, 'Miss': 2, 'Mrs': 3, 'Master': 4, 'Dr': 5, 'Rev': 6, 'Major': 7, 'Col': 7, 'Mlle': 8,
'Mme': 8, 'Don': 9, 'Lady': 10, 'Countess': 10, 'Jonkheer': 10, 'Sir': 9, 'Capt': 7, 'Ms': 2 }
for k, v in title_mapping.items():
#将不同的称呼替换成机器可以计算的数字
titles[titles == k] = v
# Add in the title column
titanic_test['Title'] = titles
print(pd.value_counts(titanic_test['Title']))
# Now, we add the family size column.
titanic_test['FamilySize'] = titanic_test['SibSp'] + titanic_test['Parch']
# In[158]:
predictors = ['Pclass','Sex','Age','Fare','Embarked','FamilySize','Title']
algorithms = [
[GradientBoostingClassifier(random_state=1, n_estimators=25, max_depth=3), predictors],
[LogisticRegression(random_state=1), ['Pclass','Sex','Age','Fare','Embarked','FamilySize','Title']]
]
full_predictions = []
for alg, predictors in algorithms:
# Fit the Algorithm using the full training data
alg.fit(titanic[predictors], titanic['Survived'])
predictions = alg.predict_proba(titanic_test[predictors].astype(float))[:, 1]
full_predictions.append(predictions)
# 梯度提升分类器产生更好的预测
# The gradient boosting classifier generates better predictions, so we weight it high
predictions = (full_predictions[0] * 3 + full_predictions[1]) / 4
predictions
