Python——泰坦尼克号船员获救

代码

数据预处理

import pandas 
titanic = pandas.read_csv("titanic_train.csv")
titanic.head(5)

#数据预分析
print(titanic.describe())

#对缺失量进行数据填充(用中位数或者均值)
titanic["Age"] = titanic["Age"].fillna(titanic["Age"].median())
print(titanic.describe())

#先判断字符型数据中有多少不同量
print(titanic["Sex"].unique())
print(titanic["Embarked"].unique())

#对缺失量进行填充并将字符量用数字来代替
titanic.loc[titanic["Sex"] == "male", "Sex"] = 0
titanic.loc[titanic["Sex"] == "female", "Sex"] = 1
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

线性回归算法

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import KFold
import numpy as np

# 构造训练特征集
predictors = ["Pclass", "Sex", "Age", "SibSp", "Parch", "Fare", "Embarked"]

# 初始化线性回归模型
alg = LinearRegression()

# 构造训练集、测试集、交叉验证集
# 将数据等分为3份
kf = KFold(n_splits=3)

predictions = []
# 每一份分别作测试集
for train, test in kf.split(titanic[predictors]):
    # 取出训练集数据
    train_predictors = (titanic[predictors].iloc[train,:])
    train_target = titanic["Survived"].iloc[train]
    
    # 参数拟合
    alg.fit(train_predictors, train_target)
    
    # 利用测试集数据进行评估
    test_predictions = alg.predict(titanic[predictors].iloc[test,:])
    predictions.append(test_predictions)

# 将3份测试集得到的数据进行合并
predictions = np.concatenate(predictions, axis=0)

# 数据整合
predictions[predictions > .5] = 1
predictions[predictions <=.5] = 0

accuracy = len(predictions[predictions == titanic["Survived"]]) / len(predictions)
print(accuracy)

逻辑回归算法

from sklearn.linear_model import LogisticRegression
predictions = []

# 划分训练集、交叉验证集
fold = KFold(n_splits=3,shuffle=False) 
for train, test in fold.split(titanic[predictors]):
    lr = LogisticRegression(penalty = 'l2',solver='liblinear')
    lr.fit(titanic[predictors].iloc[train,:],titanic["Survived"].iloc[train])
    test_predictions = lr.predict(titanic[predictors].iloc[test,:])
    predictions.append(test_predictions)
    
# 将3份测试集得到的数据进行合并    
predictions = np.concatenate(predictions, axis=0)

# 数据整合
predictions[predictions > .5] = 1
predictions[predictions <=.5] = 0
accuracy = len(predictions[predictions == titanic["Survived"]]) / len(predictions)
print(accuracy)

测试集数据预处理

titanic_test = pandas.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

随机森林算法

from sklearn import model_selection
from sklearn.ensemble import RandomForestClassifier

predictors = ["Pclass", "Sex", "Age", "SibSp", "Parch", "Fare", "Embarked"]、

# 生成随机树模型
alg = RandomForestClassifier(random_state=1, n_estimators=10, min_samples_split=2, min_samples_leaf=1)
kf = model_selection.KFold(n_splits=3)

# 计算正确率
scores = model_selection.cross_val_score(alg, titanic[predictors], titanic["Survived"], cv=kf)

# 取平均值（交叉验证集共有三个）
print(scores.mean())

# 改变随机森林模型参数
alg = RandomForestClassifier(random_state=1, n_estimators=100, min_samples_split=4, min_samples_leaf=2)
kf = model_selection.KFold(n_splits=3)
scores = model_selection.cross_val_score(alg, titanic[predictors], titanic["Survived"], cv=kf)
print(scores.mean())

生成新特征

# 利用原有特征生成新的特征
titanic["FamilySize"] = titanic["SibSp"] + titanic["Parch"]

# 得到名字的长度
titanic["NameLength"] = titanic["Name"].apply(lambda x: len(x))

利用正则表达式提取文本

import re

# 利用正则表达式提取文本
def get_title(name):
    title_search = re.search(' ([A-Za-z]+)\.', name)
    
    if title_search:
        return title_search.group(1)
    return ""

# 拿到称谓并计算其出现次数
titles = titanic["Name"].apply(get_title)
print(pandas.value_counts(titles))

# 将文本转换为数字
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

# 计算不同称呼各自的数量
print(pandas.value_counts(titles))

