用VGG16训练分类模型

最新推荐文章于 2023-07-31 23:29:23 发布
最新推荐文章于 2023-07-31 23:29:23 发布
阅读量719 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45752541/article/details/109506353
版权

系列文章目录

@[TOC](文章目录)

前言

话不多说，直接上代码

一、训练过程

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

import torch
import torch.nn as nn
from torch import  optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
from tqdm import tqdm
from PIL import Image
from torch.utils.data import Dataset
from Focalloss import FocalLoss

class MyDataset(Dataset):
    def __init__(self, txt_path, transform = None, target_transform = None):
	    fh = open(txt_path, 'r')
	    imgs = []
	    for line in fh:
		    line = line.rstrip()
		    words = line.split()
		    imgs.append((words[0], int(words[1])))
		    self.imgs = imgs 
		    self.transform = transform
		    self.target_transform = target_transform
    def __getitem__(self, index):
    	fn, label = self.imgs[index]
    	img = Image.open(fn).convert('RGB') 
    	if self.transform is not None:
    		img = self.transform(img) 
    	return img, label
    def __len__(self):
    	return len(self.imgs)


'''定义超参数'''
batch_size = 8        # 批的大小
learning_rate = 1e-3    # 学习率
num_epoches = 100      # 遍历训练集的次数

classes = ('circle','triangle','square','basketball','volleyball','football')

root=r'D:\\class'   #存放图片和标签（txt）

data_transform = transforms.Compose([
    transforms.RandomResizedCrop(128),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean = [0.22358292 ,0.22358292, 0.22358292],
                         std  =  [0.15551882, 0.15551882, 0.15551882]),
    ])



'''下载训练集 CIFAR-10 10分类训练集'''
#train_dataset = datasets.CIFAR10('./data', train=True, transform=transforms.ToTensor(), download=True)
#train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
#test_dataset = datasets.CIFAR10('./data', train=False, transform=transforms.ToTensor(), download=True)
#test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
train_dataset = MyDataset(txt_path=r'D:\\class\train.txt', transform=data_transform)
#图片放在class文件夹中，标签文件train.txt格式为（图片绝对路径＋类别：D:\class\0001.jpg 0）
test_dataset = MyDataset(txt_path=r'D:\\class\valid.txt', transform=data_transform)
train_loader = DataLoader(dataset = train_dataset, batch_size=16, shuffle=True)
test_loader = DataLoader(dataset = test_dataset, batch_size=2)


