精华内容
下载资源
问答
  • 2. 在linear regression、logistic regression、neuron network或competition提供的算法中,挑出两个算法(必须选择一个实验课上使用的算法做实验,另外一个可以选择其他算法),在Titanic数据集上做十字交叉验证。...
  • titanic 罹难乘客预测

    2017-10-13 16:21:56
    一、实验任务泰坦尼克号乘客的生存预测二、数据详细特征Variable Definition Key survival Survival 0 = ...pclass Ticket class 1 = 1st, 2 = 2nd, 3 = 3rd sex Sex Age Age in years sibsp # of siblings / spou

    一、实验任务

    泰坦尼克号乘客的生存预测

    二、数据详细特征

    Variable Definition Key
    survival Survival 0 = No, 1 = Yes
    pclass Ticket class 1 = 1st, 2 = 2nd, 3 = 3rd
    sex Sex
    Age Age in years
    sibsp # of siblings / spouses aboard the Titanic
    parch # of parents / children aboard the Titanic
    ticket Ticket number
    fare Passenger fare
    cabin Cabin number
    embarked Port of Embarkation C = Cherbourg, Q = Queenstown, S = Southampton

    Variable Notes

    pclass: A proxy for socio-economic status (SES)
    1st = Upper
    2nd = Middle
    3rd = Lower

    age: Age is fractional if less than 1. If the age is estimated, is it in the form of xx.5

    sibsp: The dataset defines family relations in this way…
    Sibling = brother, sister, stepbrother, stepsister
    Spouse = husband, wife (mistresses and fiancés were ignored)

    parch: The dataset defines family relations in this way…
    Parent = mother, father
    Child = daughter, son, stepdaughter, stepson
    Some children travelled only with a nanny, therefore parch=0 for them.

    三、代码实现

    3.1 数据展示

    import pandas as pd
    
    train = pd.read_csv('train.csv')
    test = pd.read_csv('test.csv')
    print(train.info())
    print(test.info())
    

    输出:

    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 12 columns):
    PassengerId    891 non-null int64
    Survived       891 non-null int64
    Pclass         891 non-null int64
    Name           891 non-null object
    Sex            891 non-null object
    Age            714 non-null float64
    SibSp          891 non-null int64
    Parch          891 non-null int64
    Ticket         891 non-null object
    Fare           891 non-null float64
    Cabin          204 non-null object
    Embarked       889 non-null object
    dtypes: float64(2), int64(5), object(5)
    memory usage: 83.6+ KB
    None
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 418 entries, 0 to 417
    Data columns (total 11 columns):
    PassengerId    418 non-null int64
    Pclass         418 non-null int64
    Name           418 non-null object
    Sex            418 non-null object
    Age            332 non-null float64
    SibSp          418 non-null int64
    Parch          418 non-null int64
    Ticket         418 non-null object
    Fare           417 non-null float64
    Cabin          91 non-null object
    Embarked       418 non-null object
    dtypes: float64(2), int64(4), object(5)
    memory usage: 36.0+ KB
    None

    3.2 人工选取对预测有效的特征

    selected_feature = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Embarked']
    
    X_train = train[selected_feature]
    X_test = test[selected_feature]
    
    y_train = train['Survived']
    
    print(X_train['Embarked'].value_counts())
    print(X_test['Embarked'].value_counts())

    输出:

    S    644
    C    168
    Q     77
    Name: Embarked, dtype: int64
    S    270
    C    102
    Q     46
    Name: Embarked, dtype: int64

    3.3 填充确实数据

    # 选用频率最高的特征值来填充缺失值
    X_train['Embarked'].fillna('S', inplace = True)
    X_test['Embarked'].fillna('S', inplace = True)
    X_train['Age'].fillna(X_train['Age'].mean(), inplace = True)
    X_test['Age'].fillna(X_test['Age'].mean(), inplace = True)
    X_train.info()

    输出:

    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 6 columns):
    Pclass      891 non-null int64
    Sex         891 non-null object
    Age         891 non-null float64
    SibSp       891 non-null int64
    Parch       891 non-null int64
    Embarked    891 non-null object
    dtypes: float64(1), int64(3), object(2)
    memory usage: 41.8+ KB

    3.4 特征向量化

    # 特征向量化
    from sklearn.feature_extraction import DictVectorizer
    
    dict_vec = DictVectorizer(sparse = False)
    
    X_train = dict_vec.fit_transform(X_train.to_dict(orient = 'record'))
    X_test = dict_vec.fit_transform(X_test.to_dict(orient = 'record'))
    
    dict_vec.feature_names_

    输出:

    ['Age',
     'Embarked=C',
     'Embarked=Q',
     'Embarked=S',
     'Parch',
     'Pclass',
     'Sex=female',
     'Sex=male',
     'SibSp']

    3.5 预测数据

    from sklearn.ensemble import RandomForestClassifier
    from xgboost import XGBClassifier
    
    rfc = RandomForestClassifier()
    xgbc = XGBClassifier()
    
    # 使用 5 折交叉验证的方法在训练集上分别地对默认配置的
    # RandomForestClassifier 和 XGBClassifier 进行性能评估
    # 并获得平均分类准确性的得分
    from sklearn.cross_validation import cross_val_score
    cross_val_score(rfc, X_train, y_train, cv = 5).mean()
    
    输出:# 0.81152892044682812
    
    cross_val_score(xgbc, X_train, y_train, cv = 5).mean()
    
    输出:0.82158492822330198
    
    
    # 预测操作
    # 使用并行网格搜索的方式寻找更好的超参数组合,以期待进一步提高性能
    rfc.fit(X_train, y_train)
    rfc_y_predict = rfc.predict(X_test)
    
    rfc_sumission = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':rfc_y_predict})
    rfc_sumission.to_csv('./rfc_submission.csv', index = False)
    xgbc.fit(X_train, y_train)
    xgbc_y_predict = xgbc.predict(X_test)
    xgbc_submission = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':xgbc_y_predict})
    xgbc_submission.to_csv('./xgbc_submission.csv', index = False)
    
    from sklearn.grid_search import GridSearchCV
    params = {'max_depth':[2,3,4,5,6], 'n_estimators':[100, 300, 500, 700, 900, 1100], 
              'learning_rate':[0.05, 0.1, 0.25, 0.5, 1.0]}
    xgbc_best = XGBClassifier()
    gs = GridSearchCV(xgbc_best, params, n_jobs = -1, cv = 5, verbose = 1)
    gs.fit(X_train, y_train)
    
    
    输出:
    # Fitting 5 folds for each of 150 candidates, totalling 750 fits
    # [Parallel(n_jobs=-1)]: Done 124 tasks      | elapsed:    6.7s
    # [Parallel(n_jobs=-1)]: Done 324 tasks      | elapsed:   18.1s
    # [Parallel(n_jobs=-1)]: Done 574 tasks      | elapsed:   32.7s
    # [Parallel(n_jobs=-1)]: Done 750 out of 750 | elapsed:   44.1s # # finished
    
    
    print(gs.best_score_)
    print(gs.best_params_)
    
    xgbc_best_y_predict = gs.predict(X_test)
    xgbc_best_submission = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':xgbc_best_y_predict})
    xgbc_best_submission.to_csv('./xgbc_best_submission.csv', index = False)
    
    输出:
    # 0.8316498316498316
    # {'learning_rate': 0.05, 'max_depth': 5, 'n_estimators': 300}
    展开全文
  • titanic数据集

    2018-06-05 15:59:59
    Pclass => 乘客等级(1-一等舱,2-二等舱,3-三等舱) Name => 乘客姓名 Sex => 性别 Age => 年龄 SibSp => 兄弟姐妹/配偶的数量 Parch => 父母与小孩数量 Ticket => 船票信息 Fare => 票价 Cabin => 客舱 ...
  • titanic.ipynb

    2019-08-31 10:00:31
    VariableDefinitionKey survival Survival 0 = No, 1 = Yes pclass Ticket class 1 = 1st, 2 = 2nd, 3 = 3rd sex Sex Age Age in years sibsp # of siblings / spouses aboard the Titanic parch # of parents / ...
  • titanic数据集的目标是根据乘客信息预测他们在Titanic号撞击冰山沉没后能否生存。 结构化数据一般会使用Pandas中的DataFrame进行预处理。 字段说明: Survived:0代表死亡,1代表存活【y标签】 Pclass:乘客所持票类,...
  • 泰坦尼克数据集Titanic

    2020-04-22 13:05:13
    Pclass:乘客所持票类,有三种值(1,2,3);Name:乘客姓名;Sex:乘客性别;Age:乘客年龄(有缺失);SibSp:乘客兄弟姐妹/配偶的个数(整数值);Parch:乘客父母/孩子的个数(整数值);Ticket:票号(字符串);Fare:乘客所持票...
  • The titanic dataset gives the values of four categorical attributes for each of the 2201 people on board the Titanic when it struck an iceberg and sank. The attributes are social class (first class, ...
  • 友情提示,kaggle注册帐号发送验证邮件时验证码貌似是使用了谷歌的服务,如果没有梯子是刷不出验证码无法验证账号的,...不过有时一些数据的下载好像也会用到谷歌。这个数据本来想0分的,不过现在好像最低要求是2分。
  • Titanic 生存分析

    2019-06-11 20:43:48
    https://github.com/apachecn/kaggle/tree/master/competitions/getting-started/titanic https://www.kaggle.com/goldens/classification-81-3-with-simple-model-nested-cv 1. 问题描述 泰坦尼克号的沉没是历史...

    参考:

    1. https://github.com/apachecn/kaggle/tree/master/competitions/getting-started/titanic
    2. https://www.kaggle.com/goldens/classification-81-3-with-simple-model-nested-cv

    1. 问题描述

    • 泰坦尼克号的沉没是历史上最臭名昭著的沉船事件之一。1912年4月15日,泰坦尼克号在处女航中撞上冰山沉没,2224名乘客和船员中1502人遇难。这一耸人听闻的悲剧震惊了国际社会,并导致了更好的船舶安全条例。

    • 沉船造成如此巨大人员伤亡的原因之一是没有足够的救生艇来容纳乘客和船员。虽然在沉船事件中幸存下来也有一些运气的因素,但有些人比其他人更有可能幸存下来,比如妇女、儿童和上层阶级。

    • 在这个挑战中,我们要求你完成对可能存活下来的人的分析。我们特别要求你们运用机器学习工具来预测哪些乘客在灾难中幸存下来。
      【注】

    • 数据来源:https://www.kaggle.com/c/titanic/data

    • 问题定位:二分类问题

    2. 主要分析过程

    • 探索性数据分析
    • 特征变量选取
    • 模型选择

    3. 探索性数据分析

    3.1 变量说明

    变量含义变量含义
    Survival生存Pclass票类别
    Sex性别Age年龄
    Sibsp兄弟姐妹/配偶的数量Parch父母/孩子的数量
    Ticket票号Fare票价
    Cabin客舱号码Embarked登船港口

    3.2 读取数据

    # 加载包
    from sklearn.model_selection import cross_val_score
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.pipeline import make_pipeline
    from sklearn.ensemble import RandomForestClassifier
    import matplotlib.pyplot as plt
    import seaborn as sns
    import pandas as pd
    import numpy as np
    import warnings
    
    # 读取数据
    train_data = pd.read_csv('train_titanic.csv')
    test_data = pd.read_csv('test_titanic.csv')
    titanic = pd.concat([train_data, test_data], sort=False)
    

    3.3 数据预览

    # 数据探索
    print(train_data.info())  
    print('-'*30)
    print(train_data.head())
    

    输出:

    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 12 columns):
    PassengerId    891 non-null int64
    Survived       891 non-null int64
    Pclass         891 non-null int64
    Name           891 non-null object
    Sex            891 non-null object
    Age            714 non-null float64
    SibSp          891 non-null int64
    Parch          891 non-null int64
    Ticket         891 non-null object
    Fare           891 non-null float64
    Cabin          204 non-null object
    Embarked       889 non-null object
    dtypes: float64(2), int64(5), object(5)
    memory usage: 83.6+ KB
    None
    ------------------------------
       PassengerId  Survived  Pclass                                               Name     Sex   Age  SibSp  Parch            Ticket     Fare Cabin Embarked
    0            1         0       3                            Braund, Mr. Owen Harris    male  22.0      1      0         A/5 21171   7.2500   NaN        S
    1            2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1      0          PC 17599  71.2833   C85        C
    2            3         1       3                             Heikkinen, Miss. Laina  female  26.0      0      0  STON/O2. 3101282   7.9250   NaN        S
    3            4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1      0            113803  53.1000  C123        S
    4            5         0       3                           Allen, Mr. William Henry    male  35.0      0      0            373450   8.0500   NaN        S
    

    可以看到,数据中有缺失值, 为确定数据缺失的情况,输入如下:

    print(titanic.isnull().sum()[titanic.isnull().sum() > 0])
    

    输出:

    Survived     418
    Age          263
    Fare           1
    Cabin       1014
    Embarked       2
    dtype: int64
    

    由于变量 Cabin 缺失较多,这里选择不做处理,直接放弃。对变量 Fare 的缺失值取其均值作为替换,对变量 Embarked 的缺失值取其众数作为替换,对变量 Age 的缺失值按照 Name 和 Sex 的分组 去均值作为替换。

    # Fare
    train_data['Fare'].fillna(train_data['Fare'].mean(), inplace=True)
    test_data['Fare'].fillna(test_data['Fare'].mean(), inplace=True)
    # Embarked 为登陆港口,有少量的缺失值,可以先观察 Embarked 的取值情况
    print(train_data['Embarked'].value_counts())
    # 发现S港口的人较多,因此将缺失值都设为'S'
    train_data['Embarked'].fillna('S', inplace=True)
    test_data['Embarked'].fillna('S', inplace=True)
    #  Cabin 为船舱,有大量的缺失值,无法补齐
    # Age
    train_data['title'] = train_data.Name.apply(
        lambda x: x.split('.')[0].split(',')[1].strip())
    test_data['title'] = test_data.Name.apply(
        lambda x: x.split('.')[0].split(',')[1].strip())
    newtitles = {
        "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"}
    train_data['title'] = train_data.title.map(newtitles)
    test_data['title'] = test_data.title.map(newtitles)
    train_data.groupby(['title', 'Sex']).Age.mean()
    
    
    def newage(cols):
        title = cols[0]
        Sex = cols[1]
        Age = cols[2]
        if pd.isnull(Age):
            if title == 'Master' and Sex == "male":
                return 4.57
            elif title == 'Miss' and Sex == 'female':
                return 21.8
            elif title == 'Mr' and Sex == 'male':
                return 32.37
            elif title == 'Mrs' and Sex == 'female':
                return 35.72
            elif title == 'Officer' and Sex == 'female':
                return 49
            elif title == 'Officer' and Sex == 'male':
                return 46.56
            elif title == 'Royalty' and Sex == 'female':
                return 40.50
            else:
                return 42.33
        else:
            return Age
    
    
    train_data.Age = train_data[['title', 'Sex', 'Age']].apply(newage, axis=1)
    test_data.Age = test_data[['title', 'Sex', 'Age']].apply(newage, axis=1)
    

    3.4 变量分析

    # 变量相关分析
    warnings.filterwarnings(action="ignore")
    plt.figure(figsize=[10, 30])
    plt.subplot(3, 3, 1)
    sns.barplot('Pclass', 'Survived', data=train_data)
    plt.subplot(3, 3, 2)
    sns.barplot('SibSp', 'Survived', data=train_data)
    plt.subplot(3, 3, 3)
    sns.barplot('Parch', 'Survived', data=train_data)
    plt.subplot(3, 3, 4)
    sns.barplot('Sex', 'Survived', data=train_data)
    plt.subplot(3, 3, 5)
    sns.barplot('Ticket', 'Survived', data=train_data)
    plt.subplot(3, 3, 6)
    sns.barplot('Embarked', 'Survived', data=train_data)
    plt.subplot(3, 3, 7)
    sns.distplot(train_data[train_data.Survived == 1].Age,
                 color='green', kde=False)
    sns.distplot(train_data[train_data.Survived == 0].Age,
                 color='orange', kde=False)
    plt.subplot(3, 3, 8)
    sns.distplot(train_data[train_data.Survived == 1].Fare,
                 color='green', kde=False)
    sns.distplot(train_data[train_data.Survived == 0].Fare,
                 color='orange', kde=False)
    # 由于变量 Sibsp 和变量 Parch 与 Survival 的相关性不明显,故考虑将这两个变量合并
    train_data['Relatives'] = train_data.SibSp+train_data.Parch
    test_data['Relatives'] = test_data.SibSp+test_data.Parch
    plt.subplot(3, 3, 9)
    sns.distplot(train_data[train_data.Survived ==
                            1].Relatives, color='green', kde=False)
    sns.distplot(train_data[train_data.Survived ==
                            0].Relatives, color='orange', kde=False)
    plt.show()
    

    输出:
    在这里插入图片描述

    4. 特征选择

    # 特征选择
    features = ['Pclass', 'Sex', 'Age', 'Relatives', 'Fare', 'Embarked']
    train_features = train_data[features]
    train_labels = train_data['Survived']
    test_features = test_data[features]
    
    # 将分类变量转换成数值类型
    dvec = DictVectorizer(sparse=False)
    train_features = dvec.fit_transform(
        train_features.to_dict(orient='record'))  # 将特征向量转化为特征值矩阵
    print(dvec.feature_names_)
    test_features = dvec.transform(test_features.to_dict(orient='record'))
    

    5. 模型选取

    这里主要考虑两种方法:决策树和随机森林。

    5.1 决策树

    # 决策树模型
    # 构造 ID3 决策树
    clf = DecisionTreeClassifier(criterion='entropy')
    # 决策树训练
    clf.fit(train_features, train_labels)
    
    
    # 用训练集的数据做评估
    # 得到决策树准确率
    acc_decision_tree = round(
        clf.score(train_features, train_labels), 6)
    print(u'score 准确率为 %.4lf' % acc_decision_tree)  # %4lf为宽度为4的double型双精度
    
    # 使用 K 折交叉验证决策树准确率
    # 使用 K 折交叉验证 统计决策树准确率
    print(u'cross_val_score 准确率为 %.4lf' %
          np.mean(cross_val_score(clf, train_features, train_labels, cv=10)))
    

    输出:

    ['Age', 'Embarked=C', 'Embarked=Q', 'Embarked=S', 'Fare', 'Pclass', 'Relatives', 'Sex=female', 'Sex=male']
    score 准确率为 0.9820
    cross_val_score 准确率为 0.7869
    

    5.2 随机森林

    # 随机森林
    rf = RandomForestClassifier(
        n_estimators=150, min_samples_leaf=2, max_depth=6, oob_score=True)
    rf.fit(train_features, train_labels)
    print(u'cross_val_score 准确率为 %.4lf' %
          np.mean(cross_val_score(rf, train_features, train_labels, cv=10)))
    

    输出:

    cross_val_score 准确率为 0.833
    

    经比较,随机森林的预测效果要优于决策树法。

    # 预测
    RF_lables = rf.predict(test_features)
    
    展开全文
  • Kaggle入门——Titanic案例

    千次阅读 2017-01-12 22:01:33
    Kaggle Titanic

    0、写在前面的话

           接触kaggle算起来已经快有一个学期了,断断续续做了5个(包括目前正在进行中的两个)。正好趁放假回家前这段时间回顾一下。(最近越来越体会到孔老夫子的大智慧 ”温故而知新“)
            ● Titanic是我接触kaggle的第一个案例。
           完成Titanic,让我初步了解了一个从数据分析到模型选择的完整的比赛过程,而不再是用UCI标准机器学习库数据集去验证算法的准确率(前者偏向于工程,后者偏向于科研)。这里数据预处理可以媲美甚至超过模型选择的重要性。
           ● 关于模型
           Titanic里虽然没有用到kaggle的神器xgboost(后面案例会用到),但是从决策树到随机森林以及GBDT的过程也深刻体会到随机森林以及以它为原型的各种改进的树模型的强大。(后面更会体会到ensemble的强大)
           ● 表白kaggle以及各位在forum中无私分享的大神!

    1、EDA(探索性数据分析)

           ● EDA是对数据进行探讨,强调的是统计概括和可视化。

    i) 读入数据:
    
    titanic_data = pd.read_csv("E:/Kaggle/Titanic/train.csv")   
    #pandas是最常用的一个python数据分析库,读入的数据是一个dataFrame的结构。对于dataFrame结构的数据各种操作,《利用python进行数据分析》一书中有详细的介绍。
    
    ii) 初步分析:
    
    titanic_data.shape
    Out[11]: (891, 12)
    #可以看出数据有891行,12列
    
    titanic_data.columns
    Out[12]: 
    Index([u'PassengerId', u'Survived', u'Pclass', u'Name', u'Sex', u'Age',
           u'SibSp', u'Parch', u'Ticket', u'Fare', u'Cabin', u'Embarked'],
          dtype='object')
    #数据的列索引有12个    
    
        titanic_data.describe()
    Out[19]: 
           PassengerId    Survived      Pclass         Age       SibSp  \
    count   891.000000  891.000000  891.000000  714.000000  891.000000   
    mean    446.000000    0.383838    2.308642   29.699118    0.523008   
    std     257.353842    0.486592    0.836071   14.526497    1.102743   
    min       1.000000    0.000000    1.000000    0.420000    0.000000   
    25%     223.500000    0.000000    2.000000   20.125000    0.000000   
    50%     446.000000    0.000000    3.000000   28.000000    0.000000   
    75%     668.500000    1.000000    3.000000   38.000000    1.000000   
    max     891.000000    1.000000    3.000000   80.000000    8.000000   
    
                Parch        Fare  
    count  891.000000  891.000000  
    mean     0.381594   32.204208  
    std      0.806057   49.693429  
    min      0.000000    0.000000  
    25%      0.000000    7.910400  
    50%      0.000000   14.454200  
    75%      0.000000   31.000000  
    max      6.000000  512.329200 
    #显示的是数据的统计信息
    #12列中只显示了数值型的8个,其中Age列中统计只有714个,原因是缺失值的存在
    

    2、数据预处理

    - 冗余信息删除
    - 缺失值处理
    - 非数值型数据转换成数据值
    - 异常值处理  
    
    
    #分析数据每一列,可知'PassengerId'是冗余信息,以及'Name','Ticket','Cabin'三者较为复杂,选择删除四列
    titanic_data = titanic_data.drop(['Name','PassengerId','Ticket','Cabin'],1)
    
    
    ############################'Sex'二值化
    titanic_data.loc[titanic_data['Sex']=='male','Sex'] = 0
    titanic_data.loc[titanic_data['Sex']=='female','Sex'] = 1
    
    
    ###########################'Age'缺失值处理
    #i)用中位数填充缺失值
    titanic_data['Age'] = titanic_data['Age'].fillna(titanic_data['Age'].median())
    #ii)用回归预测填充缺失值
    age_df = titanic_data[['Age','Sex','Fare', 'Parch', 'SibSp', 'Pclass']]
    age_df_notnull = age_df.loc[(titanic_data.Age.notnull())]
    age_df_isnull = age_df.loc[(titanic_data.Age.isnull())]
    X = age_df_notnull.values[:, 1:]
    Y = age_df_notnull.values[:, 0]
    rfr = RandomForestRegressor(n_estimators=1000, n_jobs=-1)
    rfr.fit(X, Y)
    predictAges = rfr.predict(age_df_isnull.values[:, 1:])
    titanic_data.loc[(titanic_data.Age.isnull()), 'Age'] = predictAges
    
    
    ###########################'Embarked'
    titanic_data['Embarked'] = titanic_data['Embarked'].fillna('S')
    #i)用数值代替
    titanic_data.loc[titanic_data['Embarked']=='S','Embarked'] = 0
    titanic_data.loc[titanic_data['Embarked']=='C','Embarked'] = 1
    titanic_data.loc[titanic_data['Embarked']=='Q','Embarked'] = 2
    #ii)用二元值代替
    dummies_titanic_data = pd.get_dummies(titanic_data.Embarked)
    dummies_titanic_data = dummies_titanic_data.rename(columns=lambda x:'Embarked_'+str(x))
    titanic_data = pd.concat([titanic_data,dummies_titanic_data],axis=1)
    
    
    #########################'Fare'
    #titanic_data['Fare'][np.where(titanic_data['Fare']==0)[0] ] = titanic_data['Fare'][ titanic_data['Fare'].nonzero()[0] ].min() / 10
    

    3、模型选择

    from sklearn.ensemble import RandomForestClassifier
    from sklearn.ensemble import GradientBoostingClassifier
    from sklearn import cross_validation
    
    ######################RandomForest调参、交叉验证
    
    results = []
    sample_leaf_options = list(range(1, 50, 3))
    n_estimators_options = list(range(50, 300,5))
    
    for leaf_size in sample_leaf_options:
        for n_estimators_size in n_estimators_options:
            titanic_forest = RandomForestClassifier(min_samples_leaf=leaf_size, n_estimators=n_estimators_size, random_state=50)
            #titanic_forest.fit(train_data[0::,1::],train_data[0::,0].astype(int))
            #print titanic_forest.feature_importances_
            scores = cross_validation.cross_val_score(titanic_forest,train_data[0::,1::],train_data[0::,0].astype(int),cv=5)
            print scores.mean()
            results.append((leaf_size, n_estimators_size,scores.mean() ))
    print(max(results, key=lambda x: x[2]))
    
    
    ####################GBDT调参、交叉验证
    results = []
    n_estimators_options = list(range(10, 1000,10))
    for n_estimators_size in n_estimators_options:
        titanic_forest = GradientBoostingClassifier(n_estimators=n_estimators_size, random_state=50)
        #titanic_forest.fit(train_data[0::,1::],train_data[0::,0].astype(int))
        #print titanic_forest.feature_importances_
        scores = cross_validation.cross_val_score(titanic_forest,train_data[0::,1::],train_data[0::,0].astype(int),cv=5)
        print scores.mean()
        results.append((n_estimators_size,scores.mean() ))
    print(max(results, key=lambda x: x[1]))
    
    展开全文
  • Titanic数据分析

    2020-05-18 23:58:13
    titanic = pd.read_csv(r"自己电脑上这个文件的路径\train.csv") # 快速预览 print(titanic.head()) print(titanic.info()) # 把所有数值类型的数据做一个简单的统计 print(titanic.describe()) #desc

    利用Pandas对泰坦尼克数据进行分析

    1.导入数据

    导入数据,对数据做个简单的统计

    import pandas as pd
    import matplotlib.pyplot as plt
    # 导入数据
    titanic = pd.read_csv(r"自己电脑上这个文件的路径\train.csv")
    # 快速预览
    print(titanic.head())
    print(titanic.info())
    # 把所有数值类型的数据做一个简单的统计
    print(titanic.describe())   #describe函数比info函数功能更强大,统计所有非空数据的条数,mean平均值,std标准差,min和max最小最大值
    # 统计null值个数
    print(titanic.isnull().sum())
    

    2. 处理空值

    # 可以填充整个dataframe里面的空值
    # titanic.fillna(0)  #将空值都填充为0
    # 单独选择一列进行空值填充
    # titanic.Age.fillna(0)
    # 年龄用0填充不合适,可以用中位数进行填充
    # 年龄的中位数
    print(titanic.Age.median())  #输出结果为28
    # 按年龄中位数去填充,此时返回一个新的series
    print(titanic.Age.fillna(titanic.Age.median()))
    # 直接填充,并不返回新的series
    titanic.Age.fillna(titanic.Age.median(), inplace = True)
    # 再次查看Age的空值
    print(titanic.isnull().sum())    #此时发现,age的空值为0了
    

    3. 尝试从性别进行分析

    
    # 做简单的汇总统计,value_counts这个函数会经常用到
    print(titanic.Sex.value_counts())   #男性577,女性314
    # 生还者中,男女的人数
    survived = titanic[titanic.Survived==1].Sex.value_counts()
    print(survived)   #男性109,女性233
    # 未生还者中,男女的人数
    dead = titanic[titanic.Survived==0].Sex.value_counts()
    print(dead)        #男性468,女性81
    

    在这里插入图片描述

    3.1. 尝试绘图

    先看一下画出的柱状图是什么样的

    # 尝试用pandas自带绘图
    df = pd.DataFrame([survived, dead],index = ['survived', 'dead'])   # 由于汇总统计输出的数据类型是series,有两列,所以可以用dataframe构建
    df.plot.bar()
    plt.show()
    

    绘图成功,但是不是我们想要的效果
    我们想把女性的死亡和生还人数画一起,把男性的死亡和生还人数画一起,这时候我们可以把dataframe转置一下

    df = df.T
    print(df)
    

    在这里插入图片描述
    转置成功,这时候再画一下

    仍然不是我们想要的结果
    尝试把直方图堆积在一起,直观一点

    df.plot(kind = 'bar', stacked = True)
    plt.show()
    

    效果如图:

    由于男女人数不一样,没法直观看到男女生还人数的百分比

    df['p_survived'] = df.survived / (df.survived + df.dead)
    df['p_dead'] = df.dead / (df.survived + df.dead)
    print(df)
    

    在这里插入图片描述此时生还和死亡的百分比就出来了,女性的死亡和生还的百分比相加是100%。注意分母要用括号括起来!

    下面绘制男女中生还者的比例情况的图

    # 男女中生还者的比例情况
    df['p_survived'] = df.survived / (df.survived + df.dead)
    df['p_dead'] = df.dead / (df.survived + df.dead)
    df[['p_survived','p_dead']].plot(kind='bar', stacked = True)
    plt.show()
    

    通过上图可以看出,性别特征对是否生还的影响还是挺大的

    4. 从年龄进行分析

    # 简单统计
    print(titanic.Age.value_counts())
    

    在这里插入图片描述
    与性别类似,对年龄进行Dataframe,打印看一下

    # 因为年龄只有一列数据,不适合用柱状图,这里尝试用直方图画一下
    # 生还者的年龄
    survived = titanic[titanic.Survived==1].Age
    # 未生还者的年龄
    dead = titanic[titanic.Survived==0].Age
    df = pd.DataFrame([survived,dead], index=['survived','dead'])
    df = df.T
    print(df)
    

    在这里插入图片描述
    绘制直方图

    df.plot.hist()
    plt.show()
    

    在这里插入图片描述可以看到,由于死亡人数比生还的多,把生还盖过了。我们还是用stacked

    df.plot.hist(stacked = True)
    plt.show()
    

    在这里插入图片描述可以看到,图片自动将柱子设为了10根,我们可以放多一点

    df.plot.hist(stacked = True, bins=30)   #将柱子根数设为30根
    plt.show()
    

    中间很高的柱子,因为我们把空值都替换为了中位数
    在这里插入图片描述
    此时可以看出死亡人数比生还者多,但是具体多多少还是不容易看出
    我们可以借用密度图,更直观一点

    # 密度图
    df.plot.kde()
    plt.show()
    

    这里记得安装scipy安装包,否则会报错。安装方法跟我前几篇博客一样的。
    在这里插入图片描述在0~16岁的区间内,生还者要多些。到20岁,死亡人数明显上升。到了30岁以后,基本死亡和生还人数趋于一致了。

    用describe函数看一下Age的分布信息

    # 可以查看年龄的分布,来决定我们图片横轴的取值范围
    print(titanic.Age.describe())
    

    在这里插入图片描述
    发现年龄在0.42-80岁之间,但是我们绘制出来的密度图区间在-40~120
    于是我们对横轴的取值范围进行限制

    df.plot.kde(xlim=(0,80))
    plt.show()
    

    在这里插入图片描述从上图可知,年龄对生还的影响还是挺大的。10岁之前,生还的几率比较大,20-30岁生还的几率就变小了,死亡率增高了

    以上都是把年龄作为线性数据来分析,我们还可以按年龄简单地分为两类,成年人和未成年人,来进行聚类分析。
    以后如果碰到数据比较适合聚类分析的话,可以想想怎么做。

    1.首先我们把成年人和未成年人的生还与死亡人数的柱状图画出来

    age = 16
    young = titanic[titanic.Age<=age]['Survived'].value_counts()
    old = titanic[titanic.Age>age]['Survived'].value_counts()
    df = pd.DataFrame([young,old],index=['young','old'])
    df.columns = ['dead','survived']
    df.plot.bar(stacked = True)
    plt.show()
    

    在这里插入图片描述
    2.与性别一样,我们把成年人和未成年生还者的比例情况画出来

    # 成年人和未成年生还者的比例情况
    df['p_survived'] = df.survived / (df.survived + df.dead)
    df['p_dead'] = df.dead / (df.survived + df.dead)
    df[['p_survived','p_dead']].plot(kind='bar', stacked = True)
    plt.show()
    

    在这里插入图片描述

    5.分析票价

    我们查看下图票价数据特征可知,票价特征跟年龄相似,都是一列数字。所以处理上会跟年龄差不多,我们这里直接画密度图就好了。

    print(titanic.Fare)
    

    在这里插入图片描述画密度图要设定xlim范围的话,先查看票价的范围

    survived = titanic[titanic.Survived==1].Fare
    dead = titanic[titanic.Survived==0].Fare
    df = pd.DataFrame([survived,dead], index=['survived','dead'])
    df = df.T
    df.plot.kde(xlim=[0,513])
    # 设定xlim范围,先查看票价的范围
    # print(titanic.Fare.describe())
    plt.show()
    

    可以看到,票价的范围是0-512.3,所以我们设置取值范围为0-513就可以。
    在这里插入图片描述
    票价的密度图如下:
    在这里插入图片描述由上图,可以看出票价对生还的影响。从大概50的地方,低票价的人,生还率比较低。

    6.组合特征

    比如同时查看年龄的票价对生还率的影响
    我们将年龄作横轴,票价作纵轴,绘制散点图

    import matplotlib.pyplot as plt
    ax = plt.subplot()
    # 死亡
    age = titanic[titanic.Survived == 0].Age
    fare = titanic[titanic.Survived == 0].Fare
    plt.scatter(age, fare, s=10, marker='o',alpha=0.3,linewidths=1,edgecolors='gray')     #alpha参数表示透明度
    # 生还者
    age = titanic[titanic.Survived == 1].Age
    fare = titanic[titanic.Survived == 1].Fare
    plt.scatter(age, fare, s=10, marker='o',alpha=0.3,linewidths=1,edgecolors='red')
    
    ax.set_xlim(min(age),max(age))
    ax.set_ylim(min(fare),max(fare))
    
    ax.set_xlabel('age')    #横轴显示标签age, scatter函数没有label参数,所以我们另外设置一下
    ax.set_ylabel('fare')   #纵轴显示标签fare
    plt.show()
    

    在这里插入图片描述
    从上图我们可以分析,
    蓝色点表示生还者,大部分年龄都是50岁以下
    图形大致呈现三角形,说明票价高的还是占少部分
    红色点表示未生还者,大部分票价都在100以下
    在100以上红色点比蓝色点多

    7.隐含特征

    7.1 Name

    Name里面有一些Mr.、Miss. 这样的称呼,都是带点的,我们可以把这些名字提取出来

    同样,用describe函数查看以下Name数据的特征
    在这里插入图片描述
    把称呼提取出来,放到title列下

    titanic['title'] = titanic.Name.apply(lambda name:name.split(',')[1].split('.')[0].strip())
    s = 'Pernot, Mr. Rene'
    print(s.split(',')[-1].split('.')[0].strip())
    

    代码的意思是:首先从,把两边分开,获取到’Pernot’和‘ Mr. Rene’,取最后一位,‘Mr. Rene’,将它从.两边分开,得到‘ Mr’和‘ Rene’,取第一位,得到‘ Mr’,最后用strip函数将两边空格删除,返回Mr

    此时,title已经插入进表格的最后一列,都是称谓

    # 简单地统计称谓
    print(titanic.title.value_counts())
    

    在这里插入图片描述提取这个有啥用呢?
    比如有一个人被称为Mr,而年龄是不知道的,这个时候可以用所有Mr的年龄平均值来替代,而不是我们之前简单地用中位数填充。

    7.2 GDP

    当需要评估一个地区的经济状况, 手头又没有数据,应该学会从一些隐含特征中提取一些有效特征。比如用夜光图,简单用灯光图的亮度来模拟GDP

    7.3 家族分类

    按家族人数的数量分成一个小的类别
    SibSp 兄弟姐妹的数量
    Parch 子女的数量

    titanic['family_size'] = titanic.SibSp + titanic.Parch +1   #加上自己
    print(titanic)
    

    在这里插入图片描述统计一下family_size

    print(titanic.family_size.value_counts())
    

    在这里插入图片描述
    可以看到大多数人还是属于1

    还可以对family_size进行聚类,首先分成Singleton,SmallFamily,LargeFamily三类

    def func(family_size):
        if family_size ==1:
            return 'Singleton'
        if family_size <=4 and family_size >=2:
            return 'SmallFamily'
        if family_size >4:
            return 'LargeFamily'
    
    titanic['family_type'] = titanic.family_size.apply(func)  # 根据现有的列生成新的列用apply函数
    print(titanic)
    

    打印看一下,生成了新的列family_type
    在这里插入图片描述统计一下family_type
    print(titanic.family_type.value_counts())
    在这里插入图片描述

    展开全文
  • Titanic

    2016-12-15 09:58:02
    It is a historical fact that during the legendary voyage of "Titanic" the wireless telegraph machine had delivered 6 warnings about the danger of icebergs. Each of the telegraph messages described the...
  • titanic1.ipynb

    2019-12-19 12:02:48
    2.对数据分析的流程做了一个文本的总结。 由数据探索-->特征工程-->建模三部分组成 2.1 数据探索:探索特征的类型,缺失情况等等 2.2 特征工程:简要介绍数据的填充,删除,增补等等方法 2.3 建模:对可以使用的...
  • Titanic-乘客生存预测2

    2020-03-14 17:57:22
    代码所需数据集:https://github.com/jsusu/Titanic_Passenger_Survival_Prediction_2/tree/master/titanic_data import re import numpy as np import pandas as pd import matplotlib.pyplot as plt import ...
  • 有几种不同算法的代码,但主要和性能最高的一种是在 randomforest2.py 中实现的 RandomForest。 要求: python(2.x 版本至少为 2.6) scikit-learn/NumPy/SciPy ( ) 熊猫( ) matplotlib ( ) 用法: > ...
  • 泰坦尼克号v2-aka使用回归 预测是相同的。
  • titanic-源码

    2021-04-01 14:25:27
    这是在世界最大的资料科学共同体-Kaggle上被视为资料科学家们的第一个竞赛,因此总参加队伍也达到2万7千多队。而我也想将其当作踏入Kaggle的第一道关卡,附件为我这次比赛的代码及详细资讯 要求 脾气暴躁的 大熊猫 ...
  • Titanic这也算是一个很经典的案例了,详情见【官网详情】(博主提交了一次,很菜七千多名,正确率:0.76555,排名有点渣,日后再优化,优化后,到两千多哈哈,0.79....左右,,还有很大的上升空间)分析一个案例我...
  • Titanic_Data analysis

    2020-08-20 01:26:23
    Part 1:探索titanic数据集 import numpy as np import pandas as pd # 读取文件,并查看文件的前三行 df = pd.read_csv('train.csv') df.head(3) PassengerId Survived Pclass Name Sex Age SibSp ...
  • Titanic生存率预测

    2020-03-20 23:33:45
    提出问题2.理解数据2.1采集数据2.2导入数据2.3查看数据集信息3.数据清洗3.1数据预处理3.2特征工程3.2.1数据分类3.2.2特征选择4.构建模型4.1建立训练数据集和测试数据集4.2选择机器学习算法4.3训练模型5.评估模型6....
  • Kaggle-Titanic入门教程2

    2018-05-31 23:25:24
    与在Embarked = C和Q的Pclass = 2的男性相比,Pclass=3的男性有更好的存活率。基于数据分析的假设.填充 #2。 对于Pclass=3的男性乘客而言,不同登船口有不同的存活率。基于数据分析的假设.关联 #1。 决策 ...
  • Kaggle Titanic数据分析和预测

    千次阅读 2018-06-16 21:12:32
    本文对Kaggle中的Titanic事故中乘客遇难情况进行了相应的分析和可视化,采用逻辑回归对他们的遇难情况进行了预测。
  • '2' '1' '1' ... , '71.2833' 'C85' 'C' ] [ '3' '1' '3' ... , '7.925' '' 'S' ] ... , [ '889' '0' '3' ... , '23.45' '' 'S' ] [ '890' '1' '1' ... , '30' 'C...
  • 下载地址:https://www.kaggle.com/c/titanic/data 数据集中有三个文件,一个是训练集,一个是测试集,还有一个是提交的答案范例。 本次仅使用训练集。 sklearn实战 导入库 import pandas as pd from sklearn.tree ...
  • kaggle实战——titanic分析
  • 数据字典: Variable Definition Key survival Survival 0 = No, 1 = Yes pclass Ticket class 1 = 1st, 2 = 2nd, 3 = 3rd sex Sex Age Age in years sibsp # of siblings / spouses aboard the Titanic parch # of...
  • Titanic 模型评估

    2019-01-10 13:38:58
    1.逻辑回归 #evaluate logisitic model X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_...2.支持向量机 3.决策树 4.随机森林 5.xgboost

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,603
精华内容 3,441
关键字:

2titanic