1 样本处理

1.1 载入样本代码—Titanic forecast.py（第1部分）

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from scipy import stats
import pandas as pd
import matplotlib.pyplot as plt
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

def moving_average(a, w=10):#定义函数计算移动平均损失值
    if len(a) < w:
        return a[:]
    return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]

def plot_losses(losses):
    avgloss= moving_average(losses) #获得损失值的移动平均值
    plt.figure(1)
    plt.subplot(211)
    plt.plot(range(len(avgloss)), avgloss, 'b--')
    plt.xlabel('step number')
    plt.ylabel('Training loss')
    plt.title('step number vs. Training loss')
    plt.show()


###1.1 载入样本
titanic_data = pd.read_csv('csv_list/titanic3.csv')
print(titanic_data.columns)
# 输出：Index(['pclass', 'survived', 'name', 'sex', 'age', 'sibsp', 'parch', 'ticket','fare', 'cabin', 'embarked', 'boat', 'body', 'home.dest'],dtype='object')

1.2 离散数据

1.2.1 离散数据的特征

数据之间没有任何连续性的数据称为离散数据，例如数据中的男性和女性。

离散数据通常可以处理为one-hot编码或者词向量，可以分为两类：

① 具有固定类别（性别）的样本：易于处理，根据总类别进行转换

②没有固定类别的样本（姓名）：通过hash算法或其他散列算法处理，再通过词向量技术进行转化

1.2.2 连续数据的特征

数据之间具有连续性的数据，称为连续数据，例如票价和年龄

对于连续数据做特征变化时，通过对数运算or归一化处理，使其具有统一的值域

1.2.3 连续数据与离散数据的转化

大跨度特征属性的数据预处理有以下三种方法：

① 根据最大​​值和最小值进行归一化

②使用对数运算

③根据分布，分为几类，然后离散化

1.3 处理样本中的离散数据与NAn值

1.3.1 将离散数据转化为one-hot编码 代码—Titanic forecast.py（第2部分）

###1.2 处理样本中的离散数据与Nan值
# 将离散数据的字段转化为one-hot
# get_dummies()会根据指定列中的离散值转化为one-hot编码，并将转化后所生成的新列放到原有数据的后面，在新的列中的数据用0，1来表示是否具有该列的属性。
titanic_data = pd.concat(
    [titanic_data,
     pd.get_dummies(titanic_data['sex']),
     pd.get_dummies(titanic_data['embarked'],prefix="embark"),
     pd.get_dummies(titanic_data['pclass'],prefix="class")],axis=1
)
print(titanic_data.columns)
# 输出：Index(['pclass', 'survived', 'name', 'sex', 'age', 'sibsp', 'parch', 'ticket', 'fare', 'cabin', 'embarked', 'boat', 'body', 'home.dest', 'female', 'male', 'embark_C', 'embark_Q', 'embark_S', 'class_1', 'class_2','class_3'],dtype='object')
print(titanic_data['sex'])
print(titanic_data['female']) # 在sex列中，值为female的行，在female列中值为1

1.3.2 对数据中的Nan值进行过滤填充代码—Titanic forecast.py（第3部分）

对于两个具有连续属性的数据列进行Nan值处理，age与fare。

# 对Nan值进行过滤填充
# 调用fillna()对特定列的NAn值进行过滤，并用该列的平均值进行填充
titanic_data["age"] = titanic_data["age"].fillna(titanic_data["age"].mean()) # 乘客年龄
titanic_data["fare"] = titanic_data["fare"].fillna(titanic_data["fare"].mean()) # 乘客票价

1.3.3 剔除无用的数据列代码—Titanic forecast.py（第4部分）

本节不包括与死亡无关的数据列。

## 去除与是否获取无关的数据列
titanic_data = titanic_data.drop(['name','ticket','cabin','boat','body','home.dest','sex','embarked','pclass'], axis=1)
print(titanic_data.columns ) # 输出真正需要处理的数据列

