pytorch实现cnn卷积,pytorch卷积层

　　这篇文章主要为大家介绍了框架卷积神经网络厌恶网络实践，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

目录

前言

　　上篇文章，讲了经典卷积神经网络-雷斯内特，这篇文章通过残差网络网络，做一些具体的事情。

一、技术介绍

　　总的来说，第一步首先要加载数据集，对数据进行一些处理，第二步，调整学习率一些参数，训练好残差网络网络模型，第三步输入图片或者视频通过训练好的模型，得到结果。

二、实现途径

　　1.加载数据集，对数据进行处理，加载的图片是(氮、碳、氢、钨)对图片进行处理成(C，H，W)，通过图片名称获取标签，进行分类。

　　train_paper=rE:\桌面\资料\cv3\数据集\罚拳_公开\火车\纸

　　train_rock=rE:\桌面\资料\cv3\数据集\罚拳_公开\火车\摇滚

　　train_scissors=rE:\桌面\资料\cv3\数据集\罚拳_公开"火车\剪刀"

　　test_paper=rE:\桌面\资料\cv3\数据集\罚拳_公开\测试\试卷

　　test_rock=rE:\桌面\资料\cv3\数据集\罚拳_公开\测试\摇滚

　　test _ scission=r E: \桌面\资料\cv3\数据集\罚拳_公开\测试\剪刀

　　批处理文件=10

　　交易=运输。撰写([

　　反式ToTensor()，

　　反式。归一化((0.5,0.5,0.5),(0.5,0.5,0.5))

　　])

　　def read_img(批处理文件):

　　图像=[]

　　标签=[]

　　对于批处理文件：中的文件

　　image=Image.open(文件)

　　image=image.convert(RGB )

　　image=image.resize((64，64))

　　张量=运输(图像)

　　图像.附加(张量)

　　如果文件：中有"岩石"

　　labels.append(torch.tensor(0，dtype=torch.int64))

　　如果文件：中有"纸张"

　　labels.append(torch.tensor(1，dtype=torch.int64))

　　如果文件：中有"剪刀"

　　labels.append(torch.tensor(2，dtype=torch.int64))

　　返回图像、标签

　　if __name__==__main__:

　　2.写入残差网络模型：

　　这里用的是resnet18

　　类条(nn .模块):

　　def __init__(self，shuru，shuchu):

　　超（条，自)。__init__()

　　self.conv1=nn .Conv2d(in_channels=shuru，out_channels=shuchu，kernel_size=(3，3)，padding=(1，1))

　　self.bath=nn .BatchNorm2d(shuchu)

　　self.relu=nn .ReLU()

　　定义向前（自身，x):

　　x1=self.conv1(x)

　　x2=自助浴室(x1)

　　x3=self.relu(x2)

　　x4=self.conv1(x3)

　　x5=自助浴室(x4)

　　x6=self.relu(x5)

　　x7=x6 x

　　返回x7

　　调2类(nn .模块):

　　def __init__(self，shuru):

　　超级（条2，s

　　elf).__init__()

　　 self.conv1=nn.Conv2d(in_channels=shuru,out_channels=shuru*2,kernel_size=(3,3),stride=(2,2),padding=(1,1))

　　 self.conv11=nn.Conv2d(in_channels=shuru,out_channels=shuru*2,kernel_size=(1,1),stride=(2,2))

　　 self.batch=nn.BatchNorm2d(shuru*2)

　　 self.relu=nn.ReLU()

　　 self.conv2=nn.Conv2d(in_channels=shuru*2,out_channels=shuru*2,kernel_size=(3,3),stride=(1,1),padding=(1,1))

　　 def forward(self,x):

　　 x1=self.conv1(x)

　　 x2=self.batch(x1)

　　 x3=self.relu(x2)

　　 x4=self.conv2(x3)

　　 x5=self.batch(x4)

　　 x6=self.relu(x5)

　　 x11=self.conv11(x)

　　 x7=x11+x6

　　 return x7

　　class resnet18(nn.Module):

　　 def __init__(self):

　　 super(resnet18, self).__init__()

　　 self.conv1=nn.Conv2d(in_channels=3,out_channels=64,kernel_size=(7,7),stride=(2,2),padding=(3,3))

　　 self.bath=nn.BatchNorm2d(64)

　　 self.relu=nn.ReLU()

　　 self.max=nn.MaxPool2d(2,2)

　　 self.tiao1=tiao(64,64)

　　 self.tiao2=tiao(64,64)

　　 self.tiao3=tiao2(64)

　　 self.tiao4=tiao(128,128)

　　 self.tiao5=tiao2(128)

　　 self.tiao6=tiao(256,256)

　　 self.tiao7=tiao2(256)

　　 self.tiao8=tiao(512,512)

　　 self.a=nn.AdaptiveAvgPool2d(output_size=(1,1))

