caffe python接口： 使用训练好的VGG16模型 对 单张图片进行分类，输出置信度

最新推荐文章于 2024-07-02 00:05:18 发布
最新推荐文章于 2024-07-02 00:05:18 发布
阅读量3.7k 收藏 1
点赞数
分类专栏： caffe 文章标签： 分类 vgg16 deploy.proto python+caffe

部分参考：http://blog.csdn.net/tangwenbo124/article/details/52725263

说明：数据集是上海BOT大赛的（12种动物），网上下载的vgg16权重文件，并且修改输出类别为12，对最后三层全连接网络训练了8个小时，top1准确率为80%，top5准确率95%

使用的测试图片是一个长颈鹿，类别编号是8，结果如下： 
这里写图片描述

 预测源码

#coding:utf-8
import numpy as np
import caffe

bot_data_root = 'F:/bot_data'

# 设置网络结构
net_file = bot_data_root + '/myVGG16/VGG_ILSVRC_16_layers_deploy.prototxt'
# 添加训练之后的网络权重参数
caffe_model = bot_data_root + '/myVGG16/myvggmodel__iter_80000.caffemodel'
# 均值文件
mean_file = bot_data_root + '/myVGG16/mean.npy'
# 设置使用gpu
caffe.set_mode_gpu()

# 构造一个Net
net = caffe.Net(net_file, caffe_model, caffe.TEST)
# 得到data的形状，这里的图片是默认matplotlib底层加载的
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
# matplotlib加载的image是像素[0-1],图片的数据格式[weight,high,channels]，RGB
# caffe加载的图片需要的是[0-255]像素，数据格式[channels,weight,high],BGR，那么就需要转换

# channel 放到前面
transformer.set_transpose('data', (2, 0, 1))
transformer.set_mean('data', np.load(mean_file).mean(1).mean(1))
# 图片像素放大到[0-255]
transformer.set_raw_scale('data', 255)
# RGB-->BGR 转换
transformer.set_channel_swap('data', (2, 1, 0))
#设置输入的图片shape，1张，3通道，长宽都是224
net.blobs['data'].reshape(1, 3, 224, 224)
# 加载图片
im = caffe.io.load_image(bot_data_root + '/test_min/Testset 1/0a3e66aea7f64597ad851bfffb929c5a.png')

# 用上面的transformer.preprocess来处理刚刚加载图片
net.blobs['data'].data[...] = transformer.preprocess('data', im)

#输出每层网络的name和shape
for layer_name, blob in net.blobs.iteritems():
    print layer_name + '\t' + str(blob.data.shape)

# 网络开始向前传播啦
output = net.forward()

# 找出最大的那个概率
output_prob = output['out'][0]
print '预测的类别是:', output_prob.argmax()

# 找出最可能的前俩名的类别和概率
top_inds = output_prob.argsort()[::-1][:2]
print "预测最可能的前两名的编号: ",top_inds
print "对应类别的概率是: ", output_prob[top_inds[0]], output_prob[top_inds[1]]
  • 多进程版代码
    • 代码的几点说明：
      • Muti_Classify类中的run方法重写了父类的run()方法（标准run()方法）
      • 解析：代码中只在类中重写了run()方法，但没有显式调用的原因：该知识点在于多进程中run()和stat()的区别,start()函数令进程对象开辟一个单独（子）线程并在其中调用run()方法（而非当前所处线程）。其实是在start()处调用了重写后的run()方法。
#coding:utf-8

#> run like:
#>:
# python2 classify.py 20 '/home/spark/grocery/FER/codes/caffe_2classify/test/test_img.txt' '/home/spark/grocery/FER/codes/caffe_2classify/test/res.txt'

import numpy as np
import sys, os
sys.path.append('/home/spark/caffe-master/python')
import caffe
from multiprocessing import Process


