制作网站报价单,如何在阿里云上做网站,优秀网页设计作品案例欣赏,wordpress文章页的三大标签任务 3.3 课程实验要求 #xff08;1#xff09;手动实现前馈神经网络解决上述回归、二分类、多分类任务 l 从训练时间、预测精度、Loss变化等角度分析实验结果#xff08;最好使用图表展示#xff09; #xff08;2#xff09;利用torch.nn实现前馈神经网络解决上述回归…任务 3.3 课程实验要求 1手动实现前馈神经网络解决上述回归、二分类、多分类任务 l 从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示 2利用torch.nn实现前馈神经网络解决上述回归、二分类、多分类任务 l 从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示 3在多分类任务中使用至少三种不同的激活函数 l 使用不同的激活函数进行对比实验并分析实验结果 4对多分类任务中的模型评估隐藏层层数和隐藏单元个数对实验结果的影响 l 使用不同的隐藏层层数和隐藏单元个数进行对比实验并分析实验结果
一、手动生成实现前馈神经网络解决回归、二分类、多分类任务
1.1 任务内容
分析实验结果并绘制训练集和测试集的loss曲线
1.2 任务思路及代码
# 导入模块
import torch
import torch.nn as nn
import numpy as np
import torchvision
from torchvision import transforms
import time# 定义绘图函数
import matplotlib.pyplot as plt
def draw_loss(train_loss, test_loss):x np.linspace(0, len(train_loss), len(train_loss))plt.plot(x, train_loss, labelTrain Loss, linewidth1.5)plt.plot(x, test_loss, labelTest Loss, linewidth1.5)plt.xlabel(Epoch)plt.ylabel(Loss)plt.legend()plt.show()# 定义评价函数
def evaluate_accuracy(data_iter, model, loss_func):acc_sum, test_l_sum, n, c 0.0, 0.0, 0, 0for X, y in data_iter:result model.forward(X)acc_sum (result.argmax(dim1)y).float().sum().item()test_l_sum loss_func(result, y).item()n y.shape[0]c 1return acc_sum/n, test_l_sum/c# 回归任务
n_train 7000
n_test 3000
num_inputs 500
true_w, true_b torch.ones(num_inputs, 1)*0.0056, 0.028# 生成数据集
features torch.randn((n_train n_test, num_inputs))
labels torch.matmul(features, true_w) true_b
labels torch.tensor(np.random.normal(0, 0.01, sizelabels.size()), dtypetorch.float)
# 数据划分
train_features, test_features features[:n_train, :], features[n_train:, :]
train_labels, test_labels labels[:n_train], labels[n_train:]
batch_size1 128traindataset1 torch.utils.data.TensorDataset(train_features, train_labels)
testdataset1 torch.utils.data.TensorDataset(test_features, test_labels)traindataloader1 torch.utils.data.DataLoader(datasettraindataset1, batch_sizebatch_size1, shuffleTrue)
testdataloader1 torch.utils.data.DataLoader(datasettestdataset1, batch_sizebatch_size1, shuffleFalse)# 定义损失函数
def my_cross_entropy_loss(y_hat, labels):def log_softmax(y_hat):max_v torch.max(y_hat, dim1).values.unsqueeze(dim1)return y_hat - max_v - torch.log(torch.exp(y_hat-max_v).sum(dim1).unsqueeze(dim1))return (-log_softmax(y_hat))[range(len(y_hat)), labels].mean()# 定义优化算法
def SGD(params, lr):for param in params:param.data - lr*param.graddef mse(pred, true):ans torch.sum((true-pred)**2)/len(pred)return ansclass Net1():def __init__(self):# 设置隐藏层和输出层的节点数num_inputs, num_hiddens, num_outputs 500, 256, 1w_1 torch.tensor(np.random.normal(0,0.01,(num_hiddens,num_inputs)),dtypetorch.float32,requires_gradTrue)b_1 torch.zeros(num_hiddens, dtypetorch.float32,requires_gradTrue)w_2 torch.tensor(np.random.normal(0, 0.01,(num_outputs, num_hiddens)),dtypetorch.float32,requires_gradTrue)b_2 torch.zeros(num_outputs,dtypetorch.float32, requires_gradTrue)self.params [w_1, b_1, w_2, b_2]# 定义模型结构self.input_layer lambda x: x.view(x.shape[0],-1)self.hidden_layer lambda x: self.my_relu(torch.matmul(x,w_1.t())b_1)self.output_layer lambda x: torch.matmul(x,w_2.t()) b_2def my_relu(self, x):return torch.max(inputx,othertorch.tensor(0.0))def forward(self, x):flatten_input self.input_layer(x)hidden_output self.hidden_layer(flatten_input)final_output self.output_layer(hidden_output)return final_output# 训练
model1 Net1() # logistics模型
criterion my_cross_entropy_loss
lr 0.01 # 学习率
batchsize 128
epochs 40 #训练轮数
train_all_loss1 [] # 记录训练集上得loss变化
test_all_loss1 [] #记录测试集上的loss变化
begintime1 time.time()
for epoch in range(epochs):train_l 0for data, labels in traindataloader1:pred model1.forward(data)train_each_loss mse(pred.view(-1,1), labels.view(-1,1)) #计算每次的损失值train_each_loss.backward() # 反向传播SGD(model1.params, lr) # 使用小批量随机梯度下降迭代模型参数# 梯度清零train_l train_each_loss.item()for param in model1.params:param.grad.data.zero_()# print(train_each_loss)train_all_loss1.append(train_l) # 添加损失值到列表中with torch.no_grad():test_loss 0for data, labels in traindataloader1:pred model1.forward(data)test_each_loss mse(pred, labels)test_loss test_each_loss.item()test_all_loss1.append(test_loss)if epoch0 or (epoch1) % 4 0:print(epoch: %d | train loss:%.5f | test loss:%.5f%(epoch1,train_all_loss1[-1],test_all_loss1[-1]))endtime1 time.time()
print(手动实现前馈网络-回归实验 %d轮 总用时: %.3fs%(epochs,endtime1-begintime1))
# 二分类任务
data_num2, train_num2, test_num2 10000, 7000, 3000
# 第一个数据集 符合均值为 0.5 标准差为1 得分布
featuresA torch.normal(mean0.5, std1, size(data_num2, 200), dtypetorch.float32)
labelsA torch.ones(data_num2)
# 第二个数据集 符合均值为 -0.5 标准差为1的分布
featuresB torch.normal(mean-0.5, std1, size(data_num2, 200), dtypetorch.float32)
labelsB torch.zeros(data_num2)# 构建训练数据集
train_features2 torch.cat((featuresA[:train_num2], featuresB[:train_num2]), dim0)
train_labels2 torch.cat((labelsA[:train_num2], labelsB[:train_num2]), dim-1)
# 构建测试数据集
test_features2 torch.cat((featuresA[train_num2:], featuresB[train_num2:]), dim0)
test_labels2 torch.cat((labelsB[train_num2:], labelsB[train_num2:]), dim-1)
batch_size 128
# Build the training and testing dataset
traindataset2 torch.utils.data.TensorDataset(train_features2, train_labels2)
testdataset2 torch.utils.data.TensorDataset(test_features2, test_labels2)
traindataloader2 torch.utils.data.DataLoader(datasettraindataset2,batch_sizebatch_size,shuffleTrue)
testdataloader2 torch.utils.data.DataLoader(datasettestdataset2,batch_sizebatch_size,shuffleTrue)from torch.nn.functional import binary_cross_entropy
from torch.nn import CrossEntropyLoss
class Net2():def __init__(self):# 设置隐藏层和输出层的节点数num_inputs, num_hiddens, num_outputs 200, 256, 1w_1 torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_inputs)), dtypetorch.float32,requires_gradTrue)b_1 torch.zeros(num_hiddens, dtypetorch.float32, requires_gradTrue)w_2 torch.tensor(np.random.normal(0, 0.01, (num_outputs, num_hiddens)), dtypetorch.float32,requires_gradTrue)b_2 torch.zeros(num_outputs, dtypetorch.float32, requires_gradTrue)self.params [w_1, b_1, w_2, b_2]# 定义模型结构self.input_layer lambda x: x.view(x.shape[0], -1)self.hidden_layer lambda x: self.my_relu(torch.matmul(x, w_1.t()) b_1)self.output_layer lambda x: torch.matmul(x, w_2.t()) b_2self.fn_logistic self.logisticdef my_relu(self, x):return torch.max(inputx, othertorch.tensor(0.0))def logistic(self, x): # 定义logistic函数x 1.0 / (1.0 torch.exp(-x))return x# 定义前向传播def forward(self, x):x self.input_layer(x)x self.my_relu(self.hidden_layer(x))x self.fn_logistic(self.output_layer(x))return x# 训练
model2 Net2()
lr 0.005 # 学习率
epochs 40 # 训练轮数
train_all_loss2 [] # 记录训练集上得loss变化
test_all_loss2 [] # 记录测试集上的loss变化
train_Acc12, test_Acc12 [], []
begintime2 time.time()
for epoch in range(epochs):train_l, train_epoch_count 0, 0for data, labels in traindataloader2:pred model2.forward(data)train_each_loss binary_cross_entropy(pred.view(-1), labels.view(-1)) # 计算每次的损失值train_l train_each_loss.item()train_each_loss.backward() # 反向传播SGD(model2.params, lr) # 使用随机梯度下降迭代模型参数# 梯度清零for param in model2.params:param.grad.data.zero_()# print(train_each_loss)train_epoch_count (pred.argmax(dim1) labels).sum()train_Acc12.append((train_epoch_count/len(traindataset2)).item())train_all_loss2.append(train_l) # 添加损失值到列表中with torch.no_grad():test_l, test_epoch_count 0, 0for data, labels in testdataloader2:pred model2.forward(data)test_each_loss binary_cross_entropy(pred.view(-1), labels.view(-1))test_l test_each_loss.item()train_epoch_count (pred.argmax(dim1) labels).sum()test_Acc12.append((test_epoch_count/len(testdataset2)).item())test_all_loss2.append(test_l)if epoch 0 or (epoch 1) % 4 0:print(epoch: %d | train loss:%.5f | test loss:%.5f | train acc:%.5f | test acc:%.5f % (epoch 1, train_all_loss2[-1], test_all_loss2[-1], train_Acc12[-1], test_Acc12[-1]))
endtime2 time.time()
print(手动实现前馈网络-二分类实验 %d轮 总用时: %.3f % (epochs, endtime2 - begintime2))
# 多分类任务
mnist_train3 torchvision.datasets.FashionMNIST(root./FashionMNIST, trainTrue, downloadTrue, transformtransforms.ToTensor())
mnist_test3 torchvision.datasets.FashionMNIST(root./FashionMNIST, trainFalse, downloadTrue, transformtransforms.ToTensor())
batch_size 256
train_iter3 torch.utils.data.DataLoader(mnist_train3, batch_sizebatch_size, shuffleTrue, num_workers0)
test_iter3 torch.utils.data.DataLoader(mnist_test3, batch_sizebatch_size, shuffleFalse, num_workers0)traindataset3 torchvision.datasets.FashionMNIST(rootE:\\DataSet\\FashionMNIST\\Train,trainTrue,downloadTrue,transformtransforms.ToTensor())
testdataset3 torchvision.datasets.FashionMNIST(rootE:\\DataSet\\FashionMNIST\\Test,trainFalse,downloadTrue,transformtransforms.ToTensor())
traindataloader3 torch.utils.data.DataLoader(traindataset3, batch_sizebatch_size, shuffleTrue)
testdataloader3 torch.utils.data.DataLoader(testdataset3, batch_sizebatch_size, shuffleFalse)
# 定义自己的前馈神经网络
class MyNet3():def __init__(self):# 设置隐藏层和输出层的节点数num_inputs, num_hiddens, num_outputs 28 * 28, 256, 10 # 十分类问题w_1 torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_inputs)), dtypetorch.float32,requires_gradTrue)b_1 torch.zeros(num_hiddens, dtypetorch.float32, requires_gradTrue)w_2 torch.tensor(np.random.normal(0, 0.01, (num_outputs, num_hiddens)), dtypetorch.float32,requires_gradTrue)b_2 torch.zeros(num_outputs, dtypetorch.float32, requires_gradTrue)self.params [w_1, b_1, w_2, b_2]# 定义模型结构self.input_layer lambda x: x.view(x.shape[0], -1)self.hidden_layer lambda x: self.my_relu(torch.matmul(x, w_1.t()) b_1)self.output_layer lambda x: torch.matmul(x, w_2.t()) b_2def my_relu(self, x):return torch.max(inputx, othertorch.tensor(0.0))# 定义前向传播def forward(self, x):x self.input_layer(x)x self.hidden_layer(x)x self.output_layer(x)return xdef mySGD(params, lr, batchsize):for param in params:param.data - lr * param.grad / batchsize# 训练
model3 MyNet3() # logistics模型
criterion my_cross_entropy_loss # 损失函数
lr 0.15 # 学习率
epochs 40 # 训练轮数
train_all_loss3 [] # 记录训练集上得loss变化
test_all_loss3 [] # 记录测试集上的loss变化
train_ACC13, test_ACC13 [], [] # 记录正确的个数
begintime3 time.time()
for epoch in range(epochs):train_l,train_acc_num 0, 0for data, labels in traindataloader3:pred model3.forward(data)train_each_loss criterion(pred, labels) # 计算每次的损失值train_l train_each_loss.item()train_each_loss.backward() # 反向传播mySGD(model3.params, lr, 128) # 使用小批量随机梯度下降迭代模型参数# 梯度清零train_acc_num (pred.argmax(dim1)labels).sum().item()for param in model3.params:param.grad.data.zero_()# print(train_each_loss)train_all_loss3.append(train_l) # 添加损失值到列表中train_ACC13.append(train_acc_num / len(traindataset3)) # 添加准确率到列表中with torch.no_grad():test_l, test_acc_num 0, 0for data, labels in testdataloader3:pred model3.forward(data)test_each_loss criterion(pred, labels)test_l test_each_loss.item()test_acc_num (pred.argmax(dim1)labels).sum().item()test_all_loss3.append(test_l)test_ACC13.append(test_acc_num / len(testdataset3)) # # 添加准确率到列表中if epoch 0 or (epoch 1) % 4 0:print(epoch: %d | train loss:%.5f | test loss:%.5f | train acc: %.2f | test acc: %.2f% (epoch 1, train_l, test_l, train_ACC13[-1],test_ACC13[-1]))
endtime3 time.time()
print(手动实现前馈网络-多分类实验 %d轮 总用时: %.3f % (epochs, endtime3 - begintime3))# 结果分析
def picture(name, trainl, testl, typeLoss):plt.rcParams[font.sans-serif][SimHei] #设置字体plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题plt.title(name) # 命名plt.plot(trainl, cg, labelTrain type)plt.plot(testl, cr, labelTest type)plt.xlabel(Epoch)plt.ylabel(Loss)plt.legend()plt.grid(True)plt.figure(figsize(12,3))
plt.title(Loss)
plt.subplot(131)
picture(前馈网络-回归-损失曲线,train_all_loss1,test_all_loss1)
plt.subplot(132)
picture(前馈网络-二分类-损失曲线,train_all_loss2,test_all_loss2)
plt.subplot(133)
picture(前馈网络-多分类-损失曲线,train_all_loss3,test_all_loss3)
plt.show()# 绘制表格
plt.figure(figsize(8, 3))
plt.subplot(121)
picture(前馈网络-二分类-准确度,train_Acc12,test_Acc12,typeACC)
plt.subplot(122)
picture(前馈网络-多分类—准确度, train_ACC13,test_ACC13, typeACC)
plt.show()
二、利用torch.nn实现前馈神经网络解决回归、二分类、多分类任务
2.1 任务内容
从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示
2.2 任务思路及代码
from torch.nn import MSELoss
from torch.optim import SGD
device torch.device(cuda if torch.cuda.is_available() else cpu)
# 回归任务
class MyNet21(nn.Module):def __init__(self):super(MyNet21, self).__init__()# 设置隐藏层和输出层的节点数num_inputs, num_hiddens, num_outputs 500, 256, 1# 定义模型结构self.input_layer nn.Flatten()self.hidden_layer nn.Linear(num_inputs, num_hiddens)self.output_layer nn.Linear(num_hiddens, num_outputs)self.relu nn.ReLU()# 定义前向传播def forward(self, x):x self.input_layer(x)x self.relu(self.hidden_layer(x))x self.output_layer(x)return x# 训练
model21 MyNet21() # logistics模型
model21 model21.to(device)
print(model21)
criterion MSELoss() # 损失函数
criterion criterion.to(device)
optimizer SGD(model21.parameters(), lr0.1) # 优化函数
epochs 40 # 训练轮数
train_all_loss21 [] # 记录训练集上得loss变化
test_all_loss21 [] # 记录测试集上的loss变化
begintime21 time.time()
for epoch in range(epochs):train_l 0for data, labels in traindataloader1:data, labels data.to(devicedevice), labels.to(device)pred model21(data)train_each_loss criterion(pred.view(-1, 1), labels.view(-1, 1)) # 计算每次的损失值optimizer.zero_grad() # 梯度清零train_each_loss.backward() # 反向传播optimizer.step() # 梯度更新train_l train_each_loss.item()train_all_loss21.append(train_l) # 添加损失值到列表中with torch.no_grad():test_loss 0for data, labels in testdataloader1:data, labels data.to(device), labels.to(device)pred model21(data)test_each_loss criterion(pred,labels)test_loss test_each_loss.item()test_all_loss21.append(test_loss)if epoch 0 or (epoch 1) % 10 0:print(epoch: %d | train loss:%.5f | test loss:%.5f % (epoch 1, train_all_loss21[-1], test_all_loss21[-1]))
endtime21 time.time()
print(torch.nn实现前馈网络-回归实验 %d轮 总用时: %.3fs % (epochs, endtime21 - begintime21))class MyNet22(nn.Module):def __init__(self):super(MyNet22, self).__init__()# 设置隐藏层和输出层的节点数num_inputs, num_hiddens, num_outputs 200, 256, 1# 定义模型结构self.input_layer nn.Flatten()self.hidden_layer nn.Linear(num_inputs, num_hiddens)self.output_layer nn.Linear(num_hiddens, num_outputs)self.relu nn.ReLU()def logistic(self, x): # 定义logistic函数x 1.0 / (1.0 torch.exp(-x))return x# 定义前向传播def forward(self, x):x self.input_layer(x)x self.relu(self.hidden_layer(x))x self.logistic(self.output_layer(x))return x# 训练
model22 MyNet22() # logistics模型
model22 model22.to(device)
print(model22)
optimizer SGD(model22.parameters(), lr0.001) # 优化函数
epochs 40 # 训练轮数
train_all_loss22 [] # 记录训练集上得loss变化
test_all_loss22 [] # 记录测试集上的loss变化
train_ACC22, test_ACC22 [], []
begintime22 time.time()
for epoch in range(epochs):train_l, train_epoch_count, test_epoch_count 0, 0, 0 # 每一轮的训练损失值 训练集正确个数 测试集正确个数for data, labels in traindataloader2:data, labels data.to(device), labels.to(device)pred model22(data)train_each_loss binary_cross_entropy(pred.view(-1), labels.view(-1)) # 计算每次的损失值optimizer.zero_grad() # 梯度清零train_each_loss.backward() # 反向传播optimizer.step() # 梯度更新train_l train_each_loss.item()pred torch.tensor(np.where(pred.cpu()0.5, 1, 0)) # 大于 0.5时候预测标签为 1 否则为0each_count (pred.view(-1) labels.cpu()).sum() # 每一个batchsize的正确个数train_epoch_count each_count # 计算每个epoch上的正确个数train_ACC22.append(train_epoch_count / len(traindataset2))train_all_loss22.append(train_l) # 添加损失值到列表中with torch.no_grad():test_loss, each_count 0, 0for data, labels in testdataloader2:data, labels data.to(device), labels.to(device)pred model22(data)test_each_loss binary_cross_entropy(pred.view(-1),labels)test_loss test_each_loss.item()# .cpu 为转换到cpu上计算pred torch.tensor(np.where(pred.cpu() 0.5, 1, 0))each_count (pred.view(-1)labels.cpu().view(-1)).sum()test_epoch_count each_counttest_all_loss22.append(test_loss)test_ACC22.append(test_epoch_count / len(testdataset2))if epoch 0 or (epoch 1) % 4 0:print(epoch: %d | train loss:%.5f test loss:%.5f | train acc:%.5f | test acc:%.5f % (epoch 1, train_all_loss22[-1], test_all_loss22[-1], train_ACC22[-1], test_ACC22[-1]))endtime22 time.time()
print(torch.nn实现前馈网络-二分类实验 %d轮 总用时: %.3fs % (epochs, endtime22 - begintime22))from torch.nn import CrossEntropyLoss
# 定义自己的前馈神经网络
class MyNet23(nn.Module):def __init__(self,num_hiddenlayer1, num_inputs28*28,num_hiddens[256],num_outs10,actrelu):super(MyNet23, self).__init__()# 设置隐藏层和输出层的节点数self.num_inputs, self.num_hiddens, self.num_outputs num_inputs,num_hiddens,num_outs # 十分类问题# 定义模型结构self.input_layer nn.Flatten()# 若只有一层隐藏层if num_hiddenlayer 1:self.hidden_layers nn.Linear(self.num_inputs,self.num_hiddens[-1])else: # 若有多个隐藏层self.hidden_layers nn.Sequential()self.hidden_layers.add_module(hidden_layer1, nn.Linear(self.num_inputs,self.num_hiddens[0]))for i in range(0,num_hiddenlayer-1):name str(hidden_layerstr(i2))self.hidden_layers.add_module(name, nn.Linear(self.num_hiddens[i],self.num_hiddens[i1]))self.output_layer nn.Linear(self.num_hiddens[-1], self.num_outputs)# 指代需要使用什么样子的激活函数if act relu:self.act nn.ReLU()elif act sigmoid:self.act nn.Sigmoid()elif act tanh:self.act nn.Tanh()elif act elu:self.act nn.ELU()print(f本次使用的激活函数为 {act})def logistic(self, x): # 定义logistic函数x 1.0 / (1.0 torch.exp(-x))return x# 定义前向传播def forward(self, x):x self.input_layer(x)x self.act(self.hidden_layers(x))x self.output_layer(x)return x# 训练
# 使用默认的参数即 num_inputs28*28,num_hiddens256,num_outs10,actrelu
model23 MyNet23()
model23 model23.to(device)# 将训练过程定义为一个函数方便实验三和实验四调用
def train_and_test(modelmodel23):MyModel modelprint(MyModel)optimizer SGD(MyModel.parameters(), lr0.01) # 优化函数epochs 40 # 训练轮数criterion CrossEntropyLoss() # 损失函数train_all_loss23 [] # 记录训练集上得loss变化test_all_loss23 [] # 记录测试集上的loss变化train_ACC23, test_ACC23 [], []begintime23 time.time()for epoch in range(epochs):train_l, train_epoch_count, test_epoch_count 0, 0, 0for data, labels in traindataloader3:data, labels data.to(device), labels.to(device)pred MyModel(data)train_each_loss criterion(pred, labels.view(-1)) # 计算每次的损失值optimizer.zero_grad() # 梯度清零train_each_loss.backward() # 反向传播optimizer.step() # 梯度更新train_l train_each_loss.item()train_epoch_count (pred.argmax(dim1)labels).sum()train_ACC23.append(train_epoch_count.cpu()/len(traindataset3))train_all_loss23.append(train_l) # 添加损失值到列表中with torch.no_grad():test_loss, test_epoch_count 0, 0for data, labels in testdataloader3:data, labels data.to(device), labels.to(device)pred MyModel(data)test_each_loss criterion(pred,labels)test_loss test_each_loss.item()test_epoch_count (pred.argmax(dim1)labels).sum()test_all_loss23.append(test_loss)test_ACC23.append(test_epoch_count.cpu()/len(testdataset3))if epoch 0 or (epoch 1) % 4 0:print(epoch: %d | train loss:%.5f | test loss:%.5f | train acc:%5f test acc:%.5f: % (epoch 1, train_all_loss23[-1], test_all_loss23[-1],train_ACC23[-1],test_ACC23[-1]))endtime23 time.time()print(torch.nn实现前馈网络-多分类任务 %d轮 总用时: %.3fs % (epochs, endtime23 - begintime23))# 返回训练集和测试集上的 损失值 与 准确率return train_all_loss23,test_all_loss23,train_ACC23,test_ACC23train_all_loss23,test_all_loss23,train_ACC23,test_ACC23 train_and_test(modelmodel23)
三、在多分类任务中使用至少三种不同的激活函数
3.1 任务内容
使用不同的激活函数进行对比实验并分析实验结果
3.2 任务思路及代码
# 使用实验二中多分类的模型定义其激活函数为 Tanh
model31 MyNet23(1,28*28,[256],10,acttanh)
model31 model31.to(device)train_all_loss31,test_all_loss31,train_ACC31,test_ACC31 train_and_test(modelmodel31)# 使用实验二中多分类的模型定义其激活函数为 Sigmoid
model32 MyNet23(1,28*28,[256],10,actsigmoid)
model32 model32.to(device)train_all_loss32,test_all_loss32,train_ACC32,test_ACC32 train_and_test(modelmodel32)# 使用实验二中多分类的模型定义其激活函数为 ELU
model33 MyNet23(1,28*28,[256],10,actelu)
model33 model33.to(device) train_all_loss33,test_all_loss33,train_ACC33,test_ACC33 train_and_test(modelmodel33)def Plot3(datalist,title1,ylabelLoss,flagact):plt.rcParams[font.sans-serif][SimHei] #设置字体plt.rcParams[axes.unicode_minus]False #该语句解决图像中的“-”负号的乱码问题plt.title(title)plt.xlabel(Epoch)plt.ylabel(ylabel)plt.plot(datalist[0],labelTanh if flagact else [128])plt.plot(datalist[1],labelSigmoid if flagact else [512 256])plt.plot(datalist[2],labelELu if flagact else [512 256 128 64])plt.plot(datalist[3],labelRelu if flagact else [256])plt.legend()plt.grid(True)plt.figure(figsize(16,3))
plt.subplot(141)
Plot3([train_all_loss31,train_all_loss32,train_all_loss33,train_all_loss23],titleTrain_Loss)
plt.subplot(142)
Plot3([test_all_loss31,test_all_loss32,test_all_loss33,test_all_loss23],titleTest_Loss)
plt.subplot(143)
Plot3([train_ACC31,train_ACC32,train_ACC33,train_ACC23],titleTrain_ACC)
plt.subplot(144)
Plot3([test_ACC31,test_ACC32,test_ACC33,test_ACC23],titleTest_ACC)
plt.show()四、在多分类任务中使用至少三种不同的激活函数
4.1 任务内容
使用不同的隐藏层层数和隐藏单元个数进行对比实验并分析实验结果
# 使用实验二中多分类的模型 一个隐藏层神经元个数为[128]
model41 MyNet23(1,28*28,[128],10,actrelu)
model41 model41.to(device) train_all_loss41,test_all_loss41,train_ACC41,test_ACC41 train_and_test(modelmodel41)# 使用实验二中多分类的模型 两个隐藏层神经元个数为[512256]
model42 MyNet23(2,28*28,[512,256],10,actrelu)
model42 model42.to(device)train_all_loss42,test_all_loss42,train_ACC42,test_ACC42 train_and_test(modelmodel42)# 使用实验二中多分类的模型 四个隐藏层神经元个数为[51225612864]
model43 MyNet23(3,28*28,[512,256,128],10,actrelu)
model43 model43.to(device) train_all_loss43,test_all_loss43,train_ACC43,test_ACC43 train_and_test(modelmodel43)plt.figure(figsize(16,3))
plt.subplot(141)
Plot3([train_all_loss41,train_all_loss42,train_all_loss43,train_all_loss23],titleTrain_Loss,flaghidden)
plt.subplot(142)
Plot3([test_all_loss41,test_all_loss42,test_all_loss43,test_all_loss23],titleTest_Loss,flaghidden)
plt.subplot(143)
Plot3([train_ACC41,train_ACC42,train_ACC43,train_ACC23],titleTrain_ACC,flaghidden)
plt.subplot(144)
Plot3([test_ACC41,test_ACC42,test_ACC43,test_ACC23],titleTest_ACC, flaghidden)
plt.show()实验结果分析
从训练时间大致可以看出隐藏层数越多隐藏神经元个数越多训练成本越高所需要的时间越久。从准确率来看准确率越高可能会有相反的效果并不是隐藏层数越多隐藏神经元个数越多。更多的隐藏层和隐藏神经元个数可能会导致模型的过拟合现象导致在训练集上准确率很高但在测试集上准确率很低。
