深度学习实现猫狗分类

本文使用vgg网络实现对猫狗分类。 可以当做图像分类的一个baseline。

一、前期工作

数据:直接到kaggle上下载相应的数据集即可。

1.导入模块

# 数据
import torch
from torchvision.datasets import ImageFolder
import torch.utils.data as Data
from torchvision import transforms
# 模型
import torch.nn as nn
from torchvision.models import vgg16
# 损失函数
import torch.nn as nn
# 优化器
import torch.optim as optim
# 训练
import numpy as np
from torch.utils.tensorboard import SummaryWriter
import matplotlib.pyplot as plt
# 工具
from torchsummary import summary
import gc
# 预测
from PIL import Image
import cv2
import glob

2.设置硬件环境

如果有GPU则使用GPU并且清空当前GPU显存,否则使用CPU

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
if device == torch.device('cuda'):
    gc.collect()
    torch.cuda.empty_cache()

二、数据

数据部分主要是构造深度学习模型所需要的“特定数据”,为什么说特定呢?因为模型是很矫情的,一般来说模型对输入图像的尺寸、格式等都有要求,所以我们要按照要求来构造模型所需要的数据集。

# 数据预处理
transform = transforms.Compose([
    transforms.Resize([224,224]), # 将图像resize到指定大小
    transforms.ToTensor(), # 将图像转为tensor
    transforms.Normalize([0.4850.4560.406], [0.2290.2240.225]) # 对图像的进行标准化(使用ImageNet数据集的均值和标准差)
])
# train 数据集
trainset = ImageFolder(root='./1-cat-dog/train/',transform = transform) # 构造训练集的Dataset
train_loader = Data.DataLoader(trainset,batch_size = 16,shuffle = True,num_workers = 0# 构造数据集的DataLoader
# val 数据集
valset = ImageFolder(root = './1-cat-dog/val/',transform = transform) # 与训练集一样,构造验证集的Dataset
val_loader = Data.DataLoader(valset,batch_size =2,num_workers = 0# 构造验证集的DataLoader
# 查看类别与数字的对应关系
valset.class_to_idx
{'cat': 0, 'dog': 1}

三、模型

这一部分是模型部分,我们使用pytorch封装好的vgg16模型,并且对其进行微调,因为原始的vgg16模型是预测1000个类别,而我们的任务只有猫和狗两个类别,所以将最后一层的输出调整为2。在训练的时候使用前面预训练模型,这样子加快模型的收敛,而且效果奇佳。

model = vgg16(pretrained = True).to(device)
# 看一下原始模型
# 加载预训练模型,并且对模型进行微调
weights_path = './vgg16-397923af.pth'
model.load_state_dict(torch.load(weights_path,map_location=device))
for param in model.parameters():
    param.requires_grad = False
model.classifier._modules['6'] = nn.Linear(4096,2)
model.to(device)
VGG((features): Sequential((0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(1): ReLU(inplace=True)(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(3): ReLU(inplace=True)(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(6): ReLU(inplace=True)(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(8): ReLU(inplace=True)(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(inplace=True)(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(13): ReLU(inplace=True)(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(15): ReLU(inplace=True)(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(18): ReLU(inplace=True)(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(20): ReLU(inplace=True)(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(22): ReLU(inplace=True)(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(25): ReLU(inplace=True)(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(27): ReLU(inplace=True)(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(29): ReLU(inplace=True)(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))(avgpool): AdaptiveAvgPool2d(output_size=(7, 7))(classifier): Sequential((0): Linear(in_features=25088, out_features=4096, bias=True)(1): ReLU(inplace=True)(2): Dropout(p=0.5, inplace=False)(3): Linear(in_features=4096, out_features=4096, bias=True)(4): ReLU(inplace=True)(5): Dropout(p=0.5, inplace=False)(6): Linear(in_features=4096, out_features=2, bias=True))
)
class MY_VGG16(nn.Module):
    def __init__(self, init_weights=True):
        super(MY_VGG16, self).__init__()

        self.block1 = nn.Sequential(
            nn.Conv2d(364, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(6464, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(22), stride=(22)),
        )
        self.block2 = nn.Sequential(
            nn.Conv2d(64128, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(128128, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(22), stride=(22)),
        )
        self.block3 = nn.Sequential(
            nn.Conv2d(128256, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(256256, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(256256, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(22), stride=(22)),
        )

        self.block4 = nn.Sequential(
            nn.Conv2d(256512, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(512512, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(512512, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(22), stride=(22)),
        )

        self.block5 = nn.Sequential(
            nn.Conv2d(512512, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(512512, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.Conv2d(512512, kernel_size=(33), stride=(11), padding=(11)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(22), stride=(22)),
        )

        self.block6 = nn.Sequential(
            nn.Linear(in_features=512*7*7, out_features=4096),
            nn.ReLU(),
            nn.Linear(in_features=4096, out_features=4096),
            nn.ReLU(),
            nn.Linear(in_features=4096, out_features=2)
        )
        if init_weights:
            self._initialize_weights()

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 00.01)
                nn.init.constant_(m.bias, 0)

    def forward(self, x):

        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = torch.flatten(x, start_dim=1)
        x = self.block6(x)

        return x

model = MY_VGG16(init_weights=True).to(device)

四、损失函数和优化器

这一部分主要是定义损失函数和优化器

# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)

五、训练模型

有了数据、模型、损失函数和优化器之后,我们就可以开始训练模型了。 模型的训练其实就是经过一些列的迭代步骤,让模型学习从“输入”到“输出”的映射函数。

这里我们定义两个函数,train_one_epoch和valid_one_epoch:

  • train_one_epoch函数对训练集遍历一遍;
  • valid_one_epoch函数对验证集遍历一遍;
def train_one_epoch(train_loader, model, criterion, optimizer):
    model.train()
    running_loss = 0.0
    metric = 0.0
    total = 0.0

    for i, data in enumerate(train_loader):
        images, labels = data
        images = images.to(device)
        labels = labels.to(device)
        outs = model(images)

        optimizer.zero_grad()
        loss = criterion(outs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        _, preds = torch.max(outs, 1)
        metric += (preds == labels).sum().item()
        total += labels.shape[0]

    train_loss = running_loss/total
    train_accuracy = 100*metric/total # 转成百分比

    return train_loss, train_accuracy    
def valid_one_epoch(valid_loader, model):
    model.eval()

    total = 0.0
    metric = 0.0

    for i,data in enumerate(valid_loader):
        images, labels = data
        images = images.to(device)
        labels = labels.to(device)

        outs = model(images)
        _, preds = torch.max(outs,1)

        total += labels.shape[0]

        metric += (preds == labels).sum().item()

    valid_accuracy = 100*metric/total 

    return valid_accuracy

然后我们就可以开始训练模型了,并且在模型训练完之后保存最终的模型。

epochs = 20
train_losses = []
train_accuracys = []
valid_accuracys = []
for epoch in range(epochs):

    train_loss, train_accuracy = train_one_epoch(train_loader= train_loader, model = model, criterion = criterion, optimizer = optimizer)
    print(f"epoch:{epoch}, loss:{train_loss}, accuracy:{train_accuracy}")
    train_losses.append(train_loss)
    train_accuracys.append(train_accuracy)

    valid_accuracy = valid_one_epoch(valid_loader= val_loader, model = model)
    print(f"valid accuracy:{valid_accuracy}")
    valid_accuracys.append(valid_accuracy)

torch.save(model,'test.pth')

epoch:0, loss:0.020580440697570642, accuracy:87.91666666666667
valid accuracy:100.0
epoch:1, loss:0.004143970409252991, accuracy:99.58333333333333
valid accuracy:100.0
epoch:2, loss:0.0024526457864946375, accuracy:100.0
valid accuracy:100.0
epoch:3, loss:0.0018572715828971316, accuracy:99.79166666666667
valid accuracy:100.0
epoch:4, loss:0.001885829681608205, accuracy:99.79166666666667
valid accuracy:100.0
epoch:5, loss:0.0012724352748288462, accuracy:100.0
valid accuracy:100.0
epoch:6, loss:0.0012308882627015312, accuracy:99.58333333333333
valid accuracy:100.0
epoch:7, loss:0.000938531729237487, accuracy:100.0
valid accuracy:100.0
epoch:8, loss:0.0008737363134666035, accuracy:100.0
valid accuracy:100.0
epoch:9, loss:0.0007390241080429405, accuracy:100.0
valid accuracy:100.0
epoch:10, loss:0.000971730300807394, accuracy:99.79166666666667
valid accuracy:100.0
epoch:11, loss:0.0006812206517982607, accuracy:100.0
valid accuracy:100.0
epoch:12, loss:0.000887786266199934, accuracy:100.0
valid accuracy:100.0
epoch:13, loss:0.0006422517117850173, accuracy:100.0
valid accuracy:100.0
epoch:14, loss:0.0005755920026179714, accuracy:100.0
valid accuracy:100.0
epoch:15, loss:0.0005269992495110879, accuracy:100.0
valid accuracy:100.0
epoch:16, loss:0.0006754447094863281, accuracy:100.0
valid accuracy:100.0
epoch:17, loss:0.0004891647525558559, accuracy:100.0
valid accuracy:100.0
epoch:18, loss:0.0004677536303158073, accuracy:100.0
valid accuracy:100.0
epoch:19, loss:0.00048221670779942843, accuracy:100.0
valid accuracy:100.0

训练完成之后,我们来可视化一下训练过程中的误差变化。

plt.figure(figsize=(13,8))
plt.subplot(1,3,1)
plt.plot(range(epochs), train_losses)
plt.title('Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')

plt.subplot(1,3,2)
plt.plot(range(epochs),train_accuracys)
plt.title('Train Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')

plt.subplot(1,3,3)
plt.plot(range(epochs),valid_accuracys)
plt.title('Valid Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')

plt.savefig('loss_accuracy_changing_with_epoch.png')
plt.show()
png
png

六、预测

有了最终的模型,我们来预测一下,先写一个函数封装一下。

classes = list(valset.class_to_idx)
model = torch.load('./test.pth')

def predict_one_image(image_path, model, transform, classes):
    
    test_img = cv2.imread(image_path)
    plt.imshow(test_img)
    test_img = Image.fromarray(test_img)

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)
    
    model.eval()
    output = model(img)

    _,pred = torch.max(output,1)
    pred_class = classes[pred]
    print(f'预测结果:{pred_class}')
    return pred_class

# 预测训练集中的某张照片
predict_one_image(image_path='./1-cat-dog/train/dog/flickr_dog_000003.jpg', model=model, transform=transform, classes=classes)

预测结果:dog'dog'
png
png
# 来个恶搞,预测下白等,hhhha
predict_one_image(image_path='./1-cat-dog/OIP-C.jpg', model=model, transform=transform, classes=classes)
预测结果:dog'dog'
png
png
# 预测我自己用手机拍的一张照片试试
predict_one_image(image_path='./1-cat-dog/gou.jpg', model=model, transform=transform, classes=classes)
预测结果:dog'dog'
png
png
# 预测从bing上下载的一张照片
predict_one_image(image_path='./1-cat-dog/cat_with_hat.jpg', model=model, transform=transform, classes=classes)
预测结果:cat'cat'
png
png
# 预测验证集中的一张照片

predict_one_image(image_path='./1-cat-dog/val/cat/flickr_cat_000003.jpg', model=model, transform=transform, classes=classes)
预测结果:cat'cat'
png
png

七、知识点详解

1. VGG16模型

vgg-16
vgg-16

vgg16的网络架构图如上所知,可以看到其总共有6个子块,之所以叫做vgg16是因为其中带有可学习参数的网络层一共有16层。

2. 注意点

  • 在使用预训练模型的时候要对模型进行微调,以使得模型适应自己的任务;
  • 在进行预测时候,也要对图片进行相应的预处理,尤其是图像大小

参考

【1】https://www.cnblogs.com/vvlj/p/14141826.html
【2】https://neurohive.io/en/popular-networks/vgg16/

本文由 mdnice 多平台发布

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/43248.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

深度学习--猫狗图像分类

1、环境介绍 python3.6,tensorflow1.4版本,pycharm编译器 2、函数库导入 import cv2 import matplotlib.pyplot as plt import os, PIL, pathlib import numpy as np from tensorflow.keras.layers import Conv2D,MaxPooling2D,Dropout,Dense,Flatten,A…

Kaggle-猫狗图像分类全流程实践(支持迁移学习和其他分类任务迁移)

1、insatll environment|安装环境 !pip install torchtoolbox !pip install torchsummary2、import package|导入三方库 # 基础库 import os import time import random import shutil import pandas as pd import csv from math import exp from PIL import Image import nu…

神经网络实战--使用迁移学习完成猫狗分类

前言: Hello大家好,我是Dream。 今天来学习一下如何使用基于tensorflow和keras的迁移学习完成猫狗分类,欢迎大家一起前来探讨学习~ 本文目录: 一、加载数据集1.调用库函数2.加载数据集3.数据集管理 二、猫狗数据集介绍1.猫狗数据集…

基于Pytorch的猫狗分类

无偿分享~ 猫狗二分类文件下载地址 在下一章说 猫狗分类这个真是困扰我好几天,找了好多资料都是以TensorFlow的猫狗分类,但我们要求的是以pytorch的猫狗分类。刚开始我找到了也运行成功了觉得可以了,最后看了一眼实践要求傻眼了,…

猫舍 靶场

目标url:http://117.41.229.122:8003/?id1 第一步,判断是否存在sql注入漏洞 构造 ?id1 and 11 ,回车 页面返回正常 构造 ?id1 and 12 ,回车 页面不正常,初步判断这里 可能 存在一个注入漏洞 第二步:判断字段数 构造 ?id1 and 11 order…

Olaparib 有望治疗 UBQLN4 过表达型肿瘤

基因组的不稳定性是人类遗传病和癌症的一大特点。在这篇文章当中,研究人员在常染色体隐性遗传病家族中发现了有害的 UBQLN4 突变。蛋白酶体穿梭因子UBQLN4 被 ATM 磷酸化并与泛素化的 MRE11 相互作用,从而介导早期的同源重组修复 (HRR)。在体外和体内实验…

神经内分泌肿瘤治疗新进展,神经内分泌肿瘤进展

脑肿瘤复发 。 颅内及椎管内肿瘤【概述】1.原发性肿瘤:起源于头颅、椎管内各种组织结构,如颅骨、脑膜、脑组织、颅神经、脑血管、脑垂体、松果体、脉络丛、颅内结缔组织、胚胎残余组织、脊膜、脊神经、脊髓、脊髓血管及脂肪组织等&#xff…

Nature Cancer | 发现非肿瘤药物的抗癌潜力

今天给大家介绍美国Broad Institute of MIT and Harvard的 Todd R. Golub团队发表在Nature cancer上的一篇文章:“Discovering the anticancer potential of nononcology drugs by systematic viability profiling“。在这个研究中,作者试图创建一个公共…

文献分享:定义的肿瘤抗原特异性T细胞增强了个性化的TCR-T细胞治疗和免疫治疗反应的预测

《Defifined tumor antigen-specifific T cells potentiate personalized TCR-T cell therapy and prediction of immunotherapy response》 简介 从患者体内自然发生的肿瘤抗原特异性T(Tas)细胞中提取的T细胞受体(TCRs)设计的T细胞将靶向其肿瘤中的个人TSAs。为了建立这种个性…

Irinotecan和vandetanib在治疗胰腺癌患者时产生协同效应(Irinotecan and vandetanib create synergies for t)

1. 摘要 背景:在胰腺癌(PAAD)中最常突变的基因对是KRAS和TP53,文章的目标是阐明KRAS/TP53突变的多组学和分子动力学图景,并为KRAS和TP53突变的PAAD患者获得有前景的新药物。此外,文章根据多组学数据尝试发现KRAS与TP53之间可能的联系。    …

癌症/肿瘤免疫治疗最新研究进展(2022年4月)

近年来,免疫治疗一直都是国内外肿瘤治疗研究领域的火爆热点,可以称之为革命性的突破。 除了大家熟知的PD-1/PD-L1已经先后斩获了包括肺癌、胃肠道肿瘤、乳腺癌、泌尿系统肿瘤、皮肤癌、淋巴瘤等在内的近20大实体肿瘤,成为免疫治疗的第一张王牌…

MCE | 癌症诊断和靶向治疗的“遍地开花”

据研究报道,很多癌细胞分泌的外泌体 (Exosome) 比正常细胞分泌的多 10 倍以上。外泌体参与了癌症的发生、进展、转移和耐药性,并通过转运蛋白和核酸,建立与肿瘤微环境的联系。例如,外泌体可导致免疫逃逸,癌细胞的免疫逃…

泛癌分析·找出各个癌症的预后相关基因

泛癌分析找出各个癌症的预后相关基因 ` 其他相关文章: 万物皆可pan分析高分文章登山梯for循环的熟练操作 前言 pan分析的第二篇我想写一下如何在TCGA整个基因集内实现COX单因素分析,将所有的预后相关基因筛选出来,同时得到这些基因的基本参数、统计量等信息。这样的分析的…

饮食干预减轻癌症治疗相关症状和毒性

现代化疗,放射疗法在摧毁癌细胞的同时,对健康细胞也造成了伤害,引发相关毒性,反应例如便秘,腹泻,疲劳,恶心,呕吐等。 癌症患者的营养状况可能是癌症治疗相关毒性的核心决定因素&…

边缘计算,是在炒概念吗?

导读:边缘计算概念刚出来的时候,很多人的第一反应是“这是哪个行业组织或者公司为了拉动市场需求而创造出来的新词汇吧?” 边缘计算究竟是什么?为什么会有边缘计算?它是一个全新的概念吗?谁在担任边缘计算的…

移动边缘计算笔记

该篇文章是阅读《移动边缘计算综述》所整理的笔记和心得,仅供参考,欢迎指正。 移动边缘计算(MEC),mobile edgecomputing,后来慢慢过渡为“多接入边缘计算”(multi-access edge computing&#x…

关于边缘计算和边云协同,看这一篇就够了~

几年前,大多数人都期望将物联网部署至云端,这的确可以给个人用户带来便捷的使用体验,但构建企业级的物联网解决方案,仍然需要采用云计算和边缘计算的结合方案。与纯粹的云端解决方案相比,包含边缘侧的混合方案可以减少…

边缘计算简介以及几款边缘计算开源平台

边缘计算中的边缘(edge)指的是网络边缘上的计算和存储资源,这里的网络边缘与数据中心相对,无论是从地理距离还是网络距离上来看都更贴近用户。作为一种新的计算范式,边缘计算将计算任务部署于接近数据产生源的网络边缘…

什么是边缘计算?

注:本篇翻译自施巍松教授的论文《Edge Computing : Vision and Challenges》 目录 文章目录 摘要简介什么是边缘计算什么是边缘计算边缘计算的优点 案例研究云卸载视频分析智能家居智慧城市 机遇和挑战编程可行性命名数据抽象服务管理私密性最优化指标 小结 摘要 …

中国电信边缘计算最佳实践

大数据、云计算、AI 等新一代信息技术的高速发展,在为新兴互联网行业提供强劲驱动之外,也在引领传统行业实施数字化、智能能化转型,并催生出智能制造、智慧金融等一系列全新智能产业生态。在中国电信 MEC 平台中,中国电信正依托自…