def single_classify(proc_num, proc_id, imgs_text, save_txt):
  net_file = '/home/spark/grocery/FER/codes/caffe_2classify/test/size32_2classify_deploy.prototxt'
  caffe_model = "/home/spark/grocery/FER/codes/caffe_2classify/model/size32_2classify_v2_iter_75000.caffemodel"
  net = caffe.Net(net_file, caffe_model, caffe.TEST)
  caffe.set_mode_gpu()

  with open(imgs_text, 'r') as fr:
    for i, img_and_label in enumerate(fr.readlines()):
      if not i % proc_num == proc_id:
        continue
      img_path = img_and_label.strip('\n').split(' ')[0]
      transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
      transformer.set_transpose('data', (2, 0, 1))
      transformer.set_raw_scale('data', 255)
      transformer.set_channel_swap('data', (2, 1, 0))
      net.blobs['data'].reshape(1, 3, 32, 32)

      im = caffe.io.load_image(img_path)
      net.blobs['data'].data[...] = transformer.preprocess('data', im)
      output = net.forward()

      output_prob = output['out'][0]
      with open(save_txt, 'a') as fw:
        fw.write(img_and_label.strip('\n') +  ' ' + str(output_prob.argmax()) + " " + \
        str(output_prob[0]) + ' ' + str( output_prob[1]) + '\n')


class Multi_Classify(Process):
  def __init__(self, proc_num, proc_id, imgs_text, save_txt):
    super(Multi_Classify, self).__init__()
    self.proc_num = proc_num
    self.proc_id = proc_id
    self.imgs_text = imgs_text
    self.save_txt = save_txt

  def run(self):
    single_classify(self.proc_num, self.proc_id, self.imgs_text, self.save_txt)

def batch_classify(proc_num, imgs_text, save_txt):
  proc_list = []
  for i in range(proc_num):
    proc_list.append(Multi_Classify(proc_num, i, imgs_text, save_txt))

  for proc in proc_list:
    proc.start()

  for proc in proc_list:
    proc.join()

if __name__ == '__main__':
  proc_num = int(sys.argv[1])
  imgs_text = sys.argv[2]
  save_txt = sys.argv[3]
  batch_classify(proc_num, imgs_text, save_txt)
  print("ok")
  • 网络结构代码
    • 注：下面为旧版本caffe定义的结构，如果使用的是caffe的新版本需要进行修改。如layers-->layer;  type对应的字段以及其字段需加引号；还要注意python执行时的版本。  