1.4 分离样本与标签并制作数据集代码—Titanic forecast.py（第5部分）

将suivived列从数据集中抽取出来，将数据列中剩下的数据作为输入样本。

### 1.3 分离样本和标签并制作数据集
# 分离样本
labels = titanic_data["survived"].to_numpy()

titanic_data = titanic_data.drop(['survived'],axis=1)
data = titanic_data.to_numpy()

# 样本属性名称
feature_names = list(titanic_data.columns)

# 将样本分为训练和测试两部分
np.random.seed(10) # 设置随机种子，保证每次运行所分的样本一致

# set() 函数创建一个无序不重复元素集,x-y返回一个新的集合,包括在集合x中但不在集合y中的元素
# random.choice(a=5, size=3, replace=False, p=None) 参数意思分别 是从a中以概率P随机选择3个, p没有指定的时候相当于是一致的分布
# 按照行号提取
train_indices = np.random.choice(len(labels),int(0.7 * len(labels)),replace = False)
print('train_indices++++',train_indices)
test_indices = list(set(range(len(labels))) - set(train_indices)) #将剩余部分设为测试集
print('train_indices++++',train_indices)

# data[:]相当于重新拷贝一个列表，列表是可变对象如果直接引用传参给函数，则会导致修改其中任意一个变量，其余变量相应改变。但是，通过这种方式可以避免这种情况。
train_features = data[train_indices]
train_labels = labels[train_indices]

test_features = data[test_indices]
test_labels = labels[test_indices]
print('测试样本数量',len(test_labels)) # 测试样本数量 393

2 训练模型

2.1 定义Mish激活函数与多层全连接网络代码—Titanic forecast.py（第6部分）

###定义Mish激活函数与多层全连接网络
# 定一个带有3层全连接网络的类，每个网络层使用Mish作为激活函数，该模型使用交叉熵损失函数
class Mish(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self,x):
        x = x * (torch.tanh(F.softplus(x)))
        return x

torch.manual_seed(0) # 设置随机种子函数

class ThreeLinearModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(12,12)
        self.mish1 = Mish()
        self.linear2 = nn.Linear(12,8)
        self.mish2 = Mish()
        self.linear3 = nn.Linear(8,2)
        self.softmax = nn.Softmax(dim = 1)
        self.criterion = nn.CrossEntropyLoss() #定义交叉熵

    def forward(self,x): # 定义一个全连接网络
        lin1_out = self.linear1(x)
        out_1 = self.mish1(lin1_out)
        out_2 = self.mish2(self.linear2(out_1))
        return self.softmax(self.linear3(out_2))

    def getloss(self,x,y): # 实现类的损失值计算接口
        y_pred = self.forward(x)
        loss = self.criterion(y_pred,y)
        return loss

2.2 训练模型并输出结果代码—Titanic forecast.py（第7部分）

### 训练模型并输出结果
if __name__ == '__main__':
    net = ThreeLinearModel()
    num_epochs = 200
    optimizer = torch.optim.Adam(net.parameters(),lr = 0.04)

    # 将输入的样本标签转化为标量
    input_tensor = torch.from_numpy(train_features).type(torch.FloatTensor)
    label_tensor = torch.from_numpy(train_labels)
    losses = [] # 定义损失值列表
    for epoch in range(num_epochs):
        loss = net.getloss(input_tensor, label_tensor)
        losses.append(loss.item())
        optimizer.zero_grad()  # 清空之前的梯度
        loss.backward()  # 反向传播损失值
        optimizer.step()  # 更新参数
        if epoch % 20 == 0:
            print('Epoch {}/{} => Loss: {:.2f}'.format(epoch + 1, num_epochs, loss.item()))

    os.makedirs('models', exist_ok=True)
    torch.save(net.state_dict(), 'models/titanic_model.pt')

    plot_losses(losses)

    # 输出训练结果
    # tensor.detach():从计算图中脱离出来，返回一个新的tensor，新的tensor和原tensor共享数据内存，（这也就意味着修改一个tensor的值，另外一个也会改变），
    #                  但是不涉及梯度计算。在从tensor转换成为numpy的时候，如果转换前面的tensor在计算图里面（requires_grad = True），那么这个时候只能先进行detach操作才能转换成为numpy
    out_probs = net(input_tensor).detach().numpy()
    out_classes = np.argmax(out_probs, axis=1)
    print("Train Accuracy:", sum(out_classes == train_labels) / len(train_labels))

    # 测试模型
    test_input_tensor = torch.from_numpy(test_features).type(torch.FloatTensor)
    out_probs = net(test_input_tensor).detach().numpy()
    out_classes = np.argmax(out_probs, axis=1)
    print("Test Accuracy:", sum(out_classes == test_labels) / len(test_labels))

