Pytorch卷积神经网络resent网络实践

 更新时间:2022年05月12日 14:01:56   作者:浅念念52  
这篇文章主要为大家介绍了Pytorch卷积神经网络resent网络实践,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

前言

上篇文章,讲了经典卷积神经网络-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模型。调用训练好的模型,对图片,视频,摄像头进行检测。

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

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

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

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

以上就是Pytorch卷积神经网络resent网络实践的详细内容,更多关于卷积神经网络resent的资料请关注脚本之家其它相关文章!

相关文章

  • python判断列表为空的三种方法总结

    python判断列表为空的三种方法总结

    这篇文章主要介绍了python判断列表为空的三种方法总结,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2023-02-02
  • Django配合python进行requests请求的问题及解决方法

    Django配合python进行requests请求的问题及解决方法

    Python作为目前比较流行的编程语言,他内置的Django框架就是一个很好的网络框架,可以被用来搭建后端,和前端进行交互,那么我们现在来学习一下,如何用Python本地进行requests请求,并通过请求让Django帮我们解决一些问题
    2022-06-06
  • Python实现手绘图效果实例分享

    Python实现手绘图效果实例分享

    在本篇文章里小编给大家整理了关于Python实现手绘图效果,有需要的朋友们可以学习下。
    2020-07-07
  • Python中的Networkx的基本使用

    Python中的Networkx的基本使用

    Networkx是一个Python的包,可以用来创建和处理复杂的图网络结构,这篇文章主要介绍了Python中的Networkx详解,需要的朋友可以参考下
    2023-02-02
  • Python 根据相邻关系还原数组的两种方式(单向构造和双向构造)

    Python 根据相邻关系还原数组的两种方式(单向构造和双向构造)

    本文主要介绍了Python 根据相邻关系还原数组的两种方式,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2021-07-07
  • python环形单链表的约瑟夫问题详解

    python环形单链表的约瑟夫问题详解

    这篇文章主要为大家详细介绍了python环形单链表的约瑟夫问题,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2018-09-09
  • Django中Middleware中的函数详解

    Django中Middleware中的函数详解

    这篇文章主要介绍了Django中Middleware中的函数详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-07-07
  • Python教程之生产者消费者模式解析

    Python教程之生产者消费者模式解析

    在并发编程中使用生产者和消费者模式能够解决大不多的并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度
    2021-09-09
  • python每天定时运行某程序代码

    python每天定时运行某程序代码

    这篇文章主要介绍了python每天定时运行某程序代码,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
    2019-08-08
  • 基于python log取对数详解

    基于python log取对数详解

    今天小编就为大家分享一篇基于python log取对数详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2018-06-06

最新评论