|
|
import torch
|
|
|
import torch.nn as nn
|
|
|
import torch.optim as optim
|
|
|
import numpy as np
|
|
|
import pandas as pd
|
|
|
from sklearn.model_selection import StratifiedKFold
|
|
|
from torch.utils.data import DataLoader, Dataset
|
|
|
from torchsummary import summary
|
|
|
# from torchviz import make_dot # 需要apt安装graphviz工具，图不好看，先不用
|
|
|
import time
|
|
|
import random
|
|
|
|
|
|
|
|
|
# 定义 MLP 模型，每一层需要手写
|
|
|
class MLP(nn.Module):
|
|
|
def __init__(self, input_size, hidden_size, output_size):
|
|
|
super(MLP, self).__init__()
|
|
|
self.fc1 = nn.Linear(input_size, hidden_size)
|
|
|
self.relu = nn.ReLU()
|
|
|
self.fc2 = nn.Linear(hidden_size, output_size)
|
|
|
self.sigmoid = nn.Sigmoid()
|
|
|
|
|
|
def forward(self, x):
|
|
|
out = self.fc1(x)
|
|
|
out = self.relu(out)
|
|
|
out = self.fc2(out)
|
|
|
out = self.sigmoid(out)
|
|
|
return out
|
|
|
|
|
|
# 定义 MMLP 模型，隐藏层根据输入数组自动生成全连接，并在每一层后自动加入ReLU激活函数
|
|
|
class MMLP(nn.Module):
|
|
|
def __init__(self, input_size, hidden_sizes, output_size):
|
|
|
super(MMLP, self).__init__()
|
|
|
self.layers = nn.ModuleList()
|
|
|
for h in hidden_sizes:
|
|
|
self.layers.append(nn.Linear(input_size, h))
|
|
|
self.layers.append(nn.ReLU())
|
|
|
input_size = h
|
|
|
self.layers.append(nn.Linear(input_size, output_size))
|
|
|
# 最后一层加入激活函数后，会严重影响收敛情况，原因待分析,softmax不需要加，因为nn.CrossEntropyLoss()损失函数自带softmax运算，加了会连续两次指数运算，容易溢出；至于Sigmoid，原因是输入数据要做（0,1）的归一化
|
|
|
#self.layers.append(nn.Sigmoid())
|
|
|
#self.layers.append(nn.Softmax(dim=1))
|
|
|
#self.layers.append(nn.LogSoftmax(dim=1))
|
|
|
|
|
|
def forward(self, x):
|
|
|
for layer in self.layers:
|
|
|
x = layer(x)
|
|
|
return x
|
|
|
|
|
|
# 定义数据集
|
|
|
class TensorDataset(Dataset):
|
|
|
def __init__(self, features, labels):
|
|
|
self.features = features
|
|
|
self.labels = labels
|
|
|
|
|
|
def __len__(self):
|
|
|
return len(self.features)
|
|
|
|
|
|
def __getitem__(self, index):
|
|
|
return self.features[index], self.labels[index]
|
|
|
|
|
|
# 定义训练函数
|
|
|
def train_model(model, train_loader, criterion, optimizer, num_epochs):
|
|
|
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
|
|
|
model.to(device)
|
|
|
model.train()
|
|
|
|
|
|
for epoch in range(num_epochs):
|
|
|
start_time = time.time()
|
|
|
train_loss = 0.0
|
|
|
train_corrects = 0
|
|
|
|
|
|
for inputs, labels in train_loader:
|
|
|
inputs = inputs.to(device)
|
|
|
labels = labels.to(device)
|
|
|
|
|
|
# # 由于出现了奇怪的情况，用于验证我的数据到这里开始训练为止是否是正确的
|
|
|
# for i, input in enumerate(inputs):
|
|
|
# ii = -1
|
|
|
# for score in input:
|
|
|
# if score >=3.0:
|
|
|
# ii = 1
|
|
|
# break
|
|
|
# else:
|
|
|
# ii = 0
|
|
|
# assert(labels[i] == ii), f"{inputs} # {labels} # 第{i}个出现问题"
|
|
|
# ## 由于出现了奇怪的情况，用于验证我的数据到这里开始训练为止是否是正确的
|
|
|
|
|
|
optimizer.zero_grad()
|
|
|
outputs = model(inputs)
|
|
|
_, preds = torch.max(outputs, 1)
|
|
|
#print(outputs)
|
|
|
# print("$$$$$$$$$")
|
|
|
#print(preds)
|
|
|
#print(inputs)
|
|
|
#assert(torch.sum(preds)==0)
|
|
|
# print("####")
|
|
|
#print(labels)
|
|
|
# print("$$$$$$$$$")
|
|
|
#loss = criterion(outputs, labels.unsqueeze(1))
|
|
|
#loss = criterion(outputs, torch.tensor(labels, dtype=torch.long))
|
|
|
loss = criterion(outputs, labels.long())
|
|
|
#print(loss)
|
|
|
#print(inputs.size())
|
|
|
loss.backward()
|
|
|
optimizer.step()
|
|
|
|
|
|
train_loss += loss.item() * inputs.size(0)
|
|
|
train_corrects += torch.sum(preds == labels.data)
|
|
|
|
|
|
train_loss = train_loss / len(train_loader.dataset)
|
|
|
train_acc = train_corrects.double() / len(train_loader.dataset)
|
|
|
|
|
|
print('Epoch [{}/{}], Loss: {:.4f}, Acc: {:.4f}, took time: {:.2f}s'
|
|
|
.format(epoch+1, num_epochs, train_loss, train_acc, time.time() - start_time))
|
|
|
|
|
|
# 定义测试函数
|
|
|
def test(model, dataloader, criterion):
|
|
|
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
|
|
|
model.eval()
|
|
|
running_loss = 0.0
|
|
|
running_corrects = 0
|
|
|
|
|
|
# 测试的写法相比于训练，主要是model.eval()和torch.no_grad()，用于屏蔽测试阶段梯度计算
|
|
|
# torch.no_gard拥有上下文管理属性，该代码块中，所有操作不跟踪梯度，减少内存和时间，训练阶段需要梯度计算，故不能使用；model.eval可以禁用BatchNorm层和Dropout层使用，以免在推断时造成不一致的结果，也可以减少内存和时间，如果训练模式下使用eval，可能会影响训练的正确性（不仅仅是内存和时间）
|
|
|
with torch.no_grad():
|
|
|
for inputs, labels in dataloader:
|
|
|
inputs = inputs.to(device)
|
|
|
labels = labels.to(device)
|
|
|
|
|
|
outputs = model(inputs)
|
|
|
#loss = criterion(outputs, labels.unsqueeze(1))
|
|
|
loss = criterion(outputs, labels.long())
|
|
|
|
|
|
_, preds = torch.max(outputs, 1)
|
|
|
|
|
|
running_loss += loss.item() * inputs.size(0)
|
|
|
running_corrects += torch.sum(preds == labels.data)
|
|
|
|
|
|
test_loss = running_loss / len(dataloader.dataset)
|
|
|
test_acc = running_corrects.double() / len(dataloader.dataset)
|
|
|
|
|
|
print('Test Loss: {:.4f} Acc: {:.4f}'.format(test_loss, test_acc))
|
|
|
return test_loss, test_acc
|
|
|
|
|
|
# 加载数据
|
|
|
df = pd.read_excel("data/data_src.xlsx")
|
|
|
src_features = df.iloc[:, 34:44].values.astype(np.float32)
|
|
|
src_labels = np.array([1 if str=="是" else 0 for str in df.iloc[:, -1].values]).astype(np.float32)
|
|
|
print("数据样本总量：", src_features.shape[0])
|
|
|
print("数据特征维度：", src_features.shape[1])
|
|
|
print("数据类别数量：", len(set(src_labels)))
|
|
|
|
|
|
# 定义交叉验证折数
|
|
|
n_splits = 5
|
|
|
skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random.randint(0, 1000))
|
|
|
|
|
|
# 定义模型参数
|
|
|
input_size = src_features.shape[1]
|
|
|
hidden_sizes = [32,128,32]
|
|
|
output_size = len(set(src_labels)) # CrossEntropyLoss()损失函数类别数量就是输出size，sigmoid损失只适用于二分类，size为1，这里统一使用Cross
|
|
|
lr = 0.001 # learn rate 学习率
|
|
|
num_epochs = 100
|
|
|
batch_size = 128
|
|
|
|
|
|
# 定义全局结果变量
|
|
|
fold_accuracy=[]
|
|
|
fold_loss=[]
|
|
|
model_name=0
|
|
|
|
|
|
# 遍历每个 fold
|
|
|
for fold, (train_idx, test_idx) in enumerate(skf.split(src_features, src_labels)):
|
|
|
print(f"Fold [{fold+1}/{skf.n_splits}]")
|
|
|
print("train_idx:", train_idx)
|
|
|
print("test_idx:", test_idx)
|
|
|
|
|
|
# 数据切片
|
|
|
train_features = src_features[train_idx]
|
|
|
train_labels = src_labels[train_idx]
|
|
|
test_features = src_features[test_idx]
|
|
|
test_labels = src_labels[test_idx]
|
|
|
|
|
|
# 将numpy数组转为PyTorch张量，这里统一使用float型，如果是Cross损失函数，这里的labels可以直接使用long整型，省去后面再转
|
|
|
train_features_tensor = torch.tensor(train_features, dtype=torch.float)
|
|
|
train_labels_tensor = torch.tensor(train_labels, dtype=torch.float)
|
|
|
test_features_tensor = torch.tensor(test_features, dtype=torch.float)
|
|
|
test_labels_tensor = torch.tensor(test_labels, dtype=torch.float)
|
|
|
|
|
|
# 构建数据集和数据加载器，batch_size大小前面定义好
|
|
|
train_dataset = TensorDataset(train_features_tensor, train_labels_tensor)
|
|
|
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
|
|
|
test_dataset = TensorDataset(test_features_tensor, test_labels_tensor)
|
|
|
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
|
|
|
|
|
|
print('--------------------------------')
|
|
|
|
|
|
# 初始化 MLP 模型
|
|
|
#model = MLP(input_size, 32, 2) # 手动写每一层，暂时不用
|
|
|
model = MMLP(input_size, hidden_sizes, output_size) # hidden_sizes是一个数组，多层
|
|
|
|
|
|
# 查看模型网络结构
|
|
|
# print(model)
|
|
|
summary(model.to(torch.device("cuda:0")), (input_size,))
|
|
|
|
|
|
# 定义损失函数和优化器，不能放在KFold之前定义，保证KFold验证的独立性
|
|
|
criterion = nn.CrossEntropyLoss()
|
|
|
#criterion = nn.BCELoss() # 使用sigmoid损失函数再使用
|
|
|
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
|
|
|
#optimizer = torch.optim.SGD(model.parameters(), lr=lr) # 这个优化器只有lr一个超参数，适用于小规模网络结构
|
|
|
|
|
|
# 训练 MLP 模型
|
|
|
train_model(model, train_loader, criterion, optimizer, num_epochs)
|
|
|
|
|
|
# 测试 MLP 模型
|
|
|
test_loss, test_acc = test(model, test_loader, criterion)
|
|
|
|
|
|
fold_accuracy.append(test_acc.item())
|
|
|
fold_loss.append(test_loss)
|
|
|
print(f'Accuracy for fold {fold}: {fold_accuracy[fold]*100} %, loss: {fold_loss[fold]}')
|
|
|
print('--------------------------------')
|
|
|
# Save trained model
|
|
|
torch.save(model.state_dict(), 'psychology_model_val_{}.pth'.format(str(model_name)))
|
|
|
model_name+=1
|
|
|
|
|
|
print('K-FOLD CROSS VALIDATION RESULTS')
|
|
|
print(f'Fold accuracies: {fold_accuracy}')
|
|
|
print(f'Mean accuracy: {np.mean(fold_accuracy)}')
|
|
|
print(f'Mean loss: {np.mean(fold_loss)}')
|
|
|
|