'''定义网络模型'''
class VGG16(nn.Module):
    def __init__(self, num_classes=6):
        super(VGG16, self).__init__()
        self.features = nn.Sequential(
            #1
            nn.Conv2d(3,64,kernel_size=3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            #2
            nn.Conv2d(64,64,kernel_size=3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #3
            nn.Conv2d(64,128,kernel_size=3,padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            #4
            nn.Conv2d(128,128,kernel_size=3,padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #5
            nn.Conv2d(128,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            #6
            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            #7
            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #8
            nn.Conv2d(256,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #9
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #10
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #11
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #12
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #13
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            nn.AvgPool2d(kernel_size=1,stride=1),
            )
        self.classifier = nn.Sequential(
            #14
            nn.Linear(8192,4096),
            nn.ReLU(True),
            nn.Dropout(),
            #15
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            #16
            nn.Linear(4096,6),
            )
        #self.classifier = nn.Linear(512, 10)
 
    def forward(self, x):
        out = self.features(x) 
#        print(out.shape)
        out = out.view(out.size(0), -1)
#        print(out.shape)
        out = self.classifier(out)
#        print(out.shape)
        return out


'''创建model实例对象，并检测是否支持使用GPU'''
model = VGG16()

#model.load_state_dict(torch.load("/home/jc/CenterNet/src/vgg16.pth"))
use_gpu = torch.cuda.is_available()  # 判断是否有GPU加速
if use_gpu:
    model = model.cuda()


'''定义loss和optimizer'''
criterion = FocalLoss(class_num = 6)
optimizer = optim.SGD(model.parameters(), lr=learning_rate)


'''训练模型'''

for epoch in range(num_epoches):
    print('*' * 25, 'epoch {}'.format(epoch + 1), '*' * 25)      # .format为输出格式，formet括号里的即为左边花括号的输出
    running_loss = 0.0
    running_acc = 0.0
    model.train()
    for i, data in tqdm(enumerate(train_loader, 1)):
        
        img, label = data
        # cuda
        if use_gpu:
            img = img.cuda()
            label = label.cuda()
        img = Variable(img)
        label = Variable(label)
        # 向前传播
        out = model(img)
        loss = criterion(inputs = out, targets = label)
        running_loss += loss.item() * label.size(0)
        _, pred = torch.max(out, 1)     # 预测最大值所在的位置标签
        num_correct = (pred == label).sum()
        accuracy = (pred == label).float().mean()
        running_acc += num_correct.item()
        # 向后传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print('Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format(
        epoch + 1, running_loss / (len(train_dataset)), running_acc / (len(train_dataset))))
    model.eval()    # 模型评估
    eval_loss = 0
    eval_acc = 0
    for data in test_loader:      # 测试模型
        img, label = data
        if use_gpu:
           with torch.no_grad():
              img = Variable(img).cuda()
              label = Variable(label).cuda()
        else:
            with torch.no_grad():
              img = Variable(img)
              label = Variable(label)
        out = model(img)
        loss = criterion(out, label)
        eval_loss += loss.item() * label.size(0)
        _, pred = torch.max(out, 1)
        num_correct = (pred == label).sum()
        eval_acc += num_correct.item()
    print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(
        test_dataset)), eval_acc / (len(test_dataset))))
    print()

# 保存模型
torch.save(model.state_dict(), './vgg16.pth')

二、FocalLoss

代码如下（示例）：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
class FocalLoss(nn.Module):
    r"""
        This criterion is a implemenation of Focal Loss, which is proposed in 
        Focal Loss for Dense Object Detection.
            Loss(x, class) = - \alpha (1-softmax(x)[class])^gamma \log(softmax(x)[class])
        The losses are averaged across observations for each minibatch.
        Args:
            alpha(1D Tensor, Variable) : the scalar factor for this criterion
            gamma(float, double) : gamma > 0; reduces the relative loss for well-classified examples (p > .5), 
                                   putting more focus on hard, misclassified examples
            size_average(bool): By default, the losses are averaged over observations for each minibatch.
                                However, if the field size_average is set to False, the losses are
                                instead summed for each minibatch.
    """
    def __init__(self, class_num, alpha=None, gamma=2, size_average=True):
        super(FocalLoss, self).__init__()
        if alpha is None:
            self.alpha = Variable(torch.ones(class_num, 1))
        else:
            if isinstance(alpha, Variable):
                self.alpha = alpha
            else:
                self.alpha = Variable(alpha)
        self.gamma = gamma
        self.class_num = class_num
        self.size_average = size_average
    def forward(self, inputs, targets):
        N = inputs.size(0)
        C = inputs.size(1)
        P = F.softmax(inputs, dim=1)          # 按行SoftMax(每行归一化，维度不变),行和为1，
        class_mask = inputs.data.new(N, C).fill_(0)       #生成新tensor，维度相同，用0填充
        class_mask = Variable(class_mask)
        ids = targets.view(-1, 1)
        class_mask.scatter_(1, ids.data, 1.)       #把GT编译成one-hot编码
        #print(class_mask)
        if inputs.is_cuda and not self.alpha.is_cuda:
            self.alpha = self.alpha.cuda()
        alpha = self.alpha[ids.data.view(-1)]      #把ids改成一行
        probs = (P*class_mask).sum(1).view(-1,1)
        log_p = probs.log()
        #print('probs size= {}'.format(probs.size()))
        #print(probs)
        batch_loss = -alpha*(torch.pow((1-probs), self.gamma))*log_p 
        #print('-----bacth_loss------')
        #print(batch_loss)
        if self.size_average:
            loss = batch_loss.mean()
        else:
            loss = batch_loss.sum()
        return loss

三、预测过程

代码如下（示例）：

import torch
import torch.nn as nn
from torch import  optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import torchvision.models as models
from tqdm import tqdm
from PIL import Image
from torch.utils.data import Dataset
import os
from glob import glob


data_transform = transforms.Compose([
    transforms.RandomResizedCrop(128),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean = [0.22358292 ,0.22358292, 0.22358292],
                         std  =  [0.15551882, 0.15551882, 0.15551882]),
    ])

classes = ('circle','triangle','square','basketball','volleyball','football')

demo_fold = 'D:/Pic'