3.0 代码汇总

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from scipy import stats
import pandas as pd
import matplotlib.pyplot as plt
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

def moving_average(a, w=10):#定义函数计算移动平均损失值
    if len(a) < w:
        return a[:]
    return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]

def plot_losses(losses):
    avgloss= moving_average(losses) #获得损失值的移动平均值
    plt.figure(1)
    plt.subplot(211)
    plt.plot(range(len(avgloss)), avgloss, 'b--')
    plt.xlabel('step number')
    plt.ylabel('Training loss')
    plt.title('step number vs. Training loss')
    plt.show()


###1.1 载入样本
titanic_data = pd.read_csv('csv_list/titanic3.csv')
print(titanic_data.columns)
# 输出：Index(['pclass', 'survived', 'name', 'sex', 'age', 'sibsp', 'parch', 'ticket','fare', 'cabin', 'embarked', 'boat', 'body', 'home.dest'],dtype='object')

###1.2 处理样本中的离散数据与Nan值
# 将离散数据的字段转化为one-hot
# get_dummies()会根据指定列中的离散值转化为one-hot编码，并将转化后所生成的新列放到原有数据的后面，在新的列中的数据用0，1来表示是否具有该列的属性。
titanic_data = pd.concat(
    [titanic_data,
     pd.get_dummies(titanic_data['sex']),
     pd.get_dummies(titanic_data['embarked'],prefix="embark"),
     pd.get_dummies(titanic_data['pclass'],prefix="class")],axis=1
)
print(titanic_data.columns)
# 输出：Index(['pclass', 'survived', 'name', 'sex', 'age', 'sibsp', 'parch', 'ticket', 'fare', 'cabin', 'embarked', 'boat', 'body', 'home.dest', 'female', 'male', 'embark_C', 'embark_Q', 'embark_S', 'class_1', 'class_2','class_3'],dtype='object')
print(titanic_data['sex'])
print(titanic_data['female']) # 在sex列中，值为female的行，在female列中值为1
# 对Nan值进行过滤填充
# 调用fillna()对特定列的NAn值进行过滤，并用该列的平均值进行填充
titanic_data["age"] = titanic_data["age"].fillna(titanic_data["age"].mean()) # 乘客年龄
titanic_data["fare"] = titanic_data["fare"].fillna(titanic_data["fare"].mean()) # 乘客票价

## 去除与是否获取无关的数据列
titanic_data = titanic_data.drop(['name','ticket','cabin','boat','body','home.dest','sex','embarked','pclass'], axis=1)
print(titanic_data.columns )


### 1.3 分离样本和标签并制作数据集
# 分离样本
labels = titanic_data["survived"].to_numpy()

titanic_data = titanic_data.drop(['survived'],axis=1)
data = titanic_data.to_numpy()

# 样本属性名称
feature_names = list(titanic_data.columns)

# 将样本分为训练和测试两部分
np.random.seed(10) # 设置随机种子，保证每次运行所分的样本一致

