精华内容
下载资源
问答
  • 题目提供的训练数据集包含11个特征,分别是: Survived:0代表死亡,1代表存活 Pclass:乘客所持票类,有三种值(1,2,3) Name:乘客姓名 Sex:乘客性别 Age:乘客年龄(有缺失) SibSp:乘客兄弟姐妹/配偶的个数(整数值) ...
  • 来自Kaggle泰坦尼克号数据集,包括测试集和训练集。用于决策树算法。
  • 暂无描述
  • **主要是让参赛选手根据训练集中的乘客数据和存活情况进行建模,进而使用模型预测测试集中的乘客是否会存活。乘客特征总共有11个,以下列出。当然也可以根据情况自己生成新特征,这就是特征工程(feature ...
  • Kaggle泰坦尼克号竞赛:探索性数据分析和机器学习模型构建 项目动机: 此项目是Udacity Data Scientist纳米学位论文的一部分 泰坦尼克号灾难是历史上最著名的海难之一。 泰坦尼克号与冰山相撞后,沉入冰冷的北...
  • Kaggle泰坦尼克号竞争:Kaggle泰坦尼克号比赛回购
  • 泰坦尼克号 在通过《泰坦尼克号》示例了解Kaggle时回购
  • Kaggle泰坦尼克号之灾

    2019-01-10 09:22:37
    kaggle比赛地址: Titanic: Machine Learning from Disaster 相关比赛背景、数据等都可在网站查看。 1、环境配置 windows 10 python 3.6 pandas numpy jupyter notebook seaborn  2、数据分析 # 载入...

    kaggle比赛地址:

    Titanic: Machine Learning from Disaster

    相关比赛背景、数据等都可在网站查看。

    1、环境配置

    • windows 10
    • python 3.6
    • pandas
    • numpy
    • jupyter notebook
    • seaborn

     2、数据分析

    # 载入pandas包来读取csv格式的数据集
    import pandas as pd
    import numpy as np
    
    # 把csv格式的数据集导入到DataFrame对象中
    df_train = pd.read_csv('train.csv')
    df_test = pd.read_csv('test.csv')
    all_data = pd.concat([df_train, df_test], ignore_index = True)
    all_data.head()

     输出结果

    特征属性解释

    VariableDefinitionKeyDescription意义
    PassengerIdPassenger Id  乘客ID
    SurvivedSurvival

    0 = No,

    1 = Yes

     是否获救
    PclassTicket class

    1 = 1st,

    2 = 2nd,

    3 = 3rd

    A proxy for socio-economic status (SES)
    1st = Upper
    2nd = Middle
    3rd = Lower
    乘客等级
    NameName  乘客姓名
    SexSex  性别
    AgeAge in years Age is fractional if less than 1. If the age is estimated, is it in the form of xx.5年龄
    SibSp# of siblings / spouses aboard the Titanic The dataset defines family relations in this way...
    Sibling = brother, sister, stepbrother, stepsister
    Spouse = husband, wife (mistresses and fiancés were ignored)
    配偶和兄弟姐妹人数
    Parch# of parents / children aboard the Titanic 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.
    父母与小孩人数
    TicketTicket number  船票号码
    FarePassenger fare  票价
    CabinCabin number  客舱号码
    EmbarkedPort of Embarkation

    C = Cherbourg,

    Q = Queenstown,

    S = Southampton

     登船港口

    查看数据详情

    all_data.info()
    

    打印结果 

    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 1309 entries, 0 to 1308
    Data columns (total 12 columns):
    Age            1046 non-null float64
    Cabin          295 non-null object
    Embarked       1307 non-null object
    Fare           1308 non-null float64
    Name           1309 non-null object
    Parch          1309 non-null int64
    PassengerId    1309 non-null int64
    Pclass         1309 non-null int64
    Sex            1309 non-null object
    SibSp          1309 non-null int64
    Survived       891 non-null float64
    Ticket         1309 non-null object
    dtypes: float64(3), int64(4), object(5)
    memory usage: 122.8+ KB

    数据大小为1309行*12列,但不少属性包含空值

    再看看具体描述,数值型特征属性详情

    all_data.describe()

    输出结果

                   Age         Fare        Parch  PassengerId       Pclass  \
    count  1046.000000  1308.000000  1309.000000  1309.000000  1309.000000   
    mean     29.881138    33.295479     0.385027   655.000000     2.294882   
    std      14.413493    51.758668     0.865560   378.020061     0.837836   
    min       0.170000     0.000000     0.000000     1.000000     1.000000   
    25%      21.000000     7.895800     0.000000   328.000000     2.000000   
    50%      28.000000    14.454200     0.000000   655.000000     3.000000   
    75%      39.000000    31.275000     0.000000   982.000000     3.000000   
    max      80.000000   512.329200     9.000000  1309.000000     3.000000   
    
                 SibSp    Survived  
    count  1309.000000  891.000000  
    mean      0.498854    0.383838  
    std       1.041658    0.486592  
    min       0.000000    0.000000  
    25%       0.000000    0.000000  
    50%       0.000000    0.000000  
    75%       1.000000    1.000000  
    max       8.000000    1.000000  

    乘客平均存活率约0.39,平均年龄约29.7岁

    再看非数值型特征属性详情

    all_data.describe(include=['O'])

     输出

                  Cabin Embarked              Name   Sex    Ticket
    count           295     1307              1309  1309      1309
    unique          186        3              1307     2       929
    top     C23 C25 C27        S  Kelly, Mr. James  male  CA. 2343
    freq              6      914                 2   843        11
    

    使用图表直观分析数据,调用matplotlib库

    import matplotlib.pyplot as plt
    import seaborn as sns
    
    plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
    plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
    
    fig = plt.figure()
    fig.set(alpha=0.2) # 设定图表颜色alpha参数
    
    ………………
    ………………
    ………………
    
    plt.show()
    
    

    分别根据不同特征属性分析获救情况

    def Survived():
        fig = plt.figure()
        fig.set(alpha=0.2) # 设定图表颜色alpha参数
        # 查看总体获救情况
        all_data['Survived'].value_counts().plot(kind='bar')
        plt.title(u"是否获救情况(1为获救)")
        plt.ylabel(u"人数")
    Survived()

    由于客观因素船上救生艇不足,导致大部分人没有获救

    def Pclass():
        # 查看不同Pclass获救情况
        sur_pcl1 = all_data['Pclass'][all_data['Survived'] == 1].value_counts()
        sur_pcl0 = all_data['Pclass'][all_data['Survived'] == 0].value_counts()
        sur_pcl = pd.DataFrame({u'获救':sur_pcl1,u'未获救':sur_pcl0})
        sur_pcl.plot(kind='bar', stacked=True)
        plt.title(u"不同乘客等级的获救情况")
        plt.xlabel(u"乘客等级")
        plt.ylabel(u"人数")
    Pclass()

    sns.barplot(x="Pclass", y="Survived", data=all_data)

     

    乘客等级为1的乘客获救率最高,社会等级高的人获救几率高

    def Sex():
        # 查看不同Sex获救情况
        sur_sex1 = all_data['Sex'][all_data['Survived'] == 1].value_counts()
        sur_sex0 = all_data['Sex'][all_data['Survived'] == 0].value_counts()
        sur_sex = pd.DataFrame({u'获救':sur_sex1,u'未获救':sur_sex0})
        print(sur_sex)
        sur_sex.plot(kind='bar', stacked=True)
        plt.title(u"不同性别的获救情况")
        plt.xlabel(u"性别")
        plt.ylabel(u"人数")
        # # fig = plt.figure()(6)
    Sex()

    sns.barplot(x="Sex", y="Survived", data=all_data)

     

     救援时先救女性,再救男性,所以女性存活率高

    # 查看不同Age获救情况
    sur_age = sns.FacetGrid(all_data, col='Survived')
    sur_age.map(plt.hist, 'Age', bins=20)
    

    sur_age.map(sns.distplot, 'Age', bins=20)

     

     

    sur_age = sns.FacetGrid(all_data, hue="Survived",aspect=2)
    sur_age.map(sns.kdeplot,'Age',shade= True)
    sur_age.set(xlim=(0, all_data['Age'].max()))
    sur_age.add_legend()
    plt.xlabel('Age')
    plt.ylabel('density')

     

    年龄小于15岁的存货超过半数,获救率更高,一般救援时,妇女儿童是首先需要救援的对象,也符合上面的规律

    def Embarked():
        # 查看不同Embarked获救情况
        sur_emb1 = all_data['Embarked'][all_data['Survived'] == 1].value_counts()
        sur_emb0 = all_data['Embarked'][all_data['Survived'] == 0].value_counts()
        sur_emb = pd.DataFrame({u'获救':sur_emb1,u'未获救':sur_emb0})
        sur_emb.plot(kind='bar', stacked=True)
        plt.title(u"不同登陆港口的获救情况")
        plt.xlabel(u"登陆港口")
        plt.ylabel(u"人数")
    Embarked()

    sns.barplot(x="Embarked", y="Survived", data=all_data)

     

    C港口登陆的乘客一半以上获救,获救率最高

    sns.barplot(x="SibSp", y="Survived", data=all_data)

     

     配偶和兄弟姐妹人数适中获救率更高

    sns.barplot(x="Parch", y="Survived", data=all_data)

     

    父母和子女人数适中获救率更高,但总体差异不大

    # 查看不同Name的称呼的获救情况
    all_data['Title'] = all_data['Name'].apply(lambda x:x.split(',')[1].split('.')[0].strip())
    sns.barplot(x="Title", y="Survived", data=all_data)

     

     称谓包含这几种

    {'Capt', 'Sir', 'Miss', 'Mlle', 'Don', 'Ms', 'Jonkheer', 'Mme', 'Col', 'Dr', 'Major', 'Rev', 'the Countess', 'Mrs', 'Lady', 'Master', 'Mr'}

     对其进行归类

    Title_Dict = {}
    Title_Dict.update(dict.fromkeys(['Capt', 'Col', 'Major', 'Dr', 'Rev'], 'Officer'))
    Title_Dict.update(dict.fromkeys(['Don', 'Sir', 'the Countess', 'Dona', 'Lady'], 'Royalty'))
    Title_Dict.update(dict.fromkeys(['Mme', 'Ms', 'Mrs'], 'Mrs'))
    Title_Dict.update(dict.fromkeys(['Mlle', 'Miss'], 'Miss'))
    Title_Dict.update(dict.fromkeys(['Mr'], 'Mr'))
    Title_Dict.update(dict.fromkeys(['Master','Jonkheer'], 'Master'))
    
    all_data['Title'] = all_data['Title'].map(Title_Dict)
    sns.barplot(x="Title", y="Survived", data=all_data)

    除了之前分析的女性生存率高,登记时登记['Don', 'Sir', 'the Countess', 'Dona', 'Lady']的贵族生存率也很高

    # 家庭成员数
    all_data['FamilySize'] = all_data['SibSp'] + all_data['Parch'] + 1
    sns.barplot(x="FamilySize", y="Survived", data=all_data)

     

    把家庭成员人数分成4类,单身狗、一般夫妻或一般家庭、兄弟姐妹孩子有点多家庭、大家族。。。

    def Fam_label(s):
        if (s == 1):
            return 1
        elif (2 <= s <= 4):
            return 2
        elif (4 < s <= 7):
            return 3
        elif (s > 7):
            return 4
    all_data['FamilyLabel'] = all_data['FamilySize'].apply(Fam_label)
    sns.barplot(x="FamilyLabel", y="Survived", data=all_data)

     

    一般家庭生存率比较高 

    # 不同船舱分析
    all_data['Cabin'] = all_data['Cabin'].fillna('Unknown')
    all_data['Deck'] = all_data['Cabin'].str.get(0)
    sns.barplot(x="Deck", y="Survived", data=all_data)

     

     不同船舱距离救生船附近的距离不同,可能导致离得近的或者高级舱存活率高

     

    # 共票人数分析
    Ticket_Count = dict(all_data['Ticket'].value_counts())
    all_data['TicketGroup'] = all_data['Ticket'].apply(lambda x:Ticket_Count[x])
    sns.barplot(x='TicketGroup', y='Survived', data=all_data)

     

    把共票人数分组 

    def Ticket_Label(s):
    	if (s == 1):
    		return 1
    	elif (2 <= s <= 4):
    		return 2
    	elif (4 < s <= 7):
    		return 3
    	elif (s > 7):
    		return 4
    
    all_data['TicketGroup'] = all_data['TicketGroup'].apply(Ticket_Label)
    sns.barplot(x='TicketGroup', y='Survived', data=all_data)

     

     一般共票的都是家庭票居多

    3、数据清洗

    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 1309 entries, 0 to 1308
    Data columns (total 12 columns):
    Age            1046 non-null float64
    Cabin          295 non-null object
    Embarked       1307 non-null object
    Fare           1308 non-null float64
    Name           1309 non-null object
    Parch          1309 non-null int64
    PassengerId    1309 non-null int64
    Pclass         1309 non-null int64
    Sex            1309 non-null object
    SibSp          1309 non-null int64
    Survived       891 non-null float64
    Ticket         1309 non-null object
    dtypes: float64(3), int64(4), object(5)
    memory usage: 122.8+ KB

     Age缺失值较多,缺少1309-1046=263,需要补值,此处采用随机森林生成空值的方法,选取Pcalss、Sex、Title三个特征建模

    from sklearn.ensemble import RandomForestRegressor
    age_df = all_data[['Age', 'Pclass','Sex','Title']]
    # 利用get_dummies()进行独热编码,将拥有不同值的变量转换为0/1数值
    age_df = pd.get_dummies(age_df)
    known_age = age_df[age_df.Age.notnull()].as_matrix()
    unknown_age = age_df[age_df.Age.isnull()].as_matrix()
    y = known_age[:, 0]
    X = known_age[:, 1:]
    # 随机森林,n_estimators建立子树的数量,random_state指定随机生成一个确定的结果,n_jobs使用多少引擎处理
    rfr = RandomForestRegressor(random_state=0, n_estimators=100, n_jobs=-1)
    rfr.fit(X, y)
    predictedAges = rfr.predict(unknown_age[:, 1::])
    all_data.loc[ (all_data.Age.isnull()), 'Age' ] = predictedAges

    Embarked的缺失值很少,缺少2个,打印相关信息

    TicketGroup()
    
    output:
          Age Cabin Embarked  Fare                                       Name  \
    61   38.0   B28      NaN  80.0                        Icard, Miss. Amelie   
    829  62.0   B28      NaN  80.0  Stone, Mrs. George Nelson (Martha Evelyn)   
    
         Parch  PassengerId  Pclass     Sex  SibSp  Survived  Ticket Title  \
    61       0           62       1  female      0       1.0  113572  Miss   
    829      0          830       1  female      0       1.0  113572   Mrs   
    
         FamilySize  FamilyLabel Deck  TicketGroup  
    61            1            1    B            2  
    829           1            1    B            2  

    这两位都是Pclass=1,女性,共票,Fare=80,Cabin=B28 ,SibSp=0,Parch=0,推测两个人可能是认识的

    sns.countplot('Embarked',hue='Survived',data=all_data)

     

    print(all_data.describe())
    
    output:
                   Age         Fare        Parch  PassengerId       Pclass  \
    count  1309.000000  1308.000000  1309.000000  1309.000000  1309.000000   
    mean     29.519228    33.295479     0.385027   655.000000     2.294882   
    std      13.417745    51.758668     0.865560   378.020061     0.837836   
    min       0.170000     0.000000     0.000000     1.000000     1.000000   
    25%      21.000000     7.895800     0.000000   328.000000     2.000000   
    50%      28.226256    14.454200     0.000000   655.000000     3.000000   
    75%      36.500000    31.275000     0.000000   982.000000     3.000000   
    max      80.000000   512.329200     9.000000  1309.000000     3.000000   
    
                 SibSp    Survived   FamilySize  FamilyLabel  TicketGroup  
    count  1309.000000  891.000000  1309.000000  1309.000000  1309.000000  
    mean      0.498854    0.383838     1.883881     1.473644     1.568373  
    std       1.041658    0.486592     1.583639     0.658014     0.716308  
    min       0.000000    0.000000     1.000000     1.000000     1.000000  
    25%       0.000000    0.000000     1.000000     1.000000     1.000000  
    50%       0.000000    0.000000     1.000000     1.000000     1.000000  
    75%       1.000000    1.000000     2.000000     2.000000     2.000000  
    max       8.000000    1.000000    11.000000     4.000000     4.000000  
    

    打印出不同Pclass、Embarked的票价中位数

    print(all_data.groupby(by=["Pclass","Embarked"]).Fare.median())
    
    output:
    Pclass  Embarked
    1       C           76.7292
            Q           90.0000
            S           52.0000
    2       C           15.3146
            Q           12.3500
            S           15.3750
    3       C            7.8958
            Q            7.7500
            S            8.0500
    Name: Fare, dtype: float64

    输出可以看出,Pclass=1、Fare=80的人群中,大概率从Embarked=C港口出发,填充C

    all_data['Embarked'] = all_data['Embarked'].fillna('C')

    Cabin字段缺失值较多,考虑一部分确实可能是船上工作人员的房间,此处不作为特征进行预测,

    4、建模预测

    后续根据需要进行建模预测,选择随机森林、SVM等……

    展开全文
  • 平台下载的原始三个数据train.csv test.csv gender_submission.csv (本来想0积分 分享给大家 无奈最低是1分了)
  • 友情提示,kaggle注册帐号发送验证邮件时验证码貌似是使用了谷歌的服务,如果没有梯子是刷不出验证码无法验证账号的,没有梯子的话可以考虑注册雅虎账号然后用雅虎账号登录kaggle。不过有时一些数据的下载好像也会...
  • kaggle泰坦尼克号生存预测(附代码、数据集和答案) 之前总结的数据预处理方法:https://blog.csdn.net/qq_43012160/article/details/98462307 先看一下数据集: 这次需要分类的标签被存储在了训练集的Survived列里...

    kaggle泰坦尼克号生存预测(附代码、数据集和答案)

    之前总结的数据预处理方法:https://blog.csdn.net/qq_43012160/article/details/98462307
    先看一下数据集:
    在这里插入图片描述
    这次需要分类的标签被存储在了训练集的Survived列里,1表示生还,0表示遇难。

    显然这次的特征是有缺失值的,读入数据集,看一下训练集和测试集的长度及各特征的缺失情况:
    在这里插入图片描述
    在这里插入图片描述

    #看一下训练集和测试集的各特征的缺失情况:
    for column in test_data.columns:
        print(column,':',train_data[column].count()/len(train_data),'  ',train_data[column].count())
        print(column,':',test_data[column].count()/len(test_data),'  ',test_data[column].count())
    

    发现最后有一个空白的特征列,多半是数据集存储的时候格式出了问题,把数据集的目录打出来看一下,果然,换行符\r被当作一个单独的列读了进来,后面要删掉:
    在这里插入图片描述

    特征工程

    观察数据,首先船舱号Cabin的缺失值太多了,缺失80%左右,这样有两种选择:
    一是给所有的缺失值补上记号UNKOWN作为缺失标记,
    二是直接删掉这一列。
    出于船舱号本身较为复杂、难以分析且考虑到降维的需要,这里选择直接删掉Cabin.
    在这里插入图片描述
    PassengerId肯定是和结果没关系的,删掉
    Ticket票号和Cabin一样情况复杂难以分析,删掉
    Name比较特殊,他其中是有一些有用的信息的,比如Mr和Mrs就蕴含了性别信息,而诸如master之类的尊称又可以反映社会地位(一定程度上和船舱号、消费等有关),因而其实是可以保留的。但是以来分析起来比较复杂,二来其携带的性别、社会地位、消费能力等信息可以从Sex、Fare等特征中得到反映,所以这里选择直接删掉。

    train_data=train_data.drop(['\r'],axis=1)
    test_data=test_data.drop(['\r'],axis=1)
    train_data=train_data.drop(['PassengerId'],axis=1)
    test_data=test_data.drop(['PassengerId'],axis=1)
    train_data=train_data.drop(['Name'],axis=1)
    test_data=test_data.drop(['Name'],axis=1)
    train_data=train_data.drop(['Cabin'],axis=1)
    test_data=test_data.drop(['Cabin'],axis=1)
    train_data=train_data.drop(['Ticket'],axis=1)
    test_data=test_data.drop(['Ticket'],axis=1)
    

    训练集缺失值的处理

    训练集有两个特征会有缺失值,一个是登船地点Embarked,另一个是年龄Age。总共占训练集的20%左右,
    对于训练集可以认为,在缺失数据不很多的情况下,存在缺失值的样本即坏样本,可以直接抛弃:

    #训练集有缺失的都是坏数据,删了:
    train_data.dropna(axis=0,inplace=True)
    trainLen=len(train_data)
    testLen=len(test_data)
    

    测试集缺失值的处理

    测试集因为需要预测,有缺失值就不能删了,对于确实不多的Fare列,我看了一下测试集和训练集数据的分布,在8左右有一个很明显的众数,所以就用测试集的众数来填补Fare的缺失值:

    #处理一下测试集里的缺失值,测试集的缺失数据不能删
    #处理Fare,先看一下分布,发现明显有个众数非常突出,且训练集和测试集众数接近:
    test_data['Fare']=test_data['Fare'].fillna(test_data['Fare'].dropna().mode()[0])
    

    由于Age是比较重要的数据(从后面的相关系数也可以看出),我们利用训练集和测试集中的其他特征对缺失的Age进行预测,然后补全。
    在预测Age之前,先对数据进行编码和归一化。

    编码和归一化

    考虑到数据间的量纲问题,对数据进行编码和归一化:

    #把训练集和测试集合起来编码:
    combineData=train_data.append(test_data)
    #先编码后拆分:
    def getReview(data,changeColumns):
        ResultReview=[]
        listReview=data
        le = LabelEncoder()
        for column in changeColumns:
            listData=[]
            for review in data[column]:
                listData.append(review)
            listReview[column]=le.fit_transform(listData)
        #向量化(需要一个个的append):
        for i in range(len(data)):
            rowVec=[]
            for j in range(0,len(data.columns)):
                rowVec.append(listReview.iloc[i,j])
            ResultReview.append(rowVec)
        return ResultReview
    
    changeColumns=['Sex','Embarked']
    combine_Review=np.array(getReview(combineData,changeColumns))
    scl = MinMaxScaler()
    combineReview=scl.fit_transform(combine_Review)
    trainReview=combineReview[0:trainLen]
    testReview=combineReview[trainLen:trainLen+testLen]
    

    之前一直有一个误区,就是会把训练集和测试集分开编码,其实这样是不对的,至少对于fit过程测试集和训练集是一定要在一起fit的,不然可能会出现这种情况;
    训练集:[2,2,3]->编码:2为0;3为1
    测试集:[3,3,2]->编码:3为0;2为1
    即两者可能会采取不同的编码方式,导致正确率下降。
    所以应该把测试集和训练集合在一起作为“词袋”一起训练编码器,然后在分开编码,或者先合在一起编码之后再拆开。

    预测Age

    由于是预测Age,所以我们可以将训练集和测试集中所有Age不为空的样本作为训练集,来预测Age为空的样本。Age的预测不是一个分类问题,而是一个回归问题,所以要用回归器而不是分类器进行预测,这里选择GradientBoostingRegressor和MLPRegressor进行预测之后取平均,重复三次之后再取平均作为最终Age的预测结果。

    #处理Age缺失值:
    #获取空元素下标:
    isNull=test_data['Age'].isnull().get_values()
    listAgeTrain=[]
    listAgeTest=[]
    for elem in trainReview:listAgeTrain.append(elem)
    for i in range(0,len(isNull)):
        if isNull[i]==False:listAgeTrain.append(testReview[i])
        else: listAgeTest.append(testReview[i])
    ageTrain = np.array(listAgeTrain)
    ageTest=np.array(listAgeTest)
    
    ageLable=ageTrain[:,2]
    ageTrain=np.delete(ageTrain,2,axis=1)
    ageTest=np.delete(ageTest,2,axis=1)
    
    #预测Age:
    print('预测测试集Age:')
    model1 = GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,
                                      learning_rate=0.03, loss='huber', max_depth=15,
                                      max_features='sqrt', max_leaf_nodes=None,
                                      min_impurity_decrease=0.0, min_impurity_split=None,
                                      min_samples_leaf=10, min_samples_split=40,
                                      min_weight_fraction_leaf=0.0, n_estimators=300,
                                      presort='auto', random_state=10, subsample=0.8, verbose=0,
                                      warm_start=False)#创建mlp神经网络对象
    model2=MLPRegressor(activation='tanh', learning_rate='adaptive')
    age_sum = []
    
    for i in range(0,3):
        print(i,'th training:')
        model1.fit(ageTrain,ageLable)#模型训练
        age_model1 = model1.predict(ageTest)#模型预测
        model2.fit(ageTrain,ageLable)#模型训练
        age_model2 = model2.predict(ageTest)#模型预测
        age_sum.append(age_model1*0.5+age_model2*0.5)
    
    age_model=[]
    for i in range(len(ageTest)):
        asum=0
        for j in range(0,3):
            asum=asum+age_sum[j][i]
        age_model.append(asum/3)
    print(age_model)
    
    #把求出来的age填回去:
    #先把空值的位置找出来:
    nullIndex=[]
    for i in range(0,len(isNull)):
        if isNull[i]==True:nullIndex.append(i)
    for i in range(0,len(nullIndex)):
        testReview[nullIndex[i],2]=age_model[i]
    

    去除离群点

    这里使用一个简单的基于概率分布的去除离群点的方法,即将各个特征的首尾部分的数据去掉,砍头去尾。
    这里就要谈到我对高维离群点的一些思考,多维空间中的离群点必然具备一个条件,即他会有至少一维大大偏离其他数据。即有至少一维大大偏离其他数据是点是离群点的必要不充分条件,因此在。程序中当某一个样本的任意特征属于前后6%,就会被删掉。这里的6%是我调参调出来的,一般在1%-5%左右:

    #去除离群点:
    rowLen=trainReview.shape[1]
    shallDel=[]
    for i in range(0,len(trainReview)):shallDel.append(0)
    for j in range(0,rowLen):
        min=np.percentile(trainReview[:,j],6)
        max = np.percentile(trainReview[:, j], 94)
        for i in range(0, len(trainReview)):
            if (trainReview[i,j]<min) or (trainReview[i,j]>max):shallDel[i]=1
    for i in range(len(trainReview)-1,-1,-1):
        if shallDel[i]==1:
            trainReview=np.delete(trainReview,i,axis=0)
            trainLable = np.delete(trainLable, i, axis=0)
    

    相关系数和方差

    看一下剩下的各组数据和Survived标签的相关系数,常用的三大相关系数是pearson相关系数、kendall相关系数和spearman相关系数,pearson相关系数更多的是反应线性关系,在面对形如y=x^2这种非线性关系的时候表现得差强人意,经过测试发现kendall相关系数的表现是很不错的。
    当然你也可以看一下各特征和Age的相关系数,或者特征的方差,然后做一下特征筛选:
    在这里插入图片描述

    rowLen=trainReview.shape[1]
    dfCorr=[]
    srLable = pd.Series(trainLable)
    for i in range(0,rowLen):
        srReview=pd.Series(trainReview[:,i])
        dfCorr.append(srReview.corr(srLable,method='kendall'))
    plt.bar(list(range(0,rowLen)),dfCorr)
    plt.show()
    

    值得注意的是方差也好、相关系数也好,只能作为特征和结果关系的一个参考。并不是说相关系数高就一定有关,相关系数低就一定无关,放一下我写的测试程序:

    import pandas as pd
    import math
    x=[]
    y=[]
    for i in range(1,101):
        x.append(i)
        y.append(math.log(i**2+math.log(i**0.5+40*i))+i**2+i**6+i**math.log(i**math.sqrt(2*i)))
    print(pd.Series(x).corr(pd.Series(y),method='pearson'))
    print(pd.Series(x).corr(pd.Series(y),method='kendall'))
    print(pd.Series(x).corr(pd.Series(y),method='spearman'))
    

    运行结果,可以发现kendall确实优秀:
    在这里插入图片描述
    然而如果我在函数关系式里加入三角函数:

    import pandas as pd
    import math
    x=[]
    y=[]
    for i in range(1,101):
        x.append(i)
        y.append(math.cos(math.log(i**2+math.log(i**0.5+40*i))+math.sin(i**2+i**6+i**math.log(i**math.sqrt(2*i))))**3)
    print(pd.Series(x).corr(pd.Series(y),method='pearson'))
    print(pd.Series(x).corr(pd.Series(y),method='kendall'))
    print(pd.Series(x).corr(pd.Series(y),method='spearman'))
    

    可以发现结果一下就差了许多:
    在这里插入图片描述
    所以方差也好、相关系数也好,只能作为特征和结果关系的一个参考。并不是说相关系数高就一定有关,相关系数低就一定无关。每个特征,特别是这种处理、脱敏后数据集的特征,都是含有信息的,如果不是降维或者可视化的迫切需要,最好还是不要乱删数据。
    前几天打了一下阿里天池的蒸汽预测·,就是降维降猛了,不太理想。
    当然你也可以用PCA降维。
    考虑到被我东删西删,现在就剩7维了,虽然Age的数据不太好看,也就不删了。

    预测与验证

    选用逻辑回归算法:

    print('建模:')
    model =LogisticRegression()
    model.fit(trainReview, trainLable)
    print('预测:')
    pred_model = model.predict(testReview)
    score = metrics.accuracy_score(testLable, pred_model)
    matrix = metrics.confusion_matrix(testLable, pred_model)
    print('>>>准确率\n', score)
    print('\n>>>混淆矩阵\n', matrix)
    

    结果(人生巅峰):
    在这里插入图片描述
    这里有另一篇博文讲的比较详细,后面打算按他的方法复现一遍,然后做个对比:
    https://tianchi.aliyun.com/notebook-ai/detail?spm=5176.12282042.0.0.1dce2042NBc6J6&postId=6772

    代码、数据集和答案集:
    链接:https://pan.baidu.com/s/1HkE_91neYHtN5EfftnLFeg
    提取码:v3l5

    展开全文
  • Kaggle泰坦尼克号

    2019-11-29 22:31:12
    Kaggle泰坦尼克号之灾 问题笔记 pandas 学习手册:https://www.yiibai.com/pandas/python_pandas_caveats_and_gotchas.html pd.read_csv("***.csv")直接读取csv格式的文件,保存成DataFrame形式 pd.concat(objs, ...

    Kaggle泰坦尼克号之灾 问题笔记

    pandas 学习手册:https://www.yiibai.com/pandas/python_pandas_caveats_and_gotchas.html

    pd.read_csv("***.csv")直接读取csv格式的文件,保存成DataFrame形式

    pd.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)

    objs 需要连接的对象,eg [df1, df2] , 注意这里的中括号

    axis axis = 0, 表示在水平方向(row)进行连接 axis = 1, 表示在垂直方向(column)进行连接

    join outer, 表示index全部需要; inner,表示只取index重合的部分

    join_axes 传入需要保留的index

    ignore_index 忽略需要连接的frame本身的index。当原本的index没有特别意义的时候可以使用

    keys 可以给每个需要连接的df一个label,多重索引,一般少用

    DataFrame格式的文件,可以通过.head()函数来显示其中的前5个样本(所有的列),可以通过.info(),查看文件的总的信息,便于查看列和缺失值。

    DataFrame可以通过直接索引[“Survived”]访问列值,显示索引和列所在的值

    .value_counts()函数,统计当前数据Frame中不同值的个数

    在这里插入图片描述

    import seaborn as sns 基于matplotlib的绘图工具,可以参考https://www.jianshu.com/p/8bb06d3fd21b

    sns.barplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, estimator=(function mean), ci=95, n_boot=1000, units=None, orient=None, color=None, palette=None, saturation=0.75, errcolor=’.26’, errwidth=None, capsize=None, dodge=True, ax=None, **kwargs)

    条形图上的误差棒则表示各类的数值相对于条形图所显示的值的误差

    hue(str):dataframe的列名,按照列名中的值分类形成分类的条形图

    order, hue_order (lists of strings):用于控制条形图的顺序

    **ci(float): *允许的*误差的范围(控制误差棒的百分比,在0-100之间),若填写"sd",则误差棒用标准误差。(默认为95)

    fig,axes=plt.subplots(1,2)  # 一定记得是subplots函数创建多副子图
    sns.barplot(x="color",y="age",data=data,ci=0,ax=axes[0])  #左图
    sns.barplot(x="color",y="age",data=data,ci="sd",ax=axes[1])  #右图
    

    palette:调色板,控制不同的颜色style

    fig,axes=plt.subplots(2,1)
    sns.barplot(x="color",y="age",data=data,ax=axes[0])  #上图
    sns.barplot(x="color",y="age",data=data,palette="Set3",ax=axes[1])  #下图
    

    **capsize(float)😗*设置误差棒帽条(上下两根横线)的宽度

    fig,axes=plt.subplots(1,2)
    sns.barplot(x="color",y="age",data=data,ax=axes[0],capsize=.2)  #左图
    sns.barplot(x="color",y="age",data=data,ax=axes[1],capsize=.5)  #右图
    

    seaborn.countplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, orient=None, color=None, palette=None, saturation=0.75, dodge=True, ax=None, **kwargs)

    注:countplot参数和barplot基本差不多,可以对比着记忆,有一点不同的是countplot中不能同时输入x和y,且countplot没有误差棒。

    fig,axes=plt.subplots(1,2)
    sns.countplot(x="gender",data=data,ax=axes[0]) #左图
    sns.countplot(y="gender",data=data,ax=axes[1])  #右图
    

    sns.FacetGrid() 参考博客:https://www.jianshu.com/p/6a210c2ad3adhttps://blog.csdn.net/weixin_42398658/article/details/82960379

    操作流程:先g=sns.FacetGrid(tips, col=“time”)画出轮廓,然后用g.map(plt.hist, “tip”)填充内容

    data : DataFrame

    row, col, hue : strings , col=“sex”, hue=“smoker”,即列表示性别,颜色语意表示是否吸烟,下面示例会给出详细说明

    aspect 是说每个小图的横轴长度和纵轴的比

    sns.kdeplot(), 参考博客:https://www.jianshu.com/p/844f66d00ac1

    kdeplot(核密度估计图)核密度估计(kernel density estimation)是在概率论中用来估计未知的密度函数,属于非参数检验方法之一。通过核密度估计图可以比较直观的看出数据样本本身的分布特征。具体用法如下:

    *seaborn.kdeplot(data,data2=None,shade=False,vertical=False,kernel=‘gau’,bw=‘scott’,gridsize=100,cut=3,clip=None,legend=True,cumulative=False,shade_lowest=True,cbar=False, cbar_ax=None, cbar_kws=None, ax=None, *kwargs)

    facet.map(sns.kdeplot, “Age”, shade=True)

    这里的Age表示的是X轴,具体参考下图所示,横轴纵轴的设置。

    在这里插入图片描述

    facet.set(xlim=(0, train[“Age”].max())),.max()获取最大值,.add_legend() 添加标注,

    plt.xlabel("Age")  # show the label
    plt.ylabel("density")
    

    如何提取乘客的称谓

    Heikkinen, Miss. Laina所有的都是这种形式的,所以有

    all_data["Title"]=all_data["Name"].apply(lambda x:x.split(",")[1].split(".")[0].strip())

    创建lambda表达式,传入的name,首先按照逗号进行分割,取出第一部分的值,然后按照点号进行分割,取出第0部分的值,最后再删除两端多余的空白

    .unique()函数以数组形式显示当前数据Frame中的不同的值,类似于set(),但是和set返回的类型不一样,set返回的是字典类型。

    对不同的称谓进行归类

    在这里插入图片描述

    在这里插入图片描述

    如图所示:

    创建一个字典,然后对该字典进行键值对对应。注意字典类型是没有unique()的,所以使用set()查看其中的不同值。

    .map(Title_Dict)表示对数据中的值,用字典中相应的值进行替换,完成分为6类的目的,但是如果是使用.apply()的话就必须里面是lambda x:Title_Dict[x],只是对字典,它俩情况特殊,其他的几乎是等价的,map使用的范围广很多。

    .fillna(“Unknown”)将空缺值补充为“Unknown”

    如果是字符串类型,需要提取首字母则可以使用以下方法:

    .str.get(0),首先调用stringmethod,然后在使用get()函数,获取首字母

    Ticket_Count = dict(all_data["Ticket"].value_counts())

    以下两句命令等价:

    Ticket_Count = dict(all_data["Ticket"].value_counts())  # create a dict. in order to turn this into TicketGroup
    all_data["TicketGroup"] = all_data["Ticket"].apply(lambda x: Ticket_Count[x])
    all_data["TicketGroup"] = all_data["Ticket"].map(Ticket_Count)
    sns.barplot(x="TicketGroup", y="Survived", data=all_data, ci=0)
    

    .get_dummies(data_frame)将数据进行one-hot 编码

    known_age = age_df[age_df.Age.notnull()].as_matrix(),选出数据Frame中不为空的部分,然后再转换成矩阵。

    在这里插入图片描述

    使用随机森林算法对Age的值进行预测

    .isnull()其中是NAN的值

    查看其中是NAN的值,如图所示。

    在这里插入图片描述

    all_data.loc[(all_data.Fare80) & (all_data.Pclass1)]

    在dataframe选出满足条件等于80和1值,注意这里的括号,如果不加括号就是错的

    all_data["Fare"] = all_data["Fare"].fillna(fare)

    使用fillna()填充值

    .groupby()

    参考博客:https://www.yiibai.com/pandas/python_pandas_groupby.html

    将dataframe其中的某几列,进行重新组合,然后再进行其他操作

    .filter()

    过滤根据定义的标准过滤数据并返回数据的子集。filter()函数用于过滤数据。

    .index

    获得数据Frame的索引值

    使用sns.barplot()时候,还可以在后面加上set_xlabel("***"),等于plt.xlabel(“xxx”)

    test.loc[(test[“Surname”].apply(lambda x:x in Dead_List)), “Sex”]=“male”

    在这里插入图片描述

    .loc选出了满足第一个条件(在死亡名单上的Surname),并且是Sex栏,然后将其改为男性,其他类似。

    .drop() 删除某行某列

    在这里插入图片描述

    模型

    Pipeline机制:

    参考博客: https://blog.csdn.net/qq_40587575/article/details/80987742

    每一步都用元组( ‘名称’,步骤)来表示。现在来创建流水线。

    pipe = Pipeline([('sc',StandardScaler()),
                     ('pca',PCA(n_components=2)),
                     ('clf',LogisticRegression(random_state=666))   #设置随机种子,使测试结果复现
                     ])
    

    RandomForestClassifier

    参考博客:https://blog.csdn.net/w952470866/article/details/78987265

    random_state=10基本设置一下就可以了

    SelectKBest:

    参考博客:https://blog.csdn.net/niutingbaby/article/details/96102393

    只保留 k 个最高分的特征

    展开全文
  • 使用深度学习对kaggle上的titanic项目,使用乘客数据(如姓名、年龄、性别、社会经济阶层等),建立一个模型预测泰坦尼克号沉船上哪些乘客能够幸存。 二、编程 该项目的训练集与测试集在官网下载即可:...

    一、目的

    使用深度学习对kaggle上的titanic项目,使用乘客数据(如姓名、年龄、性别、社会经济阶层等),建立一个模型预测泰坦尼克号沉船上哪些乘客能够幸存。

    二、编程

    该项目的训练集与测试集在官网下载即可:https://www.kaggle.com/c/titanic,在完成后还可以上传你的预测文件参与全世界排名。

    我们本次编程使用pytorch进行。本次将搭建一个三层神经网络,relu->relu->sigmoid,使用batch优化。
    下面是本次编程使用的模块:

    import numpy as np
    import matplotlib.pyplot as plt
    import torch
    import pandas as pd
    import csv
    

    2.1 数据处理

    2.1.1 导入数据集

    我们第一步先进行数据处理,先导入数据集

    # 导入数据集
    train_filepath = r"train.csv"
    train_data = pd.read_csv(train_filepath)
    test_filepath = r"test.csv"
    test_data = pd.read_csv(test_filepath)
    

    2.1.2 数据分析

    在训练集train.csv中我们有很多特征,并且数据不全我们需要对其进行处理:

    (1)PassengerID:乘客的ID,是无关信息。
    (2)Survived:乘客是否幸存,取值为0或1,是我们预测/分类的目标。
    (3)Pclass:客舱等级,可能蕴含着乘客的阶层、乘客客舱的位置等信息,比较重要。
    (4)Name: 姓名,是无关信息。
    (5)Sex:性别,灾难来临时常让妇女儿童先走,而同等条件女性体力普遍弱于男性,这些因素都会影响到一名乘客幸存的可能性,因此比较重要。
    (6)Age:年龄,较为重要,理由同上。
    (7)Parch:直系亲友数目,比较重要。
    (8)SibSp:旁系亲友数目,比较重要。
    (9)Ticket:票编号,是无关信息。
    (10)Fare:票价,可能会反映乘客的社会阶层等。
    (11)Cabin:客舱编号,可能会反映客舱位置等,但由于缺省太多,数据量很小不具有代表性,可以视为噪音剔除。
    (12)Embarked:上船的港口编号。

    在剔除了一些数据后,是否会因信息损失而降低模型的准确度?例如乘客的姓名可能暗含船上乘客之间家庭的关系。实际上我们的模型本来就是建立在不完全观测上(比如我们不知道船上的一对男女乘客有没有发生像Jack和Rose那样的故事),不确定性是必然存在的,把握主要矛盾,舍弃噪音信息是建立模型的一个好思路。

    2.1.3 数据预处理

    不了解one-hot的同学看这里:机器学习:数据预处理之独热编码(One-Hot)

    # 训练数据预处理
    def PreprocessTrainData(all_pf):
        # 预处理1:去掉无关特征
        cols = ["Survived", "Pclass", "Sex", "Age", "SibSp", "Parch", "Fare", "Embarked"]
        all_pf = all_pf[cols]
        # 预处理2:填充确实特征并标准化
        age_mean = all_pf["Age"].mean()
        all_pf["Age"] = all_pf["Age"].fillna(age_mean)
    
        fare_mean = all_pf["Fare"].mean()
        all_pf["Fare"] = all_pf["Fare"].fillna(fare_mean)
    
        # 预处理3:性别编码
        all_pf["Sex"] = all_pf["Sex"].map({"female": 0, "male": 1}).astype(int)
    
        # 预处理4:登港地点转换为one-hot编码
        x_OneHot_df = pd.get_dummies(data=all_pf, columns=["Embarked"])
        ndarray = x_OneHot_df.values
    
        # 预处理5:全体特征标准化,标签向量化
        label = ndarray[:, 0]
        label = label.reshape(label.shape[0], 1)
        features = ndarray[:, 1:]
        mean = features.mean(axis=0)
        features -= mean
        std = features.std(axis=0)
        features /= std
    
        return label, features
    
    
    # 测试数据预处理
    def PreprocessTestData(all_df):
        # 预处理1:筛除无关特征
        cols = ["Pclass", "Sex", "Age", "SibSp", "Parch", "Fare", "Embarked"]
        all_df = all_df[cols]
    
        # 预处理2:填充缺失特征并标准化特征
        age_mean = all_df["Age"].mean()
        all_df["Age"] = all_df["Age"].fillna(age_mean)
    
        fare_mean = all_df["Fare"].mean()
        all_df["Fare"] = all_df["Fare"].fillna(fare_mean)
    
        # 预处理3:性别编码0-1
        all_df["Sex"] = all_df["Sex"].map({"female": 0, "male": 1}).astype(int)
    
        # 预处理4:登港地点转换为one-hot编码
        x_OneHot_df = pd.get_dummies(data=all_df, columns=["Embarked"])
        ndarray = x_OneHot_df.values
    
        # 预处理5:全体特征标准化,标签向量化
        features = ndarray
        mean = features.mean(axis=0)
        features -= mean
        std = features.std(axis=0)
        features /= std
        return features
    
    # 转换为张量
    y_train, x_train = PreprocessTrainData(train_data)
    x_train_tenser = torch.from_numpy(x_train)
    y_train_tenser = torch.from_numpy(y_train)
    x_test = PreprocessTestData(test_data)
    x_test_tenser = torch.from_numpy(x_test)
    

    2.2 构建网络

    # 构造网络模型
    class model(torch.nn.Module):
        def __init__(self):
            super(model, self).__init__()
            self.linear1 = torch.nn.Linear(9, 6)
            self.linear2 = torch.nn.Linear(6, 3)
            self.linear3 = torch.nn.Linear(3, 1)
            self.sigmoid = torch.nn.Sigmoid()
            self.relu = torch.nn.ReLU()
    
        def forward(self, x):
            x = self.relu(self.linear1(x))
            x = self.relu(self.linear2(x))
            x = self.sigmoid(self.linear3(x))
            return x
    
    model = model()
    

    2.3 构建优化器和损失函数

    # 构造优化器和损失函数
    criterion = torch.nn.BCELoss(reduction="mean")
    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
    

    2.4 开始训练

    cost_list = []
    # 开始训练
    for epoch in range(1000):
        # 正向传播
        y_pred = model(x_train_tenser.float())
        loss = criterion(y_pred, y_train_tenser.float())
        cost_list.append(loss.item())
        print("epoch:", epoch, "cost:", loss.item())
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        # 更新参数
        optimizer.step()
    

    2.5 预测

    y_pred = model(x_test_tenser.float())
    y_pred = np.array(y_pred.data)
    for i in range(y_pred.shape[0]):
        if y_pred[i, 0] > 0.5:
            y_pred[i, 0] = 1
        else:
            y_pred[i, 0] = 0
    with open(r"gender_submission.csv", 'w+', newline='') as f:
        csv_file = csv.writer(f)
        csv_file.writerows(y_pred)
    
    plt.plot(cost_list)
    plt.xlabel("epoch")
    plt.ylabel("cost")
    plt.show()
    

    2.6 损失下降图

    epoch: 1 cost: 0.672267496585846
    epoch: 2 cost: 0.6718555688858032
    epoch: 3 cost: 0.6714616417884827
    ...
    epoch: 997 cost: 0.39888277649879456
    epoch: 998 cost: 0.39885351061820984
    epoch: 999 cost: 0.39881929755210876
    

    在这里插入图片描述
    本次结果在kaggle上取得前23%的结果,总体来说还不错,毕竟使用的是未经任何优化的梯度下降法。
    在这里插入图片描述
    此外可以留一部分验证集,测试模型的泛化能力。

    2.7 源码

    源码在此

    三、参考

    kaggle泰坦尼克号深度学习实战

    展开全文
  • 初始的把模型大致搭建起来,步骤包括:特征选择,缺失值处理,归一化与正则化,模型选择。得到的准确率是: 这个准确率排名相当低,8000/10000的水平。现在要想办法,提升准确了。 分析一 在分类错误的类别中,我...
  • kaggle泰坦尼克号

    2019-03-11 09:27:37
    1912年4月15日,泰坦尼克号在首次航行期间撞上冰山后沉没,2224名乘客和机组人员中有1502人遇难。沉船导致大量伤亡的原因之一是没有足够的救生艇给乘客和船员。虽然幸存下来有一些运气因素,但有一些人比其他人更有...
  • Sex: 乘客性别 Age: 乘客年龄 SibSp: 有几个siblings(兄弟姐妹) or spouses(配偶) 在船上 parch: 有几个parents or children 在船上 ticket: ticket number fare: 船票价格 cabin: 船舱 embarked: 登船...
  • Kaggle泰坦尼克号比赛项目详解 项目背景 1、泰坦尼克号:英国白星航运公司下辖的一艘奥林匹克级邮轮,于1909年3月31日在爱尔兰贝尔法斯特港的哈兰德与沃尔夫造船厂动工建造,1911年5月31日下水,1912年4月2日完工...
  • Kaggle泰坦尼克号生存预测挑战     这是kaggle上Getting Started 的Prediction Competition,也是比较入门和简单的新人赛,我的最好成绩好像有进入top8%,重新地回顾巩固一下这个比赛,我将分成...
  • kaggle泰坦尼克号Kaggle is a site where people create algorithms and compete against machine learning practitioners around the world. Your algorithm wins the competition if it’s the most accurate on a...
  • 前面几篇逻辑回归的例子有些是人造出来的,有些是比较正规的,但数据都比较完整,没有缺失的属性...那么这里有个地方给带给你想要的实战——Kaggle数据分析建模的应用竞赛平台,企业或者研究者可以将问题背景、数据...
  • 卡格格尔·泰坦尼克号 具有Kaggle泰坦尼克号数据集的受监督ML项目 零-R准确性:62.201%决策树准确性:77.511%
  • Kaggle泰坦尼克号生存预测挑战     这是kaggle上Getting Started 的Prediction Competition,也是比较入门和简单的新人赛,我的最好成绩好像有进入top8%,重新地回顾巩固一下这个比赛,我将分成...
  • 数据挖掘实战项目-kaggle泰坦尼克号生还者预测 一、实战项目描述 二、项目数据挖掘流程分析 三级目录
  • 文章目录前言一、数据集下载二、数据集建模1....废话略过,kaggle泰坦尼克号 直接在网站上下载,然后会得到三个文件: 第一个是提交示例,第二个是测试集,第三个是训练集。 二、数据集建模 1.引入库 import numpy a
  • 一、初识 kaggle kaggle是一个非常适合初学者去实操实战技能的一个网站,它可以根据你做的项目来评估你的得分和排名。让你对自己的能力有更清楚的了解,当然,在这个网站上,也有很多项目的教程,可以跟着教程走,...
  • 泰坦尼克号幸存者的预测 这是机器学习竞赛的第一步。 挑战 :ship: 泰坦尼克号在1912年的首次航行中沉没,造成了一半以上的乘客生命。 给出了两个数据集,即train.csv和test.csv。 这两个数据集都包含每位登上...
  • 路易斯实验室 Kaggle泰坦尼克号比赛的入门套件。 数据文件来自: :
  • 泰坦尼克号 只是GitHub上的泰坦尼克号数据集教程 在力大无比的数据集上实施一个随机森林,以根据乘客的性别,年龄,经济舱以及兄弟姐妹/父母的数量来预测乘客是否幸存
  • 案例-Kaggle泰坦尼克号生存预测分析

    千次阅读 2018-06-15 10:01:34
    Cabin: 客舱; Embarked: 登船港口(S: Southampton; C: Cherbourg Q: Queenstown) #查看数据描述性统计 full.describe() 因为,describe()函数只能查看数据类型的描述统计信息,无法查看类似字符...
  • 泰坦尼克号 泰坦尼克号的沉没是历史上最臭名昭著的海难之一。1912年4月15日,在她的处女航中,被广泛认为的“沉没” RMS泰坦尼克号与冰山相撞后沉没。不幸的是,船上没有足够的救生艇供所有人使用,导致2224名乘客...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,378
精华内容 1,351
关键字:

kaggle泰坦尼克号