精华内容
下载资源
问答
  • 泰坦尼克号预测
    2020-12-05 11:33:08
    import pandas as pd
    
    # 1、获取数据
    path = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt"
    titanic = pd.read_csv(path)
    
    titanic.head()
    
    row.namespclasssurvivednameageembarkedhome.destroomticketboatsex
    011st1Allen, Miss Elisabeth Walton29.0000SouthamptonSt Louis, MOB-524160 L2212female
    121st0Allison, Miss Helen Loraine2.0000SouthamptonMontreal, PQ / Chesterville, ONC26NaNNaNfemale
    231st0Allison, Mr Hudson Joshua Creighton30.0000SouthamptonMontreal, PQ / Chesterville, ONC26NaN(135)male
    341st0Allison, Mrs Hudson J.C. (Bessie Waldo Daniels)25.0000SouthamptonMontreal, PQ / Chesterville, ONC26NaNNaNfemale
    451st1Allison, Master Hudson Trevor0.9167SouthamptonMontreal, PQ / Chesterville, ONC22NaN11male
    # 筛选特征值和目标值
    x = titanic[["pclass", "age", "sex"]]
    y = titanic["survived"]
    
    x.head()
    
    pclassagesex
    01st29.0000female
    11st2.0000female
    21st30.0000male
    31st25.0000female
    41st0.9167male
    y.head()
    
    0    1
    1    0
    2    0
    3    0
    4    1
    Name: survived, dtype: int64
    
    # 2、数据处理
    # 1)缺失值处理
    x["age"].fillna(x["age"].mean(), inplace=True)
    
    D:\anaconda3\lib\site-packages\pandas\core\generic.py:6245: SettingWithCopyWarning: 
    A value is trying to be set on a copy of a slice from a DataFrame
    
    See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
      self._update_inplace(new_data)
    
    # 2) 转换成字典
    x = x.to_dict(orient="records")
    
    from sklearn.model_selection import train_test_split
    # 3、数据集划分
    x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)
    
    # 4、字典特征抽取
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.tree import DecisionTreeClassifier, export_graphviz
    
    transfer = DictVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    
    # 3)决策树预估器
    estimator = DecisionTreeClassifier(criterion="entropy", max_depth=8)
    estimator.fit(x_train, y_train)
    
    # 4)模型评估
    # 方法1:直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)
    
    # 方法2:计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为:\n", score)
    
    # 可视化决策树
    export_graphviz(estimator, out_file="titanic_tree.dot", feature_names=transfer.get_feature_names())
    
    
    y_predict:
     [0 0 0 0 1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 0 1 0 0 0
     0 0 0 0 0 0 0 0 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0
     0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1
     0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1
     1 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0
     0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0
     0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0
     0 1 1 1 0 0 1 1 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1
     0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1]
    直接比对真实值和预测值:
     831      True
    261      True
    1210     True
    1155     True
    255      True
            ...  
    1146     True
    1125    False
    386      True
    1025    False
    337      True
    Name: survived, Length: 329, dtype: bool
    准确率为:
     0.7811550151975684
    

    随机森林对泰坦尼克号乘客的生存进行预测

    from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import GridSearchCV
    
    estimator = RandomForestClassifier()
    # 加入网格搜索与交叉验证
    # 参数准备
    param_dict = {"n_estimators": [120,200,300,500,800,1200], "max_depth": [5,8,15,25,30]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3)
    estimator.fit(x_train, y_train)
    
    # 5)模型评估
    # 方法1:直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)
    
    # 方法2:计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为:\n", score)
    
    # 最佳参数:best_params_
    print("最佳参数:\n", estimator.best_params_)
    # 最佳结果:best_score_
    print("最佳结果:\n", estimator.best_score_)
    # 最佳估计器:best_estimator_
    print("最佳估计器:\n", estimator.best_estimator_)
    # 交叉验证结果:cv_results_
    print("交叉验证结果:\n", estimator.cv_results_)
    
    y_predict:
     [0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 0 1 0 0 0
     0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0
     0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1
     0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1
     1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0
     0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0
     0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0
     0 1 1 1 0 0 1 1 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1
     0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1]
    直接比对真实值和预测值:
     831      True
    261      True
    1210     True
    1155     True
    255      True
    762      True
    615      True
    507      True
    1175     True
    301      True
    1134     True
    177      True
    183     False
    125     False
    1093     True
    1304    False
    1124     True
    798     False
    1101     True
    1239    False
    1153     True
    1068    False
    846      True
    148      True
    478      True
    642      True
    1298     True
    540      True
    28       True
    130      True
            ...  
    194      True
    663      True
    1209     True
    117     False
    595     False
    1151    False
    1143     True
    1216     True
    874      True
    246      True
    160      True
    1208     True
    682      True
    307      True
    67       True
    961      True
    400      True
    923     False
    866      True
    134      True
    613      True
    242      True
    320     False
    829      True
    94       True
    1146     True
    1125    False
    386      True
    1025    False
    337      True
    Name: survived, Length: 329, dtype: bool
    准确率为:
     0.7872340425531915
    最佳参数:
     {'max_depth': 5, 'n_estimators': 120}
    最佳结果:
     0.8363821138211383
    最佳估计器:
     RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
                max_depth=5, max_features='auto', max_leaf_nodes=None,
                min_impurity_decrease=0.0, min_impurity_split=None,
                min_samples_leaf=1, min_samples_split=2,
                min_weight_fraction_leaf=0.0, n_estimators=120, n_jobs=None,
                oob_score=False, random_state=None, verbose=0,
                warm_start=False)
    交叉验证结果:
     {'mean_fit_time': array([0.11182229, 0.19149677, 0.27871044, 0.4505314 , 0.72257209,
           1.21950404, 0.15458934, 0.23542873, 0.37338622, 0.55880507,
           0.90250031, 1.44036126, 0.13625924, 0.24566126, 0.39018901,
           0.57973933, 0.94357061, 1.46748765, 0.15806643, 0.25924444,
           0.3800021 , 0.60227998, 0.98656511, 1.5208021 , 0.15277807,
           0.25416827, 0.37849299, 0.61238893, 1.00995   , 1.51009766]), 'std_fit_time': array([0.00438099, 0.00391445, 0.00445387, 0.00552127, 0.0178945 ,
           0.05956372, 0.00696462, 0.01180214, 0.01545986, 0.02345017,
           0.01762821, 0.07661026, 0.00448709, 0.00753101, 0.01337304,
           0.02401102, 0.02824846, 0.00723971, 0.00559061, 0.00539144,
           0.03176938, 0.00900011, 0.0357836 , 0.02412509, 0.01049831,
           0.00312499, 0.02043117, 0.03736237, 0.03896   , 0.01708367]), 'mean_score_time': array([0.01055225, 0.02124031, 0.02604191, 0.04676072, 0.06393997,
           0.1221021 , 0.01392762, 0.02117666, 0.03027145, 0.04542494,
           0.08080705, 0.11298935, 0.01059707, 0.02046402, 0.02975106,
           0.04587412, 0.07316939, 0.14350526, 0.0142649 , 0.02011824,
           0.02920715, 0.0444289 , 0.07418664, 0.11165055, 0.01248868,
           0.02353628, 0.03232622, 0.04952399, 0.08569598, 0.11799375]), 'std_score_time': array([1.09863734e-03, 2.29822618e-03, 3.20843508e-03, 4.00866766e-03,
           1.42997845e-03, 1.48818168e-02, 2.37098736e-03, 8.80449078e-04,
           1.62827120e-03, 1.83137647e-03, 9.86835991e-03, 9.71738484e-03,
           5.51943914e-04, 1.00782641e-03, 2.11610207e-03, 1.98464255e-03,
           3.04582952e-03, 9.81828652e-03, 1.69302449e-03, 1.37694072e-03,
           1.67724778e-03, 7.58986198e-05, 3.23449160e-03, 3.78348887e-03,
           1.02684570e-03, 5.07326308e-03, 4.72586897e-03, 2.47344396e-03,
           1.11438683e-02, 4.31988881e-03]), 'param_max_depth': masked_array(data=[5, 5, 5, 5, 5, 5, 8, 8, 8, 8, 8, 8, 15, 15, 15, 15, 15,
                       15, 25, 25, 25, 25, 25, 25, 30, 30, 30, 30, 30, 30],
                 mask=[False, False, False, False, False, False, False, False,
                       False, False, False, False, False, False, False, False,
                       False, False, False, False, False, False, False, False,
                       False, False, False, False, False, False],
           fill_value='?',
                dtype=object), 'param_n_estimators': masked_array(data=[120, 200, 300, 500, 800, 1200, 120, 200, 300, 500, 800,
                       1200, 120, 200, 300, 500, 800, 1200, 120, 200, 300,
                       500, 800, 1200, 120, 200, 300, 500, 800, 1200],
                 mask=[False, False, False, False, False, False, False, False,
                       False, False, False, False, False, False, False, False,
                       False, False, False, False, False, False, False, False,
                       False, False, False, False, False, False],
           fill_value='?',
                dtype=object), 'params': [{'max_depth': 5, 'n_estimators': 120}, {'max_depth': 5, 'n_estimators': 200}, {'max_depth': 5, 'n_estimators': 300}, {'max_depth': 5, 'n_estimators': 500}, {'max_depth': 5, 'n_estimators': 800}, {'max_depth': 5, 'n_estimators': 1200}, {'max_depth': 8, 'n_estimators': 120}, {'max_depth': 8, 'n_estimators': 200}, {'max_depth': 8, 'n_estimators': 300}, {'max_depth': 8, 'n_estimators': 500}, {'max_depth': 8, 'n_estimators': 800}, {'max_depth': 8, 'n_estimators': 1200}, {'max_depth': 15, 'n_estimators': 120}, {'max_depth': 15, 'n_estimators': 200}, {'max_depth': 15, 'n_estimators': 300}, {'max_depth': 15, 'n_estimators': 500}, {'max_depth': 15, 'n_estimators': 800}, {'max_depth': 15, 'n_estimators': 1200}, {'max_depth': 25, 'n_estimators': 120}, {'max_depth': 25, 'n_estimators': 200}, {'max_depth': 25, 'n_estimators': 300}, {'max_depth': 25, 'n_estimators': 500}, {'max_depth': 25, 'n_estimators': 800}, {'max_depth': 25, 'n_estimators': 1200}, {'max_depth': 30, 'n_estimators': 120}, {'max_depth': 30, 'n_estimators': 200}, {'max_depth': 30, 'n_estimators': 300}, {'max_depth': 30, 'n_estimators': 500}, {'max_depth': 30, 'n_estimators': 800}, {'max_depth': 30, 'n_estimators': 1200}], 'split0_test_score': array([0.82674772, 0.82066869, 0.82674772, 0.82674772, 0.82674772,
           0.82674772, 0.80547112, 0.80851064, 0.80243161, 0.80243161,
           0.80243161, 0.81155015, 0.79027356, 0.79635258, 0.79635258,
           0.79331307, 0.79027356, 0.79027356, 0.79635258, 0.79027356,
           0.79635258, 0.79331307, 0.79027356, 0.79331307, 0.79027356,
           0.79635258, 0.79635258, 0.79331307, 0.7993921 , 0.79331307]), 'split1_test_score': array([0.85670732, 0.85670732, 0.85365854, 0.85365854, 0.85365854,
           0.85365854, 0.85060976, 0.8597561 , 0.84756098, 0.85670732,
           0.85670732, 0.85670732, 0.85365854, 0.85365854, 0.85365854,
           0.8597561 , 0.85060976, 0.85670732, 0.85670732, 0.85365854,
           0.85670732, 0.85365854, 0.85670732, 0.85060976, 0.85670732,
           0.8597561 , 0.84756098, 0.85670732, 0.85060976, 0.85060976]), 'split2_test_score': array([0.82568807, 0.82262997, 0.82262997, 0.82568807, 0.82262997,
           0.82262997, 0.80122324, 0.79510703, 0.80122324, 0.80428135,
           0.80122324, 0.80122324, 0.80428135, 0.80122324, 0.80122324,
           0.80122324, 0.80428135, 0.80428135, 0.80428135, 0.80733945,
           0.80122324, 0.80122324, 0.80122324, 0.80122324, 0.79816514,
           0.80428135, 0.80122324, 0.80428135, 0.80122324, 0.80122324]), 'mean_test_score': array([0.83638211, 0.83333333, 0.83434959, 0.83536585, 0.83434959,
           0.83434959, 0.81910569, 0.82113821, 0.81707317, 0.82113821,
           0.82012195, 0.82317073, 0.81605691, 0.81707317, 0.81707317,
           0.81808943, 0.81504065, 0.81707317, 0.81910569, 0.81707317,
           0.81808943, 0.81605691, 0.81605691, 0.81504065, 0.81504065,
           0.82012195, 0.81504065, 0.81808943, 0.81707317, 0.81504065]), 'std_test_score': array([0.0143786 , 0.01654729, 0.01375658, 0.01294211, 0.01375658,
           0.01375658, 0.02234414, 0.02784983, 0.02156378, 0.02516249,
           0.02587446, 0.02408579, 0.02719639, 0.02594607, 0.02594607,
           0.02963923, 0.02579309, 0.02860307, 0.02678467, 0.02679151,
           0.02737927, 0.02678375, 0.02908969, 0.02535762, 0.0296384 ,
           0.02821188, 0.02308115, 0.02767166, 0.02372573, 0.02535762]), 'rank_test_score': array([ 1,  6,  3,  2,  3,  3, 12,  8, 17,  8, 10,  7, 23, 17, 17, 14, 26,
           17, 12, 17, 14, 23, 23, 26, 26, 10, 26, 14, 17, 26], dtype=int32), 'split0_train_score': array([0.85801527, 0.85954198, 0.85648855, 0.85801527, 0.85648855,
           0.85648855, 0.87633588, 0.87633588, 0.87633588, 0.87633588,
           0.87633588, 0.87480916, 0.88244275, 0.88244275, 0.88244275,
           0.88244275, 0.88244275, 0.88244275, 0.88244275, 0.88244275,
           0.88244275, 0.88244275, 0.88244275, 0.88244275, 0.88244275,
           0.88244275, 0.88244275, 0.88244275, 0.88244275, 0.88244275]), 'split1_train_score': array([0.84603659, 0.84756098, 0.84756098, 0.84756098, 0.84756098,
           0.84756098, 0.86128049, 0.86128049, 0.86128049, 0.86128049,
           0.86128049, 0.86128049, 0.86128049, 0.86128049, 0.86128049,
           0.86128049, 0.86128049, 0.86128049, 0.86128049, 0.86128049,
           0.86128049, 0.86128049, 0.86128049, 0.86128049, 0.86128049,
           0.86128049, 0.86128049, 0.86128049, 0.86128049, 0.86128049]), 'split2_train_score': array([0.87214612, 0.87214612, 0.86757991, 0.87214612, 0.86757991,
           0.86757991, 0.88736682, 0.88736682, 0.88584475, 0.88584475,
           0.88584475, 0.88584475, 0.88736682, 0.88736682, 0.88736682,
           0.88736682, 0.88736682, 0.88736682, 0.88736682, 0.88736682,
           0.88736682, 0.88736682, 0.88736682, 0.88736682, 0.88736682,
           0.88736682, 0.88736682, 0.88736682, 0.88736682, 0.88736682]), 'mean_train_score': array([0.85873266, 0.85974969, 0.85720981, 0.85924079, 0.85720981,
           0.85720981, 0.87499439, 0.87499439, 0.87448704, 0.87448704,
           0.87448704, 0.87397813, 0.87703002, 0.87703002, 0.87703002,
           0.87703002, 0.87703002, 0.87703002, 0.87703002, 0.87703002,
           0.87703002, 0.87703002, 0.87703002, 0.87703002, 0.87703002,
           0.87703002, 0.87703002, 0.87703002, 0.87703002, 0.87703002]), 'std_train_score': array([0.01067124, 0.01003792, 0.00818859, 0.01007418, 0.00818859,
           0.00818859, 0.01069186, 0.01069186, 0.01011317, 0.01011317,
           0.01011317, 0.01004552, 0.01131658, 0.01131658, 0.01131658,
           0.01131658, 0.01131658, 0.01131658, 0.01131658, 0.01131658,
           0.01131658, 0.01131658, 0.01131658, 0.01131658, 0.01131658,
           0.01131658, 0.01131658, 0.01131658, 0.01131658, 0.01131658])}
    
    
    
    更多相关内容
  • kaggle比赛——泰坦尼克号预测幸存者
  • 泰坦尼克号生存预测数据集 泰坦尼克号生存预测数据集 Taitanic data.zip
  • 泰坦尼克号幸存预测

    2018-07-05 10:43:26
    kaggle上面的Titanic比赛,77%的正确率,模型是逻辑回归。
  • 里面包含训练集和测试集,总共1200多条数据,涉及年龄,性别,船仓等信息可用于数据挖掘
  • 数据分析——泰坦尼克号预测

    千次阅读 2022-04-09 09:12:38
    'Fare']] = scaler.transform(X_train_encoded[['Age','Fare']]) X_test_encoded[['Age','Fare']] = scaler.transform(X_test_encoded[['Age','Fare']]) 模型预测 from sklearn.ensemble import ...

    之前在学校做过课程设计,但是对流程比较一知半解,现在看完了机器学习实战这本书,带着自己的理解重新做一遍。

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

    数据导入

    观察数据的具体情况,可以发现年龄变量Age和Cabin有缺失,然后Name,sex,Ticket,cabin和Embark是object类型,在后续的数据处理中要进行调整。

    data_train = pd.read_csv(r'C:/Users/train.csv')
    data_train.info()
    
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 12 columns):
     #   Column       Non-Null Count  Dtype  
    ---  ------       --------------  -----  
     0   PassengerId  891 non-null    int64  
     1   Survived     891 non-null    int64  
     2   Pclass       891 non-null    int64  
     3   Name         891 non-null    object 
     4   Sex          891 non-null    object 
     5   Age          714 non-null    float64
     6   SibSp        891 non-null    int64  
     7   Parch        891 non-null    int64  
     8   Ticket       891 non-null    object 
     9   Fare         891 non-null    float64
     10  Cabin        204 non-null    object 
     11  Embarked     889 non-null    object 
    dtypes: float64(2), int64(5), object(5)
    memory usage: 83.7+ KB
    

    再看看测试集

    data_test= pd.read_csv(r'test.csv')
    data_test.info()
    
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 418 entries, 0 to 417
    Data columns (total 11 columns):
     #   Column       Non-Null Count  Dtype  
    ---  ------       --------------  -----  
     0   PassengerId  418 non-null    int64  
     1   Pclass       418 non-null    int64  
     2   Name         418 non-null    object 
     3   Sex          418 non-null    object 
     4   Age          332 non-null    float64
     5   SibSp        418 non-null    int64  
     6   Parch        418 non-null    int64  
     7   Ticket       418 non-null    object 
     8   Fare         418 non-null    float64
     9   Cabin        91 non-null     object 
     10  Embarked     418 non-null    object 
    dtypes: float64(2), int64(4), object(5)
    memory usage: 36.0+ KB
    

    把索引设置为乘客编号

    test_process = test_process.set_index(['PassengerId'])
    test_process
    

    现在测试集长这样

    PclassNameSexAgeSibSpParchTicketFareEmbarkedCalledName_lengthFirst_name
    PassengerId
    8923Kelly, Mr. Jamesmale34003309117.8292QMr16Kelly
    8933Wilkes, Mrs. James (Ellen Needs)female47103632727.0000SMr32Wilkes
    8942Myles, Mr. Thomas Francismale62002402769.6875QMr25Myles
    8953Wirz, Mr. Albertmale27003151548.6625SMr16Wirz
    8963Hirvonen, Mrs. Alexander (Helga E Lindqvist)female2211310129812.2875SMr44Hirvonen
    .......................................
    13053Spector, Mr. Woolfmale2500A.5. 32368.0500SMr18Spector
    13061Oliva y Ocana, Dona. Ferminafemale3900PC 17758108.9000CNaN28Oliva y Ocana
    13073Saether, Mr. Simon Sivertsenmale3800SOTON/O.Q. 31012627.2500SMr28Saether
    13083Ware, Mr. Frederickmale25003593098.0500SMr19Ware
    13093Peter, Master. Michael Jmale2211266822.3583CNaN24Peter

    418 rows × 12 columns

    数据处理

    缺失值处理

    本次数据的缺失应该是完全随机的,不依赖于其他完全变量,所以可以采取删除和填补两种方式。cabin缺失过多,直接删除这一特征,不放心的话可以计算一些相关度或者画图看看情况。

    # 删除cabin
    train_process = data_train.drop(['Cabin'],axis=1)
    
    # 年龄数据进行缺失值填补
    from sklearn.ensemble import RandomForestRegressor
    from sklearn.model_selection import GridSearchCV
    Age_df = train_process[['Age','Survived','Pclass','SibSp','Parch','Fare']]
    UnknowAge = Age_df[Age_df.Age.isnull()].values
    KnowAge = Age_df[Age_df.Age.notnull()].values
    #y是目标年龄,x是已知属性
    y_train = KnowAge[:,0]
    x_train = KnowAge[:,1:]
    rfr = RandomForestRegressor(n_estimators=500,random_state=42)
    rfr.fit(x_train,y_train)
    predictedAges = rfr.predict(UnknowAge[:,1::])
    Age_df.loc[ (Age_df.Age.isnull()), 'Age' ] = predictedAges 
    train_process.Age=Age_df.Age.astype(int)
    

    年龄缺失值使用随机森林进行填补,建立回归方程进行拟合。

    测试集也要删除cabin变量和进行年龄缺失值的填补。

    #测试集
    test_process = data_test.drop(['Cabin'],axis=1)
    test_process.info()
    
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 418 entries, 0 to 417
    Data columns (total 10 columns):
     #   Column       Non-Null Count  Dtype  
    ---  ------       --------------  -----  
     0   PassengerId  418 non-null    int64  
     1   Pclass       418 non-null    int64  
     2   Name         418 non-null    object 
     3   Sex          418 non-null    object 
     4   Age          332 non-null    float64
     5   SibSp        418 non-null    int64  
     6   Parch        418 non-null    int64  
     7   Ticket       418 non-null    object 
     8   Fare         418 non-null    float64
     9   Embarked     418 non-null    object 
    dtypes: float64(2), int64(4), object(4)
    memory usage: 32.8+ KB
    
    Age_df = test_process[['Age','Pclass','SibSp','Parch','Fare']]
    UnknowAge = Age_df[Age_df.Age.isnull()].values
    KnowAge = Age_df[Age_df.Age.notnull()].values
    #y是目标年龄,x是已知属性
    y_train = KnowAge[:,0]
    x_train = KnowAge[:,1:]
    rfr = RandomForestRegressor(n_estimators=500,random_state=42)
    rfr.fit(x_train,y_train)
    predictedAges = rfr.predict(UnknowAge[:,1::])
    Age_df.loc[ (Age_df.Age.isnull()), 'Age' ] = predictedAges 
    test_process.Age=Age_df.Age.astype(int)
    

    文本数据处理

    对文本数据名字进行处理,把名字的称谓,长度,前名提取出来并舍弃名字变量。

    def change(df):
        df['Called'] = df['Name'].str.findall('Miss|Mr|Ms').str[0].to_frame()
        df['Name_length'] = df['Name'].apply(lambda x:len(x))
        df['First_name'] = df['Name'].str.split(',').str[0]
        df = df.drop(['Name'],axis=1)
        
    change(train_process)
    change(test_process)
    

    TargetEncoder

    把其他object类型变量进行编码处理。sklearn有很多种编码方式,target适用于特征无内在顺序,category数量 > 4的情况
    one-hot适用于特征无内在顺序,category数量 < 4的情况。

    import category_encoders
    from category_encoders import TargetEncoder
    X_train = train_process.iloc[:,2:]
    y_train = train_process.iloc[:,1]
    tar_encoder1 = TargetEncoder(cols=['Sex','Ticket','Embarked','Called','Name_length','First_name'],
                                 handle_missing='value',
                                 handle_unknown='value')
    
    tar_encoder1.fit(X_train,y_train)
    
    TargetEncoder(cols=['Sex', 'Ticket', 'Embarked', 'Called', 'Name_length',
                        'First_name'])
    
    X_train_encoded = tar_encoder1.transform(X_train)
    
    X_train_encoded.drop(['Name'],axis=1)
    
    PclassSexAgeSibSpParchTicketFareEmbarkedCalledName_lengthFirst_name
    030.18890822.0100.3838387.25000.3369570.2837210.2820510.103230
    110.74203838.0100.38383871.28330.5535710.2837210.9984760.383838
    230.74203826.0000.3838387.92500.3369570.6978020.3157890.383838
    310.74203835.0100.46875953.10000.3369570.2837210.9994390.468759
    430.18890835.0000.3838388.05000.3369570.2837210.3720930.468759
    ....................................
    88620.18890827.0000.38383813.00000.3369570.4920630.3250000.383838
    88710.74203819.0000.38383830.00000.3369570.6978020.3720930.632953
    88830.742038NaN120.10323023.45000.3369570.6978020.4284610.103230
    88910.18890826.0000.38383830.00000.5535710.2837210.3250000.383838
    89030.18890832.0000.3838387.75000.3896100.2837210.2343750.383838

    891 rows × 11 columns

    X_test = test_process 
    
    X_test.drop(['Name'],axis=1)
    
    PclassSexAgeSibSpParchTicketFareEmbarkedCalledName_lengthFirst_name
    PassengerId
    8923male34003309117.8292QMr16Kelly
    8933female47103632727.0000SMr32Wilkes
    8942male62002402769.6875QMr25Myles
    8953male27003151548.6625SMr16Wirz
    8963female2211310129812.2875SMr44Hirvonen
    ....................................
    13053male2500A.5. 32368.0500SMr18Spector
    13061female3900PC 17758108.9000CNaN28Oliva y Ocana
    13073male3800SOTON/O.Q. 31012627.2500SMr28Saether
    13083male25003593098.0500SMr19Ware
    13093male2211266822.3583CNaN24Peter

    418 rows × 11 columns

    X_test_encoded = tar_encoder1.transform(X_test)
    

    归一化

    后面要多模型验证,所以要把数据归一化。

    import sklearn.preprocessing as preprocessing
    scaler = preprocessing.StandardScaler()
    scaler.fit(X_train_encoded[['Age','Fare']])
    scaler.fit(X_test_encoded[['Age','Fare']])
    
    StandardScaler()
    
    X_train_encoded[['Age','Fare']] = scaler.transform(X_train_encoded[['Age','Fare']])
    X_test_encoded[['Age','Fare']] = scaler.transform(X_test_encoded[['Age','Fare']])
    

    模型预测

    from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import GridSearchCV
    from sklearn.linear_model import LogisticRegression
    from sklearn.ensemble import VotingClassifier
    from sklearn.svm import SVC
    
    
    X_train_encoded
    X_test_encoded
    
    PclassSexAgeSibSpParchTicketFareEmbarkedCalledName_lengthFirst_name
    PassengerId
    89230.1889080.325138000.383838-0.4970630.3896100.2837210.2307690.732634
    89330.7420381.326156100.383838-0.5119260.3369570.2837210.5652170.383838
    89420.1889082.481178000.383838-0.4637540.3896100.2837210.3272730.383838
    89530.188908-0.213872000.383838-0.4821270.3369570.2837210.2307690.383838
    89630.742038-0.598880110.383838-0.4171510.3369570.2837210.9994390.383838
    ....................................
    130530.188908-0.367875000.383838-0.4931050.3369570.2837210.2000000.383838
    130610.7420380.710145000.4687591.3145570.5535710.4920630.3720930.383838
    130730.1889080.633143000.383838-0.5074450.3369570.2837210.3720930.383838
    130830.188908-0.367875000.383838-0.4931050.3369570.2837210.2343750.383838
    130930.188908-0.598880110.834289-0.2366400.5535710.4920630.3720930.834289

    418 rows × 11 columns

    X_train_encoded.info()
    
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 11 columns):
     #   Column       Non-Null Count  Dtype  
    ---  ------       --------------  -----  
     0   Pclass       891 non-null    int64  
     1   Sex          891 non-null    float64
     2   Age          891 non-null    int32  
     3   SibSp        891 non-null    int64  
     4   Parch        891 non-null    int64  
     5   Ticket       891 non-null    float64
     6   Fare         891 non-null    float64
     7   Embarked     891 non-null    float64
     8   Called       891 non-null    float64
     9   Name_length  891 non-null    float64
     10  First_name   891 non-null    float64
    dtypes: float64(7), int32(1), int64(3)
    memory usage: 73.2 KB
    

    投票法

    先看看投票法

    lr_clf = LogisticRegression(penalty='l1',solver='saga',n_jobs=-1,max_iter=20000)
    rnd_clf = RandomForestClassifier(n_estimators=300,max_depth=8,min_samples_leaf=1,min_samples_split=5,random_state=42)
    svm_clf = SVC(C=2,kernel='poly',random_state=42,probability=True)
    voting_clf = VotingClassifier(estimators=[('lr',lr_clf),('rf',rnd_clf),('scv',svm_clf)],voting='soft')
    voting_clf.fit(X_train_encoded,y_train)
    
      VotingClassifier(estimators=[('lr',
                                      LogisticRegression(max_iter=20000, n_jobs=-1,
                                                         penalty='l1', solver='saga')),
                                     ('rf',
                                      RandomForestClassifier(max_depth=8,
                                                             min_samples_split=5,
                                                             n_estimators=300,
                                                             random_state=42)),
                                     ('scv',
                                      SVC(C=2, kernel='poly', probability=True,
                                          random_state=42))],
                         voting='soft')
    
    y_test = pd.read_csv(r'C:/Users/gender_submission.csv')
    
    y_test = y_test['Survived']
    
    
    from sklearn.metrics import accuracy_score
    
    for clf in (lr_clf,rnd_clf,svm_clf,voting_clf):
        clf.fit(X_train_encoded,y_train)
        y_pred = clf.predict(X_test_encoded)
        print(clf.__class__.__name__, accuracy_score(y_test, y_pred))
        
    
    LogisticRegression 0.6961722488038278
    RandomForestClassifier 0.80622009569378
    SVC 0.6363636363636364
    VotingClassifier 0.8110047846889952
    

    再试试XGBoost,果然效果比较好。

    XGBoost

    import xgboost
    from sklearn.metrics import mean_squared_error
    xgb_reg = xgboost.XGBRFRegressor(random_state=42)
    xgb_reg.fit(X_train_encoded,y_train)
    y_pred = xgb_reg.predict(X_test_encoded)
    val_error=mean_squared_error(y_test,y_pred)
    print("Validation MSE:", val_error) 
    
    Validation MSE: 0.5023153196818051
    
    展开全文
  • 泰坦尼克号数据集完整版,已经试验过,没有问题的,欢迎下载
  • 目录前言:介绍:过程:提出问题:理解数据:数据清洗:1、数据预处理2、 特征提取介绍分类数据:有直接类别的性别(Sex)登船港口(Embarked)客舱等级(Pclass)分类数据:字符串类型姓名(Name)客舱(Cabin)建立...

    前言:

    本文中的项目是Taggle的入门比赛项目,旨在让大家对Taggle的比赛有一个大致的了解和一些基本的操作。在参考了一些资料进行整理的情况下,总结出了这篇入门教学案例。
    本文就是就一个机器学习的整个过程进行了大致分析,帮助大家对机器学习有一个实践上的认识。最后,因为是入门案例,所有最后的正确率并没有太高—75%左右,在Taggle排在倒数,给我一点时间,后面会更新百分比正确率的方法。
    所需数据和代码:提取码:iiyk

    项目背景:
    泰坦尼克号的沉没是历史上最臭名昭著的沉船之一。
    1912年4月15日,人们普遍认为“永不沉没”的皇家邮轮“泰坦尼克”号在处女航中撞上冰山后沉没。不幸的是,船上没有足够的救生艇供所有人使用,导致2224名乘客和船员中有1502人死亡。
    虽然生存中有一些运气因素,但似乎有些人比其他人更有可能生存下来。
    在这个挑战中,我们要求你建立一个预测模型来回答这个问题:“什么样的人更适合存活下来?

    介绍:

    机器学习三层架构:

    image-20210808111612379

    机器学习的本质:机器取代人直接做决策

    云计算:用低成本存储和计算海量数据

    机器学习算法:人类思考决策的过程抽象成数学模型,用数学的方法给这个模型找到最优化的解,然后把这个解转换成代码命令,让机器可以去执行,完成机器大脑的构建。模型靠海量数据不断学习来优化自己的决策。

    机器学习的步骤:

    image-20210808113703481

    过程:

    提出问题:

    什么人在泰坦尼克号上更适合生存?

    泰坦尼克号的沉没是历史上最臭名昭著的沉船之一。

    1912年4月15日,人们普遍认为“永不沉没”的皇家邮轮“泰坦尼克”号在处女航中撞上冰山后沉没。不幸的是,船上没有足够的救生艇供所有人使用,导致2224名乘客和船员中有1502人死亡。

    虽然生存中有一些运气因素,但似乎有些人比其他人更有可能生存下来。

    在这个挑战中,我们要求你建立一个预测模型来回答这个问题:“什么样的人更容易存活下来。使用乘客数据(如姓名、年龄、性别、社会经济阶层等)。

    理解数据:

    1、导入查看数据所需要的包

    import numpy as np
    import pandas as pd
    

    2、导入数据文件

    #训练数据集
    train = pd.read_csv('./train.csv')
    #测试数据集
    test = pd.read_csv('./test.csv')
    

    注:数据文件可以在这个地址下载 百度网盘 提取码:62jt

    3、查看数据结构

    print('训练数据集:',train.shape,'测试数据集:',test.shape)
    

    image-20210808185004653

    训练数据集有891行,12列;测试数据集有418行,11列;

    测试数据集比训练数据集少了存活(Survived)这一列一列

    4、合并数据

    #合并数据集,方便同时对两个数据集进行清洗
    full = train.append(test,True)
    print('合并后的数据:',full.shape)
    

    image-20210808185326592

    5、查看数据

    用head()函数,可以返回前5行的数据

    #查看数据
    full.head()
    #Passengerld:顾客编号
    #Survived:1:存活,0:死亡
    #Plcass:一等舱,二等舱,三等舱
    #name:姓名
    #Sex: 性别
    #Age:年龄
    #SibSP:船上同代亲属数
    #Parch:船上不同代亲属数
    #Ticket:船票编号
    #Fare:船票价格
    #Cabin:客舱号
    #Embarked:登船港口 S:Southampton英国南安普顿 C:Cherbourg法国 瑟堡市 Q:Queenstowm爱尔兰 昆士敦
    

    image-20210808185413758

    6、获得数据描述信息

    describe()函数只能返回数字数据类型,不能查看字符串数据类型

    #获取数据类型列的描述统计信息
    full.describe()
    #count数据总数
    #mean平均值
    #std标准值
    #min最小值
    #25%下四份位数
    #50%中位数
    #75%上四分位数
    #max最大值
    

    image-20210808185606573

    其实在这里就可以看出问题,Fare的最小值为0。船票的价钱是不可能为0的,所以我们要注意数据的正确性。

    7、查看每一列数据类型

    #查看每一列的数据类型和数据总数
    full.info()
    

    image-20210808185943432

    在这里我们注意到,Survived、Age、Fare、Cabin、Embarked都存在数据缺失现象。
    我们发现数据总共有1309行。
    其中数据类型列:年龄(Age)、船票价格(Fare)里面有缺失数据:
    1)年龄(Age)里面数据总数是1046条,缺失了1309-1046=263,缺失率263/1309=20%
    2)船票价格(Fare)里面数据总数是1308条,缺失了1条数据

    字符串列:
    1)登船港口(Embarked)里面数据总数是1307,只缺失了2条数据,缺失比较少
    2)船舱号(Cabin)里面数据总数是295,缺失了1309-295=1014,缺失率=1014/1309=77.5%,缺失比较大
    这为我们下一步数据清洗指明了方向,只有知道哪些数据缺失数据,我们才能有针对性的处理。所以接下来我们要进行数据清洗。

    数据清洗:

    1、数据预处理

    image-20210808190428928

    在这个案例中,我们只需要进行第三步缺失数据处理和异常值进行处理

    缺失值进行处理

    机器学习算法为了训练模型,要求所传入的特征中不能有空值。

    1. 如果是数值类型,用平均值取代
    2. 如果是分类数据,用最常见的类别取代
    3. 使用模型预测缺失值,例如:K-NN
    #Age,Fare
    #对于缺失数字数据类型处理,使用平均值进行填充
    print('处理前:')
    full.info()
    #年龄(Age)
    full['Age']=full['Age'].fillna( full['Age'].mean() )
    #船票价格(Fare)
    full['Fare'] = full['Fare'].fillna( full['Fare'].mean() )
    print('处理红后:')
    full.info()
    

    image-20210808191851162

    '''
    Embarked
    字符串数据,用最常见的类别取代
    Embarked里的字符串类型:缺失较少
    出发地点:S=英国南安普顿Southampton
    途径地点1:C=法国 瑟堡市Cherbourg
    途径地点2:Q=爱尔兰 昆士敦Queenstown
    '''
    full['Embarked'].value_counts()
    

    image-20210808202712612

    S是最多次出现的字符串类型

    '''
    从结果来看,S类别最常见。我们将缺失值填充为最频繁出现的值:
    S=英国南安普顿Southampton
    '''
    full['Embarked'] = full['Embarked'].fillna( 'S' )
    

    查看Cabin

    #船舱号(Cabin):查看数据
    full['Cabin'].head()
    

    image-20210808203242616

    船舱号(Cabin)里面数据总数是295,缺失了1309-295=1014,缺失率=1014/1309=77.5%,缺失比较大。如果用最常见的数据代替,那不具有代表性,所以用未知(UKnow)代替

    #缺失数据比较多,船舱号(Cabin)缺失值填充为U,表示未知(Uknow) 
    full['Cabin'] = full['Cabin'].fillna( 'U' )
    

    查看最终缺失值处理情况,记住生成情况(Survived)这里一列是我们的标签,用来做机器学习预测的,不需要处理这一列

    #查看最终情况
    full.info()
    

    image-20210808204444592

    2、 特征提取

    建议学之前,阅读我的这一篇博客机器学习之特征工程进行一个大致的了解。

    介绍

    坊间常说:“数据和特征决定了机器学习的上限,而模型和算法只是逼近这个上限而已”。由此可见,特征工程在机器学习中占有相当重要的地位。在实际应用当中,可以说特征工程是机器学习成功的关键。

    数据分类

    查看数据类型,分为3种数据类型。并对类别数据处理:用数值代替类别,并进行One-hot编码,放入矩阵当中

    将特征抽象成数据,方便代码实现

    1.数值类型:
    乘客编号(PassengerId),年龄(Age),船票价格(Fare),同代直系亲属人数(SibSp),不同代直系亲属人数(Parch)
    2.时间序列:无
    3.分类数据:
    1)有直接类别的
    乘客性别(Sex):男性male,女性female
    登船港口(Embarked):出发地点S=英国南安普顿Southampton,途径地点1:C=法国 瑟堡市Cherbourg,出发地点2:Q=爱尔兰 昆士敦Queenstown
    客舱等级(Pclass):1=1等舱,2=2等舱,3=3等舱
    2)字符串类型:可能从这里面提取出特征来,也归到分类数据中
    乘客姓名(Name)
    客舱号(Cabin)
    船票编号(Ticket)

    分类数据:有直接类别的

    1. 乘客性别(Sex): 男性male,女性female
    2. 登船港口(Embarked):出发地点S=英国南安普顿Southampton,途径地点1:C=法国 瑟堡市Cherbourg,出发地点2:Q=爱尔兰 昆士敦Queenstown
    3. 客舱等级(Pclass):1=1等舱,2=2等舱,3=3等舱
    性别(Sex)
    '''
    将性别的值映射为数值
    男(male)对应数值1,女(female)对应数值0
    '''
    sex_mapDict={'male':1, 'female':0}
    #map函数:对Series每个数据应用自定义的函数计算
    full['Sex']=full['Sex'].map(sex_mapDict)
    full.head()
    

    image-20210808205947119

    登船港口(Embarked)

    登船港口就只要三个点:C,Q,S,而一个顾客对应这三个点中的一个,所以我们拆分成三个登船港口点:Embarked_C,Embarked_Q,Embarked_S。转换成数据模型就是[1,0,0],[0,1,0],[0,0,1]。这也叫做one-hot编码。

    #存放提取后的特征
    embarkedDf = pd.DataFrame()
    '''
    使用get_dummies进行one-hot编码,产生虚拟变量(dummy variables),列名前缀是Embarked
    '''
    embarkedDf = pd.get_dummies( full['Embarked'] , prefix='Embarked' )
    #查看前5个
    embarkedDf.head()
    

    image-20210809113115689

    #将Embarked替换成EmbarkedDF
    #删除Embarked
    full.drop('Embarked',axis=1,inplace=True)
    #替换
    full = pd.concat([full,embarkedDf],axis=1)
    #展示
    full.head()
    

    image-20210809112152706

    客舱等级(Pclass)

    同登船港口一样,客舱等级分为1,2,3三个等级,进行拆分Pclass_1,Pclass_2,Pclass_3,数据模型也为[1,0,0],[0,1,0],[0,0,1]。

    #Embarked,分为Pclass_1,Pclass_2,Pclass_3
    pclassDf = pd.DataFrame()
    #使用get_dummies进行one-hot编码,列名前缀是Pclass
    pclassDf = pd.get_dummies( full['Pclass'] , prefix='Pclass' )
    pclassDf.head()
    

    image-20210809112949856

    #添加one-hot编码产生的虚拟变量(dummy variables)到泰坦尼克号数据集full
    full = pd.concat([full,pclassDf],axis=1)
    
    #删掉客舱等级(Pclass)这一列
    full.drop('Pclass',axis=1,inplace=True)
    full.head()
    

    image-20210809113222798

    分类数据:字符串类型

    字符串类型:可能从这里面提取出特征来,也归到分类数据中,这里数据有:

    1. 乘客姓名(Name)
    2. 客舱号(Cabin)
    3. 船票编号(Ticket)
    姓名(Name)
    #查看姓名
    full[ 'Name' ].head()
    

    image-20210809150614104

    注意到在乘客名字(Name)中,有一个非常显著的特点:
    乘客头衔每个名字当中都包含了具体的称谓或者说是头衔,将这部分信息提取出来后可以作为非常有用一个新变量,可以帮助我们进行预测。

    我们看到姓名中’Braund, Mr. Owen Harris’,逗号前面的是“名”,逗号后面是‘头衔. 姓’

    '''
    定义函数:从姓名中获取头衔
    '''
    def getTitle(name):
        str1=name.split( ',' )[1] #Mr. Owen Harris
        str2=str1.split( '.' )[0]#Mr
        #strip() 方法用于移除字符串头尾指定的字符(默认为空格)
        str3=str2.strip()
        return str3
    
    #存放提取后的特征
    titleDf = pd.DataFrame()
    #map函数:对Series每个数据应用自定义的函数计算
    titleDf['Title'] = full['Name'].map(getTitle)
    
    #查看titleDF的种类
    titleDf.value_counts()
    

    image-20210809152016409

    我们现在已经知道了所有的头衔,一共18个。这太多了,进行进一步的简化。

    定义以下几种头衔类别:

    分类
    Mr已婚男士
    Mrs已婚妇女
    Royalty王室(皇室)
    Miss年轻未婚女子
    Master有技能的人/教师
    Officer政府官员
    头衔对应
    CaptOfficer
    ColOfficer
    MajorOfficer
    JonkheerRoyalty
    DonRoyalty
    SirRoyalty
    DrOfficer
    RevOfficer
    the CountessRoyalty
    DonaRoyalty
    MmeMrs
    MlleMiss
    MsMrs
    MrMr
    MrsMrs
    MissMiss
    MasterMaster
    LadyRoyalty

    基于以上的对应关系,用代码表示,并且用one-hot进行编码

    #姓名中头衔字符串与定义头衔类别的对应关系
    title_mapDict = {
                        "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"
                        }
    
    #map函数:对Series每个数据应用自定义的函数计算
    titleDf['Title'] = titleDf['Title'].map(title_mapDict)
    
    #使用get_dummies进行one-hot编码
    titleDf = pd.get_dummies(titleDf['Title'])
    
    #查看
    titleDf.head()
    

    image-20210809153145853

    再替换到full总表当中,同样是先删除再替换。

    #删掉姓名这一列
    full.drop('Name',axis=1,inplace=True)
    #添加one-hot编码产生的虚拟变量(dummy variables)到泰坦尼克号数据集full
    full = pd.concat([full,titleDf],axis=1)
    
    #查看
    full.head()
    

    image-20210809153413438

    客舱号(Cabin)

    查看客舱号

    #查看客舱号的内容
    full['Cabin'].head()
    

    image-20210809154435785

    我们用客舱号的首字母来代替客舱号的类别

    #存放客舱号信息
    cabinDf = pd.DataFrame()
    #取首字母
    full[ 'Cabin' ] = full[ 'Cabin' ].map( lambda c : c[0] )
    ##使用get_dummies进行one-hot编码,列名前缀是Cabin
    cabinDf = pd.get_dummies( full['Cabin'] , prefix = 'Cabin' )
    

    再替换到full总表当中,同样是先删除再替换。

    #删掉客舱号这一列
    full.drop('Cabin',axis=1,inplace=True)
    #添加one-hot编码产生的虚拟变量(dummy variables)到泰坦尼克号数据集full
    full = pd.concat([full,cabinDf],axis=1)
    
    #查看
    full.head()
    

    image-20210809163143299

    建立家庭人数和家庭类别(Family)

    家庭人数=同代直系亲属数(Parch)+不同代直系亲属数(SibSp)+乘客自己

    家庭类别:
    小家庭Family_Single:家庭人数=1
    中等家庭Family_Small: 2<=家庭人数<=4
    大家庭Family_Large: 家庭人数>=5

    #存放家庭信息
    familyDf = pd.DataFrame()
    #家庭人数
    familyDf[ 'FamilySize' ] = full[ 'Parch' ] + full[ 'SibSp' ] + 1
    #家庭类别
    #if 条件为真的时候返回if前面内容,否则返回0
    familyDf[ 'Family_Single' ] = familyDf[ 'FamilySize' ].map( lambda s : 1 if s == 1 else 0 )
    familyDf[ 'Family_Small' ]  = familyDf[ 'FamilySize' ].map( lambda s : 1 if 2 <= s <= 4 else 0 )
    familyDf[ 'Family_Large' ]  = familyDf[ 'FamilySize' ].map( lambda s : 1 if 5 <= s else 0 )
    

    查看结果:

    familyDf.head()
    

    image-20210809163807396

    添加到full总表中

    #添加one-hot编码产生的虚拟变量(dummy variables)到泰坦尼克号数据集full
    full = pd.concat([full,familyDf],axis=1)
    

    查看结果:

    full.head()
    

    image-20210809164028762

    结果:

    到现在为止,所有的特征就已经提取完毕了。

    查看最后结构

    #查看总表结构
    full.shape
    

    image-20210809164258027

    也就是说明现在有1309行数据,每行数据由33个特征值

    3、特征选择

    数据和特征决定了机器学习的上限,而模型和算法只是逼近这个上限而已

    '''
    DataFrame.corr(method='pearson', min_periods=1)
    参数说明:
    method:可选值为{‘pearson’, ‘kendall’, ‘spearman’}
    pearson:Pearson相关系数来衡量两个数据集合是否在一条线上面,即针对线性数据的相关系数计算,针对非线性数据便会有误差。
    kendall:用于反映分类变量相关性的指标,即针对无序序列的相关系数,非正太分布的数据
    spearman:非线性的,非正太分析的数据的相关系数
    min_periods:样本最少的数据量
    返回值:各类型之间的相关系数DataFrame表格。
    '''
    corrDf = full.corr() 
    
    #查看pearson相关系数
    corrDf
    

    image-20210811153235277

    '''
    查看各个特征与生成情况(Survived)的相关系数,
    ascending=False表示按降序排列
    '''
    corrDf['Survived'].sort_values(ascending =False)
    

    image-20210811153818777

    根据各个特征与生成情况(Survived)的相关系数大小,我们选择了这几个特征作为模型的输入:

    头衔(前面所在的数据集titleDf)、客舱等级(pclassDf)、家庭大小(familyDf)、船票价格(Fare)、船舱号(cabinDf)、登船港口(embarkedDf)、性别(Sex)

    构建模型

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

    1、建立训练数据集和测试数据集

    1)泰坦尼克号测试数据集因为是我们最后要提交给Kaggle的,里面没有生存情况的值,所以不能用于评估模型。
    我们将Kaggle泰坦尼克号项目给我们的测试数据,叫做预测数据集(记为pred,也就是预测英文单词predict的缩写)。
    也就是我们使用机器学习模型来对其生存情况就那些预测。
    2)我们使用Kaggle泰坦尼克号项目给的训练数据集,做为我们的原始数据集(记为source),
    从这个原始数据集中拆分出训练数据集(记为train:用于模型训练)和测试数据集(记为test:用于模型评估)。

    sourceRow是我们在最开始合并数据前知道的,原始数据集有总共有891条数据
    从特征集合full_X中提取原始数据集提取前891行数据时,我们要减去1,因为行号是从0开始的。

    loc函数,loc指的是location。参数指的是索引,也就是[行,列]

    #原始数据集有891行
    sourceRow=891
    #原始数据集:特征
    source_X = full_X.loc[0:sourceRow-1]
    #原始数据集:标签
    source_y = full.loc[0:sourceRow-1,'Survived']
    #预测数据集:特征
    pred_X = full_X.loc[sourceRow:,:]
    

    确保这里原始数据集取的是前891行的数据,不然后面模型会有错误

    #原始数据集有多少行
    print('原始数据集有多少行:',source_X.shape[0])
    #预测数据集大小
    print('预测数据集有多少行:',pred_X.shape[0])
    

    image-20210811211820404

    从原始数据集(source)中拆分出训练数据集(用于模型训练train),测试数据集(用于模型评估test)
    train_test_split是交叉验证中常用的函数,功能是从样本中随机的按比例选取train data和test data
    train_data:所要划分的样本特征集
    train_target:所要划分的样本结果
    test_size:样本占比,如果是整数的话就是样本的数量

    from sklearn.cross_validation import train_test_split 
    
    #建立模型用的训练数据集和测试数据集
    train_X, test_X, train_y, test_y = train_test_split(source_X ,
                                                        source_y,
                                                        train_size=.8)
    
    #输出数据集大小
    print ('原始数据集特征:',source_X.shape, 
           '训练数据集特征:',train_X.shape ,
          '测试数据集特征:',test_X.shape)
    
    print ('原始数据集标签:',source_y.shape, 
           '训练数据集标签:',train_y.shape ,
          '测试数据集标签:',test_y.shape)
    

    image-20210811211941709

    查看数据

    #原始数据查看
    source_y
    

    image-20210811213640268

    2、 选择机器学习算法

    这里使用逻辑回归(logisic regression)

    #第1步:导入算法
    from sklearn.linear_model import LogisticRegression
    #第2步:创建模型:逻辑回归(logisic regression)
    model = LogisticRegression()
    
    

    3、训练模型

    #第3步:训练模型
    model.fit( train_X , train_y )
    

    评估模型

    # 分类问题,score得到的是模型的正确率
    model.score(test_X , test_y )
    

    image-20210811220102780

    方案实施

    得到预测结果上传到Kaggle

    使用预测数据集到底预测结果,并保存到csv文件中,上传到Kaggle中,就可以看到排名。

    #使用机器学习模型,对预测数据集中的生存情况进行预测
    pred_Y = model.predict(pred_X)
    
    '''
    生成的预测值是浮点数(0.0,1,0)
    但是Kaggle要求提交的结果是整型(0,1)
    所以要对数据类型进行转换
    '''
    pred_Y=pred_Y.astype(int)
    #乘客id
    passenger_id = full.loc[sourceRow:,'PassengerId']
    #数据框:乘客id,预测生存情况的值
    predDf = pd.DataFrame( 
        { 'PassengerId': passenger_id , 
         'Survived': pred_Y } )
    predDf.shape
    predDf.head()
    #保存结果
    predDf.to_csv( 'titanic_pred.csv' , index = False )
    

    3、训练模型

    #第3步:训练模型
    model.fit( train_X , train_y )
    

    评估模型

    # 分类问题,score得到的是模型的正确率
    model.score(test_X , test_y )
    

    [外链图片转存中…(img-PYohazeb-1628692759422)]

    方案实施

    得到预测结果上传到Kaggle

    使用预测数据集到底预测结果,并保存到csv文件中,上传到Kaggle中,就可以看到排名。

    #使用机器学习模型,对预测数据集中的生存情况进行预测
    pred_Y = model.predict(pred_X)
    
    '''
    生成的预测值是浮点数(0.0,1,0)
    但是Kaggle要求提交的结果是整型(0,1)
    所以要对数据类型进行转换
    '''
    pred_Y=pred_Y.astype(int)
    #乘客id
    passenger_id = full.loc[sourceRow:,'PassengerId']
    #数据框:乘客id,预测生存情况的值
    predDf = pd.DataFrame( 
        { 'PassengerId': passenger_id , 
         'Survived': pred_Y } )
    predDf.shape
    predDf.head()
    #保存结果
    predDf.to_csv( 'titanic_pred.csv' , index = False )
    
    展开全文
  • 方案实施提交结果报告撰写一、提出问题什么样的人可以在泰坦尼克号事故中生存下来二、理解数据① 导入数据(pd.read_csv)先导入处理数据包Numpy和Pandas导入文件的时候注意应该用左划线(“/”),而在文件中复制路径...

    机器学习分析步骤:提出问题

    2. 理解数据导入数据

    采集数据

    查看数据集信息

    3. 数据清洗数据预处理

    特征工程

    4. 构建模型

    5. 模型评估

    6. 方案实施提交结果

    报告撰写

    一、提出问题

    什么样的人可以在泰坦尼克号事故中生存下来

    二、理解数据

    ① 导入数据(pd.read_csv)

    先导入处理数据包Numpy和Pandas导入文件的时候注意应该用左划线(“/”),而在文件中复制路径时是右划线D:\BaiduYunDownload

    路径可以用双引号,也可以用单引号,结果是一样的

    这里将泰坦尼克号数据中的train训练数据和test测试数据导入,测试数据集比训练数据集少1列,缺少的这些数据由接下来的机器学习进行计算。

    ② 数据合并(append)

    因为train数据和test数据是分开进行导入的,为了方便进行数据清洗,先将两种数据进行合并

    #数据1. append(#数据2,ignore_index=True)ignore_index默认为False,默认情况下会把添加的数据的索引行号保留下来,若ignore_index=Ture则会对所有的行重新自动建立索引。

    ③ 查看数据集信息(head()、describe()、info())

    Age:年龄; Cabin:客舱号; Embarked:上船的港口号;

    Fare:船票费用; Name:姓名;

    Parch:船上的不同代直系亲属数(父母子女);

    SibSp:船上的同代直系亲属数(兄弟姐妹或配偶);

    PassengerId:乘客编号; Pclass:客舱等级(1为1等舱,3为3等舱);

    Sex:性别; Survived:是否存活(1代表存活,0代表死亡); Ticket:船票编号

    有的数据随便是数值,但是是字符串类型的,不能进行运算,在实际计算中应该确认好各数据的类型

    显示Age、Cabin、Fare、Embarked、Survived列是有缺失值的,其中Age列数据缺失约20%,Cabin列数据缺失约80%。确认数据缺失情况有注意

    三、数据清洗

    ① 数据预处理选择子集

    以上所有数据列均有用,无需选择子集列名重命名

    无需重命名,我都能看懂缺失数据处理

    根据情况对有缺失值的数据列进行填充

    其中Age、Fare列是数值型数据,可以填充该列数据的平均值,尽可能少影响总体数值

    Cabin和Embarked列是字符串数据,可以填充出现次数最多的数据进行填充,若需要填充的数据太多,可填充一种新的数据,方便以后计算

    其中Embarked数据列缺失数据少,填充使用频率最高的‘S’;Cabin因缺失数据太多,填充一个新的字幕‘U’

    处理完的数据信息如下:数据类型转换

    数据排序

    异常值处理

    ② 特征工程

    特征工程即最大限度地从原始数据中提取特征X以供机器学习算法和模型使用

    特征工程分为特征提取与特征选择和特征降维特征提取数值类型:直接使用

    时间序列(在一段时间内定期收集的数据):转成单独年、月、日

    分类数据(字符串数据也属于其中):用数值代替类别One-Hot编码

    直接分类:Sex数据列(性别)

    将‘Sex’数据列的数据映射为数值

    本来应该是male或者female的数据列,换成了1或者0

    直接分类:Embarked数据列(pd.get_dummies)

    将‘Embarked’数据列的数据拆分为三个不同的列,空值使用0填充,列名使用Embarked作为前缀

    将其插入至suoyou数据集,并删除原有的‘Embarked’数据列

    concat为连接函数,默认为axis=0,

    若axis=0时,类似于onion函数,索引值沿用原来的

    若axis=1,重新建立索引值

    inplace参数的理解:

    修改一个对象时:

    inplace=True:不创建新的对象,直接对原始对象进行修改;

    inplace=False:对数据进行修改,创建并返回新的对象承载其修改结果。

    直接分类:Pclass数据列(客舱等级)(pd.get_dummies)

    字符串类型:Name数据列

    显示Name数据列,会发现名字都是由 “名,头衔. 姓”组成的字符串格式,头衔可以提取出来进行分析

    首先建立分离函数,并使用map方法将整列的头衔全部提取出来

    分离函数中使用split方法进行分离,使用strip方法去除字符串的空格

    再将头衔进行归类,建立Series并使用map方法使其一一对应,将其添加进数据表,并删除原有'Name'数据列

    字符串类型:Cabin数据列(lambda函数)

    Cabin的数据中有的只有一个字母,有的有多个字母,为了方便,取所有数据中的首字母进行分析

    取首字母的函数可使用lambda进行建立

    lambda 变量:表达式

    如:lambda c:c[0]

    字符串类型:SibSp数据列和Parch数据列

    SibSp数据列和Parch数据列的特征是可以提取与合并的

    SibSp数值与Parch数值的和再加一,即乘客的家庭人员数量,通过家庭人员数量,可以划分出家庭规模的范围,使用lambda方法进行函数设定

    函数也可以是关系表达式

    将familyDf添加进数据集中

    suoyou=pd.concat([suoyou,familyDf],axis=1)

    ③ 特征选择

    相关系数法:计算各个特征的相关系数

    特征选择

    根据相关性系数的大小,选择头衔、客舱等级、家庭大小、船票价格、船舱号、登船渡口、性别数据列进行分析

    ④ 构建模型

    建立训练数据集和测试数据集

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

    首先将suoyou数据集拆分回train数据和test数据

    因为行号是从0开始的,所以选择行号等于sourceRow时,应该选择0到sourceRow-1

    shape表示多少行和列,shape[0]为多少行,shape[1]为多少列

    再将train数据进一步拆分为训练与测试数据

    前80%为训练数据,后20%为测试数据

    选择并训练机器学习算法(此处选择逻辑回归算法)

    选择与训练机器学习算法步骤:导入算法(import)

    创建模型(model)

    训练模型(model.fit)

    评估模型(model.score)

    score语句得到的是模型的正确率,可以看出正确率还是较高的

    预测结果,并将数据列的类型转换为Kaggle可识别的整数型,并使用series将乘客ID与survive情况一一对应

    将预测结果导出至csv文件

    predDf.to_csv( 'titanic_pred.csv' , index = False )

    展开全文
  • 天善智能kaggle案例,https://edu.hellobi.com/course/137,泰坦尼克号预测,讲师唐老师
  • 泰坦尼克号之灾事件中,建立乘客获救情况(是/否)与其诸背景特征之间的量化模型,并且依据此模型来预测有某些背景的人在该海难中能否获救。 二 课题分析: 2.1 选择模型 一个二分类问题。常用的分类算法有逻辑...
  • 经典又兼具备趣味性的案例泰坦尼克号问题源码。大家都熟悉的『Jack and Rose』的故事,豪华游艇倒了,大家都惊恐逃生,可是救生艇的数量有限,无法人人都有,副船长发话了『lady and kid first!』,所以是否获救...
  • 该数据是kaggle的泰坦尼克号幸存者预测大赛的数据。有训练集和测试集两部分组成
  • scores= cross_val_score(gbdt,x,y,cv = 5,scoring = "accuracy")print(np.mean(scores)) 5 总结 经过数据探索、数据处理、常用机器学习模型比较,最后可以发现GBDT在泰坦尼克号生存预测上面表现最好,准确率能达到...
  • 决策树:泰坦尼克号生存预测决策树:
  • 泰坦尼克号生还预测数据集
  • 泰坦尼克号生存者预测训练集。泰坦尼克海难是著名的十大灾难之一,究竟多少人遇难,各方统计的结果不一。现在我们可以得到部分的数据。
  • 背景:泰坦尼克号(RMS Titanic)是英国白星航运公司下辖的一艘奥林匹克级邮轮,于1909年3月31日在爱尔兰贝尔法斯特港的哈兰德与沃尔夫造船厂动工建造。她是当时世界上体积最庞大、内部设施最豪华的客运轮船,有“永不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,108
精华内容 2,443
关键字:

泰坦尼克号预测

友情链接: perf-timechart.rar