多分类任务中不同隐藏层层数对实验结果的影响

多分类任务中不同隐藏层层数对实验结果的影响

一导入实验所需要的包

进口火炬

将火炬网导入为神经网络

将numpy作为铭牌导入

导入火炬视觉

导入torchvision.transforms作为转换

将matplotlib.pyplot导入为plt

来自火炬。utils。数据导入数据加载器

2下载MNIST数据集和读取数据

train _ dataset=火炬视觉。数据集。mnist(root='./数据集/MNIST '，训练=真，变换=变换。传感器(),下载=真)

test _ dataset=火炬视觉。数据集。mnist(root='./数据集/MNIST '，训练=假，变换=变换。传感器(),下载=真)

train _ x=train _ dataset。数据。cuda().float()/255

train _ y=train _ dataset。目标。cuda().长()

test_x=test_dataset.data.cuda().float()/255

test _ y=test _数据集。目标。cuda().长()

train _ dataset=TensorDataset(train _ x，train_y)

test _ dataset=TensorDataset(test _ x，test_y)

批处理大小=32

train _ ITER=DataLoader(train _ dataset，batch_size=32，shuffle=True)

test _ ITER=DataLoader(test _ dataset，batch_size=32，shuffle=False)

next(iter(train_iter))[0].形状

next(iter(test_iter))[0].形状

3定义模型参数

#训练次数和学习率

num _ epochs，lr=50，0.01

num_inputs，num_outputs=28*28，10

四定义模型

第一种：定义一个有三层的前馈神经网络

类线性网络1(nn .模块):

def __init__(self，num_inputs=784，num_outputs=10，num_hiddens=100):

super(LinearNet_1，self).__init__()

自线性化1=nn线性（数字输入，数字输出)

self.relu=nn .ReLU()

自线性化2=nn线性（数字输出)

向前延迟（自我，x):

x=自线性化1(x)

x=self.relu(x)

x=自线形2(x)

y=self.relu(x)

返回y

第二种：定义一个有四层的前馈神经网络

类线性网络2(nn .模块):

def __init__(self，num_inputs=784，num_outputs=10，num_hiddens1=100，num_hiddens2=100):

super(LinearNet_2，self).__init__()

自线性化1=nn线性(num_inputs，num_hiddens1)

self.relu=nn .ReLU()

自线性化2=nn线性(num_hiddens1，num_hiddens2)

非线性3=nn线性(num_hiddens2，num_outputs)

向前延迟（自我，x):

x=自线性化1(x)

x=self.relu(x)

x=自线形2(x)

x=self.relu(x)

x=自线形3(x)

y=self.relu(x)

返回y

第三种：定义一个有五层的前馈神经网络

类线性网络3(nn .模块):

def __init__(self，num_inputs=784，num_outputs=10，num_hiddens1=100，num_hiddens2=100，num_hiddens3=100):

super(LinearNet_3，self).__init__()

自线性化1=nn线性(num_inputs，num_hiddens1)

self.relu=nn .ReLU()

自线性化2=nn线性(num_hiddens1，num_hiddens2)

非线性3=nn线性(num_hiddens2，num_hiddens3)

非线性4=nn线性(num_hiddens3，num_outputs)

向前延迟（自我，x):

x=自线性化1(x)

x=self.relu(x)

x=自线形2(x)

x=self.relu(x)

x=自线形3(x)

x=self.relu(x)

x=自线形4(x)

y=self.relu(x)

返回y

5定义训练模型

def train(net，train_iter，test_iter，loss，num _ epochs，batch_size，params=None，lr=None，optimizer=None):

train_ls，test_ls=[]，[]

对于范围内的纪元(num _ epoch):

ls，计数=0,0

对于train_iter:中的x，y

X=X。重塑(-1，num_inputs) #[32，28，28] - [32，784]

l=损失（净额(X，y)

optimizer.zero_grad()

l.backward()

optimizer.step()

ls=l.item()*y.shape[0]

train_ls.append(ls)

ls，计数=0,0

对于test_iter:中的x，y

X=X。整形(-1，输入数)

l=损失（净额(X，y)

ls=l.item()*y.shape[0]

test_ls.append

如果(纪元1)%5==0:

打印(“epoch: %d，train loss: %f，test loss :% f”%(epoch 1，train_ls[-1]，test_ls[-1])

回程列车，测试

6 模型训练

total_net=[LinearNet_1，LinearNet_2，LinearNet_3]

Train_loss，Test_loss=[]，[]

#定义损失函数

损失=nn .CrossEntropyLoss()

对于cur_net in total_net:

net=cur_net()

net.parameters()中的参数为：

nn.init.normal_(参数，平均值=0,标准=0.01)

优化器=火炬。optim。SGD(净额。参数()，lr=0.001)

train_ls，test_ls=train(net，train_iter，test_iter，loss，num_epochs，batch_size，net.cuda().参数，lr，优化器)

Train_loss.append(train_ls)

Test_loss.append(test_ls)

七绘制不同隐藏层数损失图

x=np.linspace(0，len(train_ls)，len(train_ls))

PLT。图大小=(10，8))

对于(0,3):范围内的我

PLT。PLT(x，Train_loss[i]，标签=f '带{ I }隐藏层： '，线宽=1.5)

plt.xlabel('epoch ')

plt.ylabel("损失")

plt.legend()

plt.title("列车损失")

plt.show()

因上求缘，果上努力~~~~ 作者：希望每天涨粉，转载请注明原文链接：https://www .cn博客。com/BlairgString/p/15511072。超文本标记语言