# 新增特征
titanic["Title"] = titles

计算特征重要程度

import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
import matplotlib.pyplot as plt
predictors = ["Pclass", "Sex", "Age", "SibSp", "Parch", "Fare", "Embarked", "FamilySize", "Title", "NameLength"]

# 对特征重要程度计算
selector = SelectKBest(f_classif, k=5)
selector.fit(titanic[predictors], titanic["Survived"])

scores = -np.log10(selector.pvalues_)

# 用直方图显示
plt.bar(range(len(predictors)), scores)
plt.xticks(range(len(predictors)), predictors, rotation='vertical')
plt.show()

# 选择较重要的特征进行拟合
predictors = ["Pclass", "Sex", "Fare", "Title"]

alg = RandomForestClassifier(random_state=1, n_estimators=50, min_samples_split=8, min_samples_leaf=4)

集成算法

from sklearn.ensemble import GradientBoostingClassifier
import numpy as np

# 进行算法集成
algorithms = [
    [GradientBoostingClassifier(random_state=1, n_estimators=25, max_depth=3), ["Pclass", "Sex", "Age", "Fare", "Embarked", "FamilySize", "Title",]],
    [LogisticRegression(random_state=1), ["Pclass", "Sex", "Fare", "FamilySize", "Title", "Age", "Embarked"]]
]

kf = KFold(n_splits=3)

predictions = []
for train, test in kf.split(titanic[predictors], titanic["Survived"]):
    train_target = titanic["Survived"].iloc[train]
    full_test_predictions = []
    # 将算法以及相应特征传入
    for alg, predictors in algorithms:
        # 参数拟合
        alg.fit(titanic[predictors].iloc[train,:], train_target)
        # 将数据转换成float类型
        test_predictions = alg.predict_proba(titanic[predictors].iloc[test,:].astype(float))[:,1]
        full_test_predictions.append(test_predictions)
    # 将两种算法得到的结果取平均值
    test_predictions = (full_test_predictions[0] + full_test_predictions[1]) / 2
    # 将结果进行转换
    test_predictions[test_predictions <= .5] = 0
    test_predictions[test_predictions > .5] = 1
    predictions.append(test_predictions)

# 将结果转换为数组
predictions = np.concatenate(predictions, axis=0)

accuracy = len(predictions[predictions == titanic["Survived"]]) / len(predictions)
print(accuracy)

测试集数据处理

titles = titanic_test["Name"].apply(get_title)
# 对测试集进行相同操作
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, "Dona": 10}
for k,v in title_mapping.items():
    titles[titles == k] = v
titanic_test["Title"] = titles
# Check the counts of each unique title.
print(pandas.value_counts(titanic_test["Title"]))

# Now, we add the family size column.
titanic_test["FamilySize"] = titanic_test["SibSp"] + titanic_test["Parch"]

测试集数据预测

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", "Fare", "FamilySize", "Title", "Age", "Embarked"]]
]

full_predictions = []
for alg, predictors in algorithms:
    # 将整个训练集数据进行拟合
    alg.fit(titanic[predictors], titanic["Survived"])
    predictions = alg.predict_proba(titanic_test[predictors].astype(float))[:,1]
    full_predictions.append(predictions)

# 将boosting classifier权重增加
predictions = (full_predictions[0] * 3 + full_predictions[1]) / 4
predictions[predictions <= .5] = 0
predictions[predictions > .5] = 1
predictions

重要函数整理

print(titanic.describe())
titanic["Age"] = titanic["Age"].fillna(titanic["Age"].median())
print(titanic["Sex"].unique())
np.concatenate(predictions, axis=0)
print(pandas.value_counts(titles))

备注

正则表达式

import re
a = "123abc456"
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)   #123abc456,返回整体
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)   #123
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)   #abc
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)   #456
————————————————
原文链接：https://blog.csdn.net/sinat_20174131/article/details/77769309

正则表达式中的三组括号把匹配结果分成三组

group() 同group（0）就是匹配正则表达式整体结果
group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。

lambda匿名函数

lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值

# 将返回名字长度
titanic["Name"].apply(lambda x: len(x))

随机森林模型参数：https://blog.csdn.net/w952470866/article/details/78987265/
部分内容取自于：https://blog.csdn.net/sinat_20174131/article/details/77769309