前言
上篇文章，讲了经典卷积神经网络-resnet，这篇文章通过resnet网络，做一些具体的事情。
一、技术介绍
总的来说，第一步首先要加载数据集，对数据进行一些处理，第二步，调整学习率一些参数，训练好resnet网络模型，第三步输入图片或者视频通过训练好的模型，得到结果。
二、实现途径
1.加载数据集，对数据进行处理，加载的图片是（N,C,H,W ）对图片进行处理成（C,H,W），通过图片名称获取标签，进行分类。
train_paper=r'E:\桌面\资料\cv3\数据集\罚拳_公开\train\paper'
train_rock=r'E:\桌面\资料\cv3\数据集\罚拳_公开\train\rock'
train_scissors=r'E:\桌面\资料\cv3\数据集\罚拳_公开\train\scissors'
test_paper=r'E:\桌面\资料\cv3\数据集\罚拳_公开\test\paper'
test_rock=r'E:\桌面\资料\cv3\数据集\罚拳_公开\test\rock'
test_scission=r'E:\桌面\资料\cv3\数据集\罚拳_公开\test\scissors'
Batch_files=10
transs=trans.Compose([
trans.ToTensor(),
trans.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
])
def read_img(batch_files):
images=[]
labels=[]
for file in batch_files:
image=Image.open(file)
image=image.convert('RGB')
image=image.resize((64,64))
tensor=transs(image)
images.append(tensor)
if 'rock' in file :
labels.append(torch.tensor(0,dtype=torch.int64))
if 'paper' in file:
labels.append(torch.tensor(1,dtype=torch.int64))
if 'scissors' in file:
labels.append(torch.tensor(2,dtype=torch.int64))
return images,labels
if __name__ == '__main__':
2.写入resnet模型：
这里用的是resnet18
class tiao(nn.Module):
def __init__(self,shuru,shuchu):
super(tiao, self).__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()
def forward(self,x):
x1=self.conv1(x)
x2=self.bath(x1)
x3=self.relu(x2)
x4=self.conv1(x3)
x5=self.bath(x4)
x6=self.relu(x5)
x7=x6+x
return x7
class tiao2(nn.Module):
def __init__(self,shuru):
super(tiao2, self).__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(r'E:\桌面\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模型。调用训练好的模型，对图片c;视频，摄像头进行检测。
本文只是简单对图片进行检测，得到预测结果。
在这里运用了resnet18模型进行训练，其实还有更好的模型，得到更好的训练结果。
在目标检测领域，最著名的是YOLO，检测速度非常快，在实时检测领域很受欢迎，在一些游戏上，可以通过YOLO脚本，实现自动锁定，追踪之类的，比如现在欢迎的吃鸡游戏，玩家通过脚本，实现自动识别人，进行射击操作。在yolov3中，作者提到过yolo已经运用到军事中，出于道德层面的考虑，作者暂停了yolo的更新，在这之后v4，v5，v6以及之后的版本都是一些大佬接棒的。
在实时检测中，现在AI在一些方面已经超越人类了，在准确率上虽然人脑的高层次演绎归纳能力是远胜于AI的，但是在低级信息处理速度和精确度上，人类就很难比得过专精某个功能的AI了。
以上就是Pytorch卷积神经网络resent网络实践的详细内容，更多关于卷积神经网络resent的资料请关注其它相关文章！
