搭建全连接网络进行分类（糖尿病为例）

拿来练手，大神请绕道。

1.网上的代码大多都写在一个函数里，但是其实很多好论文都是把网络，数据训练等分开写的。

2.分开写就是有一个需要注意的事情，就是要import 要用到的文件中的模型或者变量等。

3.全连接的回归也写了，有空再上传吧。

4.一般都是先写data或者model

import torch
import torch.nn as nn
import torch.nn.functional as F
#nn.func这个里面很多功能其实nn里就有，可以不导入，而且后面新的版本的torch也取消了cc.functional里面的部分函数#定义网络，需要定义两部分，一部分就是初始化，另一部分就是数据流
class FCNet(nn.Module):def __init__(self):super(FCNet,self).__init__()self.fc1 = nn.Linear(8,16）#初始的这个8，要和你的数据的特征数一样才行，后面的数可以随意设置，但是不要太多，容易过拟合# self.fc2 = nn.Linear(50,20)self.fc3 = nn.Linear(16,2)#二分类，输出2，其实1也可以的#最后的就是分类数，因为用的sigmod和交叉熵损失，就不用额外加softmax了，多分类要用softmaxself.sig = nn.Sigmoid()# self.drop = nn.Dropout(0.3)#可以把用到的放在这里，也可以用nn.Sequential()放在一起，这样后面的话就可以直接用这个，不用写那么多了def forward(self,x):x = self.sig(self.fc1(x))# x = self.sig(self.fc2(x))x = self.sig(self.fc3(x))return x#就是x要怎么在网络中走，要写一遍#可以自己输出测试一下看看网络是不是自己想的那样，在真的调用的时候再屏蔽掉
# net= FCNet()
# print(net)

首先看看数据是是啥样，outcome就是有没有糖尿病

其实可以手动把csv分成train和test

import pandas as pd
from sklearn.model_selection import train_test_split
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import numpy as np
#导入pands是为了读数据，当然使用numpy也可以读得，sklearn是为了把训练数据分为训练和验证集data = pd.read_csv('./train.csv')
#就是把对应的数据哪出来，x代表的是feature上的data，y代表的是label，因为pd可以读到最上面的标签，所以从第2行（i=1）开始读就行
x = data.iloc[1:,:-1]
y = data.iloc[1:,[-1]]
#可以输出看看数据对不对，x中不应该包含labels
# print(x)
# print(y)
#test_size就是划分的比例，后面的是种子，意思是每次运行这个函数时候，0.8就是那些，0.2也还是每次一样，如果想要不一样，只要每次运行这个函数时候换个值就行
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2,random_state=0)
#print(x_train,y_test)
# print(x_test,y_test)
#给数据进行归一化，可以用很多方法，我用最简单的归一到-1到1
x_train = x_train.apply(lambda x: (x - x.mean()) / (x.std()))
x_test = x_test.apply(lambda x: (x - x.mean()) / (x.std()))#写dataset可以用两种方法，第一种就是 每一个数据自己单独处理，第二个就是要自己重写dataset类
#1.
# 可以使用分别的处理，把数据(首先转换为tensor，或者把dataframe.valus拿出来才能转换为tensor)转换为tensor并且数据类型转换为float32,如果测试没有真值，需要单独转换
# x_train = torch.tensor(np.array(x_train),dtype=torch.float32)
# y_train = torch.tensor(np.array(y_train),dtype=torch.float32)
# x_test = torch.tensor(np.array(x_test),dtype=torch.float32)
# y_test = torch.tensor(np.array(x_test),dtype=torch.float32)
# train_dataset = torch.utils.data.TensorDataset(x_train,y_train)
# test_dataset = torch.utils.data.TensorDataset(x_test,y_test)#2.也可以直接重写datasetclass dataset(Dataset):def __init__(self, x, y):#把值拿出来或者变为np类型才能转换为tensor# self.data = torch.tensor(x.values,dtype=torch.float32)# self.labels = torch.tensor(y.values,dtype=torch.float32)self.data = torch.tensor(np.array(x),dtype=torch.float32)self.labels = torch.tensor(np.array(y),dtype=torch.float32)def __len__(self):return len(self.data)def __getitem__(self,idx):return self.data[idx],self.labels[idx]#应该返回的是list类型，不是字典也不是setBATCH_SIZE = 64#验证集一般不用shuffle
train_dataset = dataset(x_train,y_train)
test_dataset = dataset(x_test,y_test)
# print(train_dataset)
train_loader = DataLoader(train_dataset,batch_size=BATCH_SIZE,shuffle=True)
test_lodaer = DataLoader(test_dataset,batch_size=BATCH_SIZE,shuffle=False)
# print(train_loader)