class VGG16(nn.Module):
    def __init__(self, num_classes=6):
        super(VGG16, self).__init__()
        self.features = nn.Sequential(
            #1
            nn.Conv2d(3,64,kernel_size=3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            #2
            nn.Conv2d(64,64,kernel_size=3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #3
            nn.Conv2d(64,128,kernel_size=3,padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            #4
            nn.Conv2d(128,128,kernel_size=3,padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #5
            nn.Conv2d(128,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            #6
            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            #7
            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #8
            nn.Conv2d(256,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #9
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #10
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #11
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #12
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #13
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            nn.AvgPool2d(kernel_size=1,stride=1),
            )
        self.classifier = nn.Sequential(
            #14
            nn.Linear(8192,4096),
            nn.ReLU(True),
            nn.Dropout(),
            #15
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            #16
            nn.Linear(4096,6),
            )
        #self.classifier = nn.Linear(512, 10)
 
    def forward(self, x):
        out = self.features(x) 
#        print(out.shape)
        out = out.view(out.size(0), -1)
#        print(out.shape)
        out = self.classifier(out)
#        print(out.shape)
        return out
    
def fenlei(inputs):
        model =  VGG16()
        model.load_state_dict(torch.load("D:/xzz/研一/vgg16/vgg16.pth"))
        img = data_transform(inputs).reshape(1,3,128,128)
        model.eval()
        out = model(img)
        _, pred = torch.max(out, 1)
        pred = classes[pred.item()]
        #print(pred)
        return pred    



model =  VGG16()
model.load_state_dict(torch.load("D:/xzz/研一/vgg16/vgg16.pth"))
fList=os.listdir(demo_fold)
for i in fList :
    img = Image.open(os.path.join(demo_fold,i)).convert('RGB') 
    img = data_transform(img).reshape(1,3,128,128)
    model.eval()
    out = model(img)
    _, pred = torch.max(out, 1)
    pred = classes[pred.item()]
    print(pred)

该处使用的url网络请求的数据。

总结

后续还会更新一些ap值计算的test.py文件，敬请关注

杀生丸学AI
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用vgg16进行二分类-vgg16.zip
04-05
利用vgg16进行的猫狗图像的分类，由于其在模型比普通的cnn的层更加复杂，所以分类效果较优。同时可根据结果添加dropout层避免出现的过拟合现象。训练和测试图像较大没有放上来，可私聊/评论后发送。
VGG16-keras完整训练流程
zhouxuechao的博客
03-15 4023
VGG16-keras实现步骤 ​ 最近在复现一些基础的论文，怕自己忘得太快了，记录一下笔记，后续会逐渐更新。 ​ VGG是由Simonyan 和Zisserman在文献《Very Deep Convolutional Networks for Large Scale Image Recognition》中提出卷积神经网络模型，其名称来源于作者所在的牛津大学视觉几何组(Visual Geometry Group)的缩写。 ​ 该模型参加2014年的 ImageNet图像分类与定位挑战赛，取得了优异成.
用VGG_16网络模型训练并测试自己的数据库（超级详细的教程）
visvim的博客
04-14 8528
网络结构：VGG-16 数据库：cats_vs_dogs 硬件：Nvida Quadro p2000 5GB 深度学习框架：Tensorflow 文章目录step1: Get Filestep2: Transform To TFRecordstep3: Read TFRecordstpe4: VGG_16 Modelstep5: Train step1: Get File 找到已经下载到电脑...
Tensorflow学习笔记：VGG16训练——Finetuning，猫狗大战，VGGNet的重新针对训练
luckyboy101的专栏
10-26 3045
前面我们介绍了猫狗大战的数据集的整理已经转换成Tensorflow专用格式https://blog.csdn.net/nvidiacuda/article/details/83413837 以及介绍了vgg16模型https://blog.csdn.net/nvidiacuda/article/details/83414293 这篇介绍如何用数据对vgg16进行训练 Finetuning最重...
Tensorflow加载Vgg预训练模型
GodWriter的博客
03-02 7062
很多深度神经网络模型需要加载预训练过的Vgg参数，比如说：风格迁移、目标检测、图像标注等计算机视觉中常见的任务。那么到底如何加载Vgg模型呢？Vgg文件的参数到底有何意义呢？加载后的模型该如何使用呢？本文将以Vgg19为例子，详细说明Tensorflow如何加载Vgg预训练模型。 实验环境 GTX1050-ti, cuda9.0 Window10, Tensorflow 1.12...
VGG16实现Cifar10分类训练模型
02-04
VGG16实现Cifar10分类训练模型
pytorch迁移学习训练VGG16和模型测试代码
05-13
Pytorch迁移学习训练VGG16和模型测试代码（采用华为云modelarts训练），训练猫狗分类模型
浅谈keras使用预训练模型vgg16分类,损失和准确度不变
09-16
主要介绍了浅谈keras使用预训练模型vgg16分类,损失和准确度不变，具有很好的参考价值，希望对大家有所帮助。一起跟随小编小编过来看看吧
利用vgg预训练模型提取图像特征及常见问题
for happy の road
04-01 3260
VGG卷积神经网络是牛津大学在2014年提出来的模...
Keras 二分类 VGG-16
matafeiyanll的博客
02-15 1211
猫狗分类 VGG-16 导入相关的包 from keras.applications.vgg16 import VGG16 from keras.preprocessing import image from keras.applications.vgg16 import preprocess_input import numpy as np from keras.preprocessing.im...
使用自己的数据训练 Faster R-CNN 的 VGG-16 模型
weixin_39970417的博客
09-26 3428
版权声明：Copyright (c) strongnine https://blog.csdn.net/weixin_39679367/article/details/80930830 最近在学习 Faster R-CNN 模型，为了了解其中网络的结构，利用 PascalVOC 数据集，来扩展网络的类别（原来有 20 类）。过程分为：数据准备 ==> 相关文件修改 ==> 训练网络 ...
TensorFlow2学习十五、使用VGG16模型训练自己的数据集
编程圈子-谢厂节的博客
11-29 6866
一、说明 VGG16在2014年ImageNet比赛中获胜。ImageNet数据集中有1000个图像属于1000个不同的类别。 VGG模型的权重是免费的，可以在您自己的模型和应用程序中加载和使用。这使得其他研究人员和开发人员可以在自己的工作和程序中使用最先进的图像分类模型。 二、实现过程 1. 这里使用谷歌的花卉数据集。 from __future__ import absolute_impor...
【分类】VGG16训练记录
Maisie_Nan的博客
01-06 440
1.所有文件名加标签后缀，生成train乱序的list 参考：https://blog.csdn.net/cpongo3/article/details/93624404 rename 's/\.jpg/\_0.jpg/' * rename 's/\.jpg/\_180.jpg/' * rename 's/\.jpg/\_180.jpg/' * rename 's/\.jpg/\_180....
0026-pytorch入门-图片二分类在VGG16基础上finetune
左手coding，右手cooking
01-24 1094
# -*- coding: utf-8 -*- """ Created on ${DATE} ${TIME} @author: Johnson Email:[email protected] """ import torch import torchvision #prepare model1_vgg16 = torchvision.models.vgg16(pretrained=True) #设置网络参数 #读取输入特征的维度 num_fc = model1_vgg16.classifier[6].i
vgg16网络实现车牌二分类（整理）
但行好事，莫问前程
07-11 4701
参考：https://blog.csdn.net/qq_37389133/article/details/80707304，感谢文件结构：vgg16:---data      #存放训练数据     ---Yes     ---No---model   #存放训练好的模型---pred_data   #存放测速数据    ---Yes    ---No---vgg16.npy   #参数文件，直接...
keras 利用vgg16处理kaggle的猫狗大战二分类问题
ZJE
07-30 4890
一，kaggle的猫狗打大战数据集 Kaggle猫狗大战的数据集下载链接：https://www.kaggle.com/c/dogs-vs-cats 二，vgg网络 vgg是拥有比较深层数的cnn网络(当然比不上resnet)，其中vgg按照层数的不同分为了vgg11，vgg13，vgg16，vgg19，举例说明vgg11就是卷积层加上全连接层一共11层，具体如下图，其中红色框框住的C,...
基于vgg16的猫狗识别（二分类）
weixin_55833709的博客
06-12 1007
基于vgg16的猫狗识别（二分类）
Pytorch使用VGG16模型进行预测猫狗二分类
qq_43649937的博客
07-31 3023
pytorch python
vgg16二分类模型
最新发布
04-08
VGG16是一种经典的卷积神经网络模型，由Karen Simonyan和Andrew Zisserman于2014年提出。它在ImageNet图像分类挑战赛中取得了很好的成绩，并且被广泛应用于计算机视觉领域。 VGG16模型的结构相对简单，它由16个卷积层和3个全连接层组成。其中，卷积层主要用于提取图像的特征，全连接层则用于将提取到的特征映射到不同的类别上。 对于二分类任务，可以将VGG16模型的最后一个全连接层进行修改，使其输出两个节点，分别表示两个类别的概率。一般常用的修改方式是将最后一个全连接层的输出节点数改为2，并添加一个softmax激活函数，用于将输出转化为概率值。 训练VGG16二分类模型时，可以使用已标注好的数据集进行监督学习。通过反向传播算法和优化器，可以不断调整模型参数，使得模型能够更好地区分两个类别。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值