　　 self.l=nn.Linear(512,3)

　　 def forward(self,x):

　　 x1=self.conv1(x)

　　 x2=self.bath(x1)

　　 x3=self.relu(x2)

　　 x4=self.tiao1(x3)

　　 x5=self.tiao2(x4)

　　 x6=self.tiao3(x5)

　　 x7=self.tiao4(x6)

　　 x8=self.tiao5(x7)

　　 x9=self.tiao6(x8)

　　 x10=self.tiao7(x9)

　　 x11=self.tiao8(x10)

　　 x12=self.a(x11)

　　 x13=x12.view(x12.size()[0],-1)

　　 x14=self.l(x13)

　　 return x14

　　第三步：调用读取数据函数，读取数据，打乱，开始训练：

 train_rock=[os.path.join(train_rock,file) for file in os.listdir(train_rock)]
　　 train_paper= [os.path.join(train_paper, file) for file in os.listdir(train_paper)]
　　 train_scissors = [os.path.join(train_scissors, file) for file in os.listdir(train_scissors)]
　　 test_rock=[os.path.join(test_rock,file) for file in os.listdir(test_rock)]
　　 test_paper=[os.path.join(test_paper,file) for file in os.listdir(test_paper)]
　　 test_scission=[os.path.join(test_scission,file) for file in os.listdir(test_scission)]
　　 train=train_rock+train_paper+train_scissors
　　 test=test_rock+test_paper+test_scission
　　 random.shuffle(train)
　　 random.shuffle(test)
　　 model=resnet18().cuda()
　　 opt = torch.optim.ASGD(model.parameters(), lr=0.001, weight_decay=0.8)
　　 loss = nn.CrossEntropyLoss()
　　 print("开始训练")
　　

　　第四步：训练模型，完成后保存模型：

 for i in range(5):
　　 running_loss=0
　　 for index in range(0,len(train),Batch_files):
　　 images,labels=read_img(train[index:index+Batch_files])
　　 inputs=torch.stack(images,0).cuda()
　　 labels=torch.stack(labels,0).cuda()
　　 inputs, labels = Variable(inputs), Variable(labels)
　　 opt.zero_grad()
　　 h=model(inputs)
　　 loss1=loss(h,labels)
　　 loss1.backward()
　　 opt.step()
　　 running_loss+=loss1.item()
　　 if index%41==40:
　　 avg_loos=running_loss/41
　　 running_loss=0
　　 print(avg_loss,avg_loos)
　　 if index%101==99:
　　 test_files=random.sample(test,100)
　　 test_image,test_label=read_img(test_files)
　　 test_images=torch.stack(test_image,0).cuda()
　　 test_labels=torch.stack(test_label,0).cuda()
　　 test_h=model(test_images)
　　 _,prediction=torch.max(test_h.data,1)
　　 total=test_labels.size(0)
　　 correct=(prediction==test_labels).sum()
　　 print(100张测试集准确率%d %%%(100*correct/total))
　　 torch.save(model.state_dict(),resnet_caiq猜拳.pth)
　　

　　第五步：加载模型，进行测试：

model.load_state_dict(torch.load(resnet_caiq猜拳.pth))
　　labels={0:rock,1:paper,2:scissors}
　　 images=[]
　　 image=Image.open(rE:\桌面\1.png)
　　 image=image.convert(RGB)
　　 image=image.resize((64,64))
　　 image=transs(image)
　　 images.append(image)
　　 image= torch.stack(images, 0).cuda()
　　 label=model(image)
　　 _,prediction=torch.max(label.data,1)
　　 print("预测类别",labels[prediction.item()])
　　

三、总结

　　本文只是简单介绍了，通过pytorch训练resnet模型。调用训练好的模型，对图片，视频，摄像头进行检测。

　　本文只是简单对图片进行检测，得到预测结果。

　　在这里运用了resnet18模型进行训练，其实还有更好的模型，得到更好的训练结果。

　　在目标检测领域，最著名的是YOLO，检测速度非常快，在实时检测领域很受欢迎，在一些游戏上，可以通过YOLO脚本，实现自动锁定，追踪之类的，比如现在欢迎的吃鸡游戏，玩家通过脚本，实现自动识别人，进行射击操作。在yolov3中，作者提到过yolo已经运用到军事中，出于道德层面的考虑，作者暂停了yolo的更新，在这之后v4，v5，v6以及之后的版本都是一些大佬接棒的。

　　在实时检测中，现在AI在一些方面已经超越人类了，在准确率上虽然人脑的高层次演绎归纳能力是远胜于AI的，但是在低级信息处理速度和精确度上，人类就很难比得过专精某个功能的AI了。

　　以上就是Pytorch卷积神经网络resent网络实践的详细内容，更多关于卷积神经网络resent的资料请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。