# set() 函数创建一个无序不重复元素集,x-y返回一个新的集合,包括在集合x中但不在集合y中的元素
# random.choice(a=5, size=3, replace=False, p=None) 参数意思分别 是从a中以概率P随机选择3个, p没有指定的时候相当于是一致的分布
# 按照行号提取
train_indices = np.random.choice(len(labels),int(0.7 * len(labels)),replace = False)
print('train_indices++++',train_indices)
test_indices = list(set(range(len(labels))) - set(train_indices)) #将剩余部分设为测试集
print('train_indices++++',train_indices)

# data[:]相当于重新拷贝一个列表，列表是可变对象如果直接引用传参给函数，则会导致修改其中任意一个变量，其余变量相应改变。但是，通过这种方式可以避免这种情况。
train_features = data[train_indices]
train_labels = labels[train_indices]

test_features = data[test_indices]
test_labels = labels[test_indices]
print('测试样本数量',len(test_labels)) # 测试样本数量 393

###定义Mish激活函数与多层全连接网络
# 定一个带有3层全连接网络的类，每个网络层使用Mish作为激活函数，该模型使用交叉熵损失函数
class Mish(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self,x):
        x = x * (torch.tanh(F.softplus(x)))
        return x

torch.manual_seed(0) # 设置随机种子函数

class ThreeLinearModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(12,12)
        self.mish1 = Mish()
        self.linear2 = nn.Linear(12,8)
        self.mish2 = Mish()
        self.linear3 = nn.Linear(8,2)
        self.softmax = nn.Softmax(dim = 1)
        self.criterion = nn.CrossEntropyLoss() #定义交叉熵

    def forward(self,x): # 定义一个全连接网络
        lin1_out = self.linear1(x)
        out_1 = self.mish1(lin1_out)
        out_2 = self.mish2(self.linear2(out_1))
        return self.softmax(self.linear3(out_2))

    def getloss(self,x,y): # 实现类的损失值计算接口
        y_pred = self.forward(x)
        loss = self.criterion(y_pred,y)
        return loss

### 训练模型并输出结果
if __name__ == '__main__':
    net = ThreeLinearModel()
    num_epochs = 200
    optimizer = torch.optim.Adam(net.parameters(),lr = 0.04)

    # 将输入的样本标签转化为标量
    input_tensor = torch.from_numpy(train_features).type(torch.FloatTensor)
    label_tensor = torch.from_numpy(train_labels)
    losses = [] # 定义损失值列表
    for epoch in range(num_epochs):
        loss = net.getloss(input_tensor, label_tensor)
        losses.append(loss.item())
        optimizer.zero_grad()  # 清空之前的梯度
        loss.backward()  # 反向传播损失值
        optimizer.step()  # 更新参数
        if epoch % 20 == 0:
            print('Epoch {}/{} => Loss: {:.2f}'.format(epoch + 1, num_epochs, loss.item()))

    os.makedirs('models', exist_ok=True)
    torch.save(net.state_dict(), 'models/titanic_model.pt')

    plot_losses(losses)

    # 输出训练结果
    # tensor.detach():从计算图中脱离出来，返回一个新的tensor，新的tensor和原tensor共享数据内存，（这也就意味着修改一个tensor的值，另外一个也会改变），
    #                  但是不涉及梯度计算。在从tensor转换成为numpy的时候，如果转换前面的tensor在计算图里面（requires_grad = True），那么这个时候只能先进行detach操作才能转换成为numpy
    out_probs = net(input_tensor).detach().numpy()
    out_classes = np.argmax(out_probs, axis=1)
    print("Train Accuracy:", sum(out_classes == train_labels) / len(train_labels))

    # 测试模型
    test_input_tensor = torch.from_numpy(test_features).type(torch.FloatTensor)
    out_probs = net(test_input_tensor).detach().numpy()
    out_classes = np.argmax(out_probs, axis=1)
    print("Test Accuracy:", sum(out_classes == test_labels) / len(test_labels))