然后就可以写train或者test了，其实test和train一样

from Model import FCNet
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
import data
#导入要调用的net和data，也可以from data import xxx 这样可以直接用xxx，现在的这个需要用data.xxx#看自己的设备，最好用gpu来跑
if (torch.cuda.is_available()):my_device = torch.device('cuda')
else:my_device = torch.device('cpu')print(my_device)
#实例化一个net，并且放到gpu上，需要放到gpu上的有inputs，labels，net，loss
net = FCNet().to(my_device)
# print(net)
#定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
#一开始是不需要weight_decay（也就是l2正则化）,可以等出现过拟合在用，也可以先用上
optimizer = optim.Adam(net.parameters(),lr=0.001,weight_decay=0.01)epochs = 600
#定义train，因为一边训练一边验证，所有就把两个loader都放进去了，不过写法很多，也可以不放dataloader，放epoches也可以
def train(dataloader,valloader):losses = []acces = []losses_val = []for epoch in range(epochs):loss_batch = 0for i,data in enumerate(dataloader):#需要注意的，这里的inputs和labels和之前定义的dataset相关，需要是list类型才可以inputs,labels = data#print(data)可以打印出来查看一下inputs,labels = inputs.to(my_device),labels.to(my_device)optimizer.zero_grad()#每次要梯度清零outputs = net(inputs)#print(outputs)#model的最后一层是sigmod#labels的格式需要注意，因为现在是[[1],[0],[1],[1]..]这样得格式，无法放到交叉熵了，需要时[0,1,1,1...]这样得格式才行loss = criterion(outputs,labels.squeeze(1).long()).to(my_device)#print(labels.squeeze(1).long())loss.backward()optimizer.step()loss_batch += loss.item()length = i#验证的时候不用反向传播和梯度下降这些net.eval()count = 0right = 0loss_batch_val =0with torch.no_grad():for j,data2 in enumerate(valloader):val_inputs,val_labels = data2val_inputs,val_labels = val_inputs.to(my_device),val_labels.squeeze(1).long().to(my_device)val_outputs = net(val_inputs)loss_val = criterion(val_outputs,val_labels)#因为net的最后一层是2，所以输出的是2维的【0.6，0.4】这种，但是这个可以直接放到交叉熵中#——中放的是概率，pred中放的是预测的类别，算损失还是要用outputs，但是算准确率就是用pred和真实labels相比了_,pred = torch.max(val_outputs,1)#print(pred)right = (pred == val_labels).sum().item()count = len(val_labels)acc = right/countloss_batch_val += loss_val.item()length2 = jif epoch % 10 == 9:print('train_epoch:',epoch+1,'train_loss:',loss_batch/length,'val_loss:',loss_batch_val/length2,'acc:',acc)losses.append(loss_batch/length)acces.append(acc)losses_val.append(loss_batch_val/length2)#可以画一些曲线，输出一些值plt.plot(range(60),losses,color ='blue',label ='train_loss')plt.plot(range(60),acces, color ='red',label ='val_acc')plt.plot(range(60),losses_val,color ='yellow',label ='val_loss')plt.legend()plt.show()torch.save(net.state_dict(),'./weights_epoch1000.pth')#保存参数train(data.train_loader,data.test_lodaer)

最后看一下结果，最后的准确率在85%左右，还可以，毕竟数据不多，也是简单的全连接。

在这个结果之前出现了很多问题，比如波动很大，损失先降后升等问题，找个有问题的图

下面是一些总结：

1.跳跃很大，波动：增大batch_size，减小lr。

2.降低过拟合：

        a.降低模型的复杂程度，但是修改具体的神经元个数，因为这个网络本身就不大，所有没啥用，模型非常大没准会有用。

        b.batchsize增大，lr减小是有效的。

        c.输入数据进行归一化是有用的，归一化之后lr可以调大一点，收敛变快了。

        d.L2正则化是有用的，很有用。dropout应该也有用，但是模型本来就很小，我试了试没啥差别。而且有正则化之后可以加速收敛，lr可以稍微调大一点，较少的epoches也可以收敛了，而已acc也会更高一点，稳定一点。