name: "VGG_ILSVRC_16_layers"
input: "data"
input_dim: 1
input_dim: 3
input_dim: 224
input_dim: 224
layers {
  bottom: "data"
  top: "conv1_1"
  name: "conv1_1"
  type: CONVOLUTION
  convolution_param {
    num_output: 64
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv1_1"
  top: "conv1_1"
  name: "relu1_1"
  type: RELU
}
layers {
  bottom: "conv1_1"
  top: "conv1_2"
  name: "conv1_2"
  type: CONVOLUTION
  convolution_param {
    num_output: 64
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv1_2"
  top: "conv1_2"
  name: "relu1_2"
  type: RELU
}
layers {
  bottom: "conv1_2"
  top: "pool1"
  name: "pool1"
  type: POOLING
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  bottom: "pool1"
  top: "conv2_1"
  name: "conv2_1"
  type: CONVOLUTION
  convolution_param {
    num_output: 128
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv2_1"
  top: "conv2_1"
  name: "relu2_1"
  type: RELU
}
layers {
  bottom: "conv2_1"
  top: "conv2_2"
  name: "conv2_2"
  type: CONVOLUTION
  convolution_param {
    num_output: 128
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv2_2"
  top: "conv2_2"
  name: "relu2_2"
  type: RELU
}
layers {
  bottom: "conv2_2"
  top: "pool2"
  name: "pool2"
  type: POOLING
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  bottom: "pool2"
  top: "conv3_1"
  name: "conv3_1"
  type: CONVOLUTION
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv3_1"
  top: "conv3_1"
  name: "relu3_1"
  type: RELU
}
layers {
  bottom: "conv3_1"
  top: "conv3_2"
  name: "conv3_2"
  type: CONVOLUTION
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv3_2"
  top: "conv3_2"
  name: "relu3_2"
  type: RELU
}
layers {
  bottom: "conv3_2"
  top: "conv3_3"
  name: "conv3_3"
  type: CONVOLUTION
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv3_3"
  top: "conv3_3"
  name: "relu3_3"
  type: RELU
}
layers {
  bottom: "conv3_3"
  top: "pool3"
  name: "pool3"
  type: POOLING
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  bottom: "pool3"
  top: "conv4_1"
  name: "conv4_1"
  type: CONVOLUTION
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv4_1"
  top: "conv4_1"
  name: "relu4_1"
  type: RELU
}
layers {
  bottom: "conv4_1"
  top: "conv4_2"
  name: "conv4_2"
  type: CONVOLUTION
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv4_2"
  top: "conv4_2"
  name: "relu4_2"
  type: RELU
}
layers {
  bottom: "conv4_2"
  top: "conv4_3"
  name: "conv4_3"
  type: CONVOLUTION
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv4_3"
  top: "conv4_3"
  name: "relu4_3"
  type: RELU
}
layers {
  bottom: "conv4_3"
  top: "pool4"
  name: "pool4"
  type: POOLING
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  bottom: "pool4"
  top: "conv5_1"
  name: "conv5_1"
  type: CONVOLUTION
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv5_1"
  top: "conv5_1"
  name: "relu5_1"
  type: RELU
}
layers {
  bottom: "conv5_1"
  top: "conv5_2"
  name: "conv5_2"
  type: CONVOLUTION
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv5_2"
  top: "conv5_2"
  name: "relu5_2"
  type: RELU
}
layers {
  bottom: "conv5_2"
  top: "conv5_3"
  name: "conv5_3"
  type: CONVOLUTION
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
  }
  blobs_lr: 0
  blobs_lr: 0
}
layers {
  bottom: "conv5_3"
  top: "conv5_3"
  name: "relu5_3"
  type: RELU
}
layers {
  bottom: "conv5_3"
  top: "pool5"
  name: "pool5"
  type: POOLING
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layers {
  bottom: "pool5"
  top: "fc6"
  name: "fc6"
  type: INNER_PRODUCT
  inner_product_param {
    num_output: 4096
  }
  blobs_lr: 1
  blobs_lr: 2
}
layers {
  bottom: "fc6"
  top: "fc6"
  name: "relu6"
  type: RELU
}
layers {
  bottom: "fc6"
  top: "fc6"
  name: "drop6"
  type: DROPOUT
  dropout_param {
    dropout_ratio: 0.5
  }
}
layers {
  bottom: "fc6"
  top: "fc7"
  name: "fc7"
  type: INNER_PRODUCT
  inner_product_param {
    num_output: 4096
  }
  blobs_lr: 1
  blobs_lr: 2
}
layers {
  bottom: "fc7"
  top: "fc7"
  name: "relu7"
  type: RELU
}
layers {
  bottom: "fc7"
  top: "fc7"
  name: "drop7"
  type: DROPOUT
  dropout_param {
    dropout_ratio: 0.5
  }
}
layers {
  name: "myfc8"
  bottom: "fc7"
  top: "myfc8"
  type: INNER_PRODUCT

  inner_product_param {
    num_output: 12
    weight_filler {  
      type: "gaussian"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }
  blobs_lr: 10
  blobs_lr: 20
}
layers {
  bottom: "myfc8"
  top: "out"
  name: "out"
  type: SOFTMAX
}

 

 

 

wonengguwozai
关注
专栏目录
Python 人工智能实战：自动驾驶
程序员光剑
10-21 582
自动驾驶(self-driving car)技术是通过计算机系统把现有的汽车机械结构和传感器结合起来,能够将驾驶者控制的车辆变成一个人类驾驶者可以理解的行为,而无需驾驶员自行操控的一种驾驶技术。自动驾驶系统能够精确地预测道路的情况并避免前方障碍物影响,从而安全、准确地驾驶汽车。由于自动驾驶的巨大需求和应用前景,当前已经有许多团队、研究机构和企业积极探索和开发自动驾驶系统。目前国内外的自动驾驶公司、研究机构和个人也在不断投入研发新型的自动驾驶技术。
使用Python，OpenCV，本地二进制模式（LBP）进行人脸识别
qq_40985985的博客
08-21 1737
在深度学习和暹罗网络之前，面部识别算法依赖于特征提取和机器学习。 今天，我们将涵盖最受欢迎的预学习人脸识别算法之一，用局部二进制模式（LBPS）面对脸部检测。
python图像处理-图片分类项目
lishuaixixi的博客
03-13 2746
目录 最近帮朋友做一个图片数据分类的项目，借鉴了大佬的代码，修修改改,话不多说直接上代码！ 一、图片转batch文件 import numpy as np from PIL import Image import operator from os import listdir import sys import pickle import random data = {} list1 = [] list2 = [] list3 = [] # 将图片转化为32*32的三通道图片 def img_t
caffe+python 使用训练好的VGG16模型 对 单张图片进行分类，输出置信度
热门推荐
PlusTang
10-02 2万+
网上看了一堆都是图片转lmdb格式，然后测试总的准确率，我想测试每张图片的top1，top2以及对应置信度是多少，摸索了一下午+一晚上终于搞定，期间遇到不少坑！！！同时感谢实验室博士师兄一块帮我找bug说明：数据集是上海BOT大赛的（12种动物），网上下载的vgg16权重文件，并且修改输出类别为12，对最后三层全连接网络训练了8个小时，top1准确率为80%，top5准确率95%使用的测试图片是一个
深度学习（论文版）| 基于 VGG16-UNet 语义分割模型的猫狗图像提取研究
最新发布
ttrr27的博客
07-02 1472
Hi，大家好，我是半亩花海。本实验本项目基于 VGG16-UNet 架构，利用 Labelme 标注数据和迁移学习，构建高效准确的猫狗图像分割模型。通过编码器-解码器结构（特征提取-上采样）提升分割精度，适应不同场景，推动图像分割技术发展。
基于VGG16网络模型对图像进行识别分类
weixin_44879270的博客
12-20 7544
基于VGG16网络模型对图像进行识别分类 随着人工智能热潮的发展，图像识别已经成为了其中非常重要的一部分。图像识别是指计算机对图像进行处理、分析，以识别其中所含目标的类别及其位置(即目标检测和分类)的技术。其中图像分类是图像识别的一个类，是给定一幅测试图像，利用训练好的分类器判定它所属的类别。 该项目分为三部分： 第一部分：系统驱动的安装与环境的搭建 第二部分：利用VGG16网络进行模型训练与预...
[caffe]深度学习之图像分类模型VGG解读
weixin_33814685的博客
03-23 141
一、简单介绍 vgg和googlenet是2014年imagenet竞赛的双雄，这两类模型结构有一个共同特点是go deeper。跟googlenet不同的是。vgg继承了lenet以及alexnet的一些框架。尤其是跟alexnet框架很像。vgg也是5个group的卷积、2层fc图像特征、一层fc分类特征，能够看做和alexnet一样总共8个part。依据前5个卷积group。每一个...
图像分类：Pytorch图像分类之--VGG模型
xp_fangfei的博客
04-06 990
VGG模型的详解，创新点的详解，以及程序的介绍
预训练的图像分类模型_使用预训练模型进行图像分类
cunzai1985的博客
09-22 2445
预训练的图像分类模型 使用预训练模型进行图像分类 (Image Classification Using Pre-Trained Model) Advertisements 广告 Previous Page 上一页 Next Page 下一页 In this lesson, you will learn to use a pre-trained model to...
2024年Python最全人脸检测实战进阶：使用 OpenCV 进行活体检测
2401_84691757的博客
04-30 726
input ：我们输入视频文件的路径。–output ：将存储每个裁剪面的输出目录的路径。–detector ：面部检测器的路径。我们将使用 OpenCV 的深度学习人脸检测器。为方便起见，此 Caffe 模型包含在今天的“下载”中。–confidence : 过滤弱人脸检测的最小概率。默认情况下，此值为 50%。–skip ：我们不需要检测和存储每个图像，因为相邻的帧是相似的。相反，我们将在两次检测之间跳过 N 帧。您可以使用此参数更改默认值 16。
使用自己设计的网络训练自己的图像识别模型
liupc的学习笔记
04-26 2656
一、准备数据集 点击此处返回总目录 二、制作标签 三、将图片转换为LMDB格式 四、修改网络结构文件 五、修改超参数文...
trained models for caffe
07-22
对应在caffe-master/models内各网络的训练模型，可用来对自己的数据集进行训练微调模型
VGG16_vgg16代码_VGG16_vgg16代码详解_
09-29
vgg16代码，最简单版本，容易看懂，易上手，按照论文敲的
pytorch---利用训练好的模型进行图片分类测试
小膜仙的博客
05-02 568
先参考一下这篇博客：https://www.jianshu.com/p/bf4a2082014f 我觉得可行！就应该使用softmax啊。
云上的移动性能测试平台
阿里云开发者
12-31 2234
简介：功能决定现在，性能决定未来。欢迎大家围观《云上的移动性能测试平台》， 了解EMAS性能测试平台的能力与规划。1. 功能决定现在，性能决定未来性能测试在移动测试领域一直是一个大难题，它最直观的表现是用户在前台使用 App 时的主观体验，然而决定体验优劣的背后，涉及到了许许多多的技术变迁。 当我们习惯于诺基亚时，智能机出现了；当我们学会native开发时，hybrid来了；当各种 hybrid 框架下的巨型应用倾向成熟时，小程序出现在了我们眼前；紧接着直播、iot、ar、vr、人工智能，新的技术与应用场景
基于Python的图像分类 项目实践——图像分类项目
aiqq136的博客
03-09 1万+
图像分类项目 我们有了几十张宠物的图像，这些图像的种类都在ImageNet数据集中出现过，我们需要通过CNN模型来帮我们筛选比较一遍，顺便也对模型的识别结果和识别效率进行比较。 需要做的事情： 利用 Python 技能以及调用PaddlePaddle的CNN模型判断哪个图像分类算法最适合将图像分类为“小狗”和“非小狗”图像。 需要确定最合适的分类算法在识别小狗品种时的准确率。每个图片名字使用当前认知的小狗的品种进行标记。程序只需将照片的文件名（包含品种信息）与分类算法返回的品种进行对比。找到信息一致
基于Pytorch和Vgg16实现图片分类
qq_42850516的博客
05-26 4542
最近在基于Pytorch框架补一些CNN的基础知识，学会自己写简单的卷积神经网络，从加载数据集到训练模型、测试模型、保存模型和输出测试结果，现在来总结一下。 首先基于Pytorch实现Vgg16网络，命名为model.py（可为其他任意名字，但是后续导入时要记得更改） import torch import torch.nn as nn class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init_
图像分类模型 VGG
mengxianglong123的博客
07-08 2001
2014年，牛津大学计算机视觉组（Visual Geometry Group）和Google DeepMind公司的研究员一起研发出了新的深度卷积神经网络：VGGNet，并取得了ILSVRC2014比赛分类项目的第二名，主要贡献是使用很小的卷积核(3×3)构建卷积神经网络结构，能够取得较好的识别精度，常用来提取图像特征的VGG-16和VGG-19。VGG可以看成是加深版的AlexNet，整个网络由卷积层和全连接层叠加而成，和AlexNet不同的是，VGG中使用的都是小尺寸的卷积核(3×3)，其网络架构如下图
使用Caffe进行图像分类：Python接口详解
"这篇教程是关于如何使用Caffe的Python接口进行图像分类的详细指南，主要涉及CaffeNet模型，该模型基于Krizhevsky等人在ImageNet上的网络架构。内容包括在CPU和GPU模式下运行分类，以及深入模型检查特征和输出。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值