Titanic数据分析项目——Kaggle数据分析项目实战1

目前预测准确度达到77.511%, 会持续优化并且更新。

一、特征工程：

1、先对缺失值进行填充，先找到缺失值的位置，数值型数据填充众数，字符数据或者是离散型数据则填充出现最多的数据。
2、标准化数值型数据， 根据标准化数据公式：
$$x_{\text{standardized}}=\frac{x-\text{mean}(x)}{\text{std}(x)}$$
3、增加特征值：
(1) 票价等级：将票价大于均值的记为1，将票价小于等于均值的记为0，分别表示票价高者和票价低者。
(2) 是否存在亲属：将有亲属的标记位1，无亲属的标记为0。
(3) 同船亲属的数量，将同船的有关系的人数加起来，并且初始化这一列数据。
(4) 同船亲属的数量等级：求出同船亲属数量大于同船亲属数量的均值，记为1，小于等于同船亲属数量，记为0。
(5) 通过对字符型数据也就是"name"那一列的观察与处理，发现会有三种不同的称呼: “Mrs”, “Miss”, “Mr”，分别记为0, 1, -1。
(6) 年龄级别: 将大于平均年龄的记为1,小于等于平均年龄的记为0
(7) 还在思考，后续会进行补充…

特征工程代码实现：

from sklearn.preprocessing import StandardScaler
us_list = ['舱位等级', '性别', '年龄', '同船的兄弟姐妹/配偶数量', '同船的父母/孩子数量', '船票号码', '票价', '船舱号码', '登船港口'] 

#处理数据
def Work_Data(df):
   

    List1 = [] 
    for i in df.index:
        # print(df.loc[i, '姓名'])
        ustr = str(df.loc[i, '姓名'])
        if ustr.find("Mrs") >= 0:
            List1.append(1) 
        elif ustr.find("Miss"):
            List1.append(2) 
        else:
            List1.append(0) 

    df['称呼'] = List1

    for i in df.columns:
        us = df[i].mode()[0] 
        df[i].fillna(us, inplace = True)    
        if isinstance(list(df[i])[0], (int, float)):
            continue
        dic = dict() 
        idx = 0 
        for j in set(df[i]): 
            dic[j] = idx
            idx += 1 
        for j in df.index:
            df.loc[j, i] = dic[df.loc[j, i]] 

    List1 = [] 
    for i in df.index:
        if df.loc[i,'同船的兄弟姐妹/配偶数量'] > 0 or df.loc[i,'同船的父母/孩子数量'] > 0:
            List1.append(1)
        else:
            List1.append(0) 

    df['是否存在亲属'] = List1
    List1 = [] 
    arg_pj = sum(list(df3['票价'])) / len(list(df3['票价'])) 
    for i in df.index:
        if df.loc[i, '票价'] > arg_pj:
            List1.append(1)
        else:
            List1.append(0) 
     
    df['票价等级'] = List1

    us = [] 
    for i in df.index:
        us.append(df.loc[i, '同船的兄弟姐妹/配偶数量'] + df.loc[i, '同船的父母/孩子数量']) 
    x = sum(us) / len(us)
    List1 = []         
    for i in us:
        if i > x:
            List1.append(1)
        else:
            List1.append(0) 
    
    df['同船亲属的数量等级'] = List1

    List1 = [] 
    for i in df.index:
        List1.append(df.loc[i, '同船的兄弟姐妹/配偶数量'] + df.loc[i, '同船的父母/孩子数量']) 

    df['同船有关系的人的数量'] = List1 
    
    List1 = []
    
    x = sum(df['年龄']) / len(df['年龄']) 

    for i in df.index:
        if df.loc[i, '年龄'] > x:
            List1.append(1) 
        else:
            List1.append(0) 
    df['年龄级别'] = List1 

    for i in ['年龄', '票价']:
        scaler = StandardScaler()
        x = [[x] for x in df[i]]
        # 首先拟合 StandardScaler 对象
        scaler.fit(x)
        # 使用 transform 方法对数据进行标准化
        x = scaler.transform(x)
        us = []
        for j in x:
            for k in j:
                us.append(k) 
        df[i] = us


    return df 

---

二、从数据中处理出测试集和训练集带入模型中

1、先求出测试数据和训练数据：

df = Work_Data(df3) 

df3 = Work_Data(df3)
train_x, train_y = [], [] 

us_list.append("票价等级")
us_list.append("是否存在亲属") 
us_list.append("同船亲属的数量等级")
us_list.append("称呼") 
us_list.append("同船有关系的人的数量") 
us_list.append('年龄级别') 

for i in df.index:
    uslist = [] 
    for j in us_list:
        uslist.append(df.loc[i,j]) 
    train_x.append(uslist) 
    train_y.append(df.loc[i,'是否生还'])
    
# 构造测试集合：
test_x = [] 
df = Work_Data(df2) 
df2 = Work_Data(df2) 

for i in df.index:
    uslist = [] 
    for j in us_list:
        uslist.append(df.loc[i,j]) 
    test_x.append(uslist) 

2、模型带入

(1) 逻辑回归:

研究了一下逻辑回归处理离散型数据的方法，处理离散型数据的逻辑回归方法与处理连续型数据的逻辑回归方法类似

1. 数据预处理：

   • 确保数据中的离散型特征已经被编码为数值类型。可以使用独热编码、标签编码等方法将离散型特征转换为数值型特征。

2. 模型训练：

   • 使用逻辑回归模型训练数据。逻辑回归模型的目标是找到最佳的参数（系数），以最大化似然函数或最小化损失函数。通常使用梯度下降等优化算法来训练模型。

3. 模型评估：

   • 使用测试集评估模型的性能。可以使用各种评估指标，如准确率、精确率、召回率、F1 分数等来评估模型的性能。

4. 调整模型：

   • 根据评估结果，可能需要调整模型的超参数或特征工程方法，以提高模型的性能。

5. 解释结果：

   • 分析模型的系数，了解离散型特征对目标变量的影响。系数的正负和大小可以告诉我们特征对目标变量的影响程度。

   总之，对于二分类问题，无论是离散型数据还是连续型数据逻辑回归都是报错的选择, 因为它都有自己的处理方法。

# 训练逻辑回归模型
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score


# 特征缩放
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(train_x)
X_test_scaled = scaler.transform(test_x)

# 初始化逻辑回归模型
log_reg = LogisticRegression()

# 拟合模型
log_reg.fit(X_train_scaled, train_y)


# 预测测试集
y_pred = log_reg.predict(X_test_scaled)

(2) 随机森林：

#随机森林：
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

clf = RandomForestClassifier(n_estimators=1000, random_state=42)

# 在训练集上拟合模型
clf.fit(train_x, train_y)

# 在测试集上做出预测
y_pred = clf.predict(test_x)

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

随缘更新…