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

最新推荐文章于 2025-05-04 14:28:11 发布
最新推荐文章于 2025-05-04 14:28:11 发布
阅读量3.8k 收藏 1
点赞数
分类专栏： caffe 文章标签： 分类 vgg16 deploy.proto python+caffe
本文介绍了一个基于VGG16网络结构的12种动物分类模型，通过修改输出层并重新训练，实现了80%的Top1准确率和95%的Top5准确率。文中提供了详细的预测流程代码及多进程批量分类实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

部分参考：http://blog.youkuaiyun.com/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
}

 

 

 

Python 人工智能实战：自动驾驶
AI天才研究院
10-21 690
自动驾驶(self-driving car)技术是通过计算机系统把现有的汽车机械结构和传感器结合起来,能够将驾驶者控制的车辆变成一个人类驾驶者可以理解的行为,而无需驾驶员自行操控的一种驾驶技术。自动驾驶系统能够精确地预测道路的情况并避免前方障碍物影响,从而安全、准确地驾驶汽车。由于自动驾驶的巨大需求和应用前景,当前已经有许多团队、研究机构和企业积极探索和开发自动驾驶系统。目前国内外的自动驾驶公司、研究机构和个人也在不断投入研发新型的自动驾驶技术。
使用Python，OpenCV，本地二进制模式（LBP）进行人脸识别
qq_40985985的博客
08-21 1904
在深度学习和暹罗网络之前，面部识别算法依赖于特征提取和机器学习。 今天，我们将涵盖最受欢迎的预学习人脸识别算法之一，用局部二进制模式（LBPS）面对脸部检测。
基于VGG16网络模型对图像进行识别分类
weixin_44879270的博客
12-20 7966
基于VGG16网络模型对图像进行识别分类 随着人工智能热潮的发展，图像识别已经成为了其中非常重要的一部分。图像识别是指计算机对图像进行处理、分析，以识别其中所含目标的类别及其位置(即目标检测和分类)的技术。其中图像分类是图像识别的一个类，是给定一幅测试图像，利用训练好的分类器判定它所属的类别。 该项目分为三部分： 第一部分：系统驱动的安装与环境的搭建 第二部分：利用VGG16网络进行模型训练与预...
caffe+python 使用训练好的VGG16模型 对 单张图片进行分类，输出置信度
热门推荐
PlusTang
10-02 2万+
网上看了一堆都是图片转lmdb格式，然后测试总的准确率，我想测试每张图片的top1，top2以及对应置信度是多少，摸索了一下午+一晚上终于搞定，期间遇到不少坑！！！同时感谢实验室博士师兄一块帮我找bug说明：数据集是上海BOT大赛的（12种动物），网上下载的vgg16权重文件，并且修改输出类别为12，对最后三层全连接网络训练了8个小时，top1准确率为80%，top5准确率95%使用的测试图片是一个
利用vgg16进行二分类资源文件介绍
最新发布
gitblog_06769的博客
05-04 639
利用vgg16进行二分类资源文件介绍 去发现同类优质开源项目:https://gitcode.com/ 文件简介 本资源文件提供了一个基于vgg16模型实现的猫狗图像二分类项目的压缩包：vgg16.zip。此模型利用了深度学习的强大能力，通过vgg16网络结构对猫狗图像进行分类。vgg16因其相较于普通卷积神经网络（CNN）具有更复杂的层结构，所以通常能够取得更优的分类效果。 特点 模型结构：采...
[caffe]深度学习之图像分类模型VGG解读
weixin_33814685的博客
03-23 173
一、简单介绍 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 1390
VGG模型的详解，创新点的详解，以及程序的介绍
pytorch---利用训练好的模型进行图片分类测试
小膜仙的博客
05-02 618
先参考一下这篇博客：https://www.jianshu.com/p/bf4a2082014f 我觉得可行！就应该使用softmax啊。
预训练的图像分类模型_使用预训练模型进行图像分类
cunzai1985的博客
09-22 2650
预训练的图像分类模型 使用预训练模型进行图像分类 (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 938
input ：我们输入视频文件的路径。–output ：将存储每个裁剪面的输出目录的路径。–detector ：面部检测器的路径。我们将使用 OpenCV 的深度学习人脸检测器。为方便起见，此 Caffe 模型包含在今天的“下载”中。–confidence : 过滤弱人脸检测的最小概率。默认情况下，此值为 50%。–skip ：我们不需要检测和存储每个图像，因为相邻的帧是相似的。相反，我们将在两次检测之间跳过 N 帧。您可以使用此参数更改默认值 16。
使用 OpenCV -6-使用 OpenCV 进行性别和年龄检测的有趣 Python 项目
P5093的博客
07-23 1327
计算机视觉是一个研究领域，它使计算机能够像人类一样查看和识别数字图像和视频。它面临的挑战很大程度上来自对生物视觉的有限理解。计算机视觉涉及获取、处理、分析和理解数字图像，以从现实世界中提取高维数据，以生成符号或数字信息，然后可用于做出决策。该过程通常包括对象识别、视频跟踪、运动估计和图像恢复等实践。OpenCV是开源计算机视觉的缩写。顾名思义，它是一个开源的计算机视觉和机器学习库。该库能够处理实时图像和视频，同时还具有分析功能。它支持深度学习框架TensorFlow、Caffe 和 PyTorch。
trained models for caffe
07-22
对应在caffe-master/models内各网络的训练模型，可用来对自己的数据集进行训练微调模型
VGG16_vgg16代码_VGG16_vgg16代码详解_
09-29
vgg16代码，最简单版本，容易看懂，易上手，按照论文敲的
云上的移动性能测试平台
阿里云开发者
12-31 2294
简介：功能决定现在，性能决定未来。欢迎大家围观《云上的移动性能测试平台》， 了解EMAS性能测试平台的能力与规划。1. 功能决定现在，性能决定未来性能测试在移动测试领域一直是一个大难题，它最直观的表现是用户在前台使用 App 时的主观体验，然而决定体验优劣的背后，涉及到了许许多多的技术变迁。 当我们习惯于诺基亚时，智能机出现了；当我们学会native开发时，hybrid来了；当各种 hybrid 框架下的巨型应用倾向成熟时，小程序出现在了我们眼前；紧接着直播、iot、ar、vr、人工智能，新的技术与应用场景
python图像处理-图片分类项目
lishuaixixi的博客
03-13 2841
目录 最近帮朋友做一个图片数据分类的项目，借鉴了大佬的代码，修修改改,话不多说直接上代码！ 一、图片转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
基于Python的图像分类 项目实践——图像分类项目
aiqq136的博客
03-09 1万+
图像分类项目 我们有了几十张宠物的图像，这些图像的种类都在ImageNet数据集中出现过，我们需要通过CNN模型来帮我们筛选比较一遍，顺便也对模型的识别结果和识别效率进行比较。 需要做的事情： 利用 Python 技能以及调用PaddlePaddle的CNN模型判断哪个图像分类算法最适合将图像分类为“小狗”和“非小狗”图像。 需要确定最合适的分类算法在识别小狗品种时的准确率。每个图片名字使用当前认知的小狗的品种进行标记。程序只需将照片的文件名（包含品种信息）与分类算法返回的品种进行对比。找到信息一致
基于Pytorch和Vgg16实现图片分类
qq_42850516的博客
05-26 4710
最近在基于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 2220
2014年，牛津大学计算机视觉组（Visual Geometry Group）和Google DeepMind公司的研究员一起研发出了新的深度卷积神经网络：VGGNet，并取得了ILSVRC2014比赛分类项目的第二名，主要贡献是使用很小的卷积核(3×3)构建卷积神经网络结构，能够取得较好的识别精度，常用来提取图像特征的VGG-16和VGG-19。VGG可以看成是加深版的AlexNet，整个网络由卷积层和全连接层叠加而成，和AlexNet不同的是，VGG中使用的都是小尺寸的卷积核(3×3)，其网络架构如下图
3测试图片显示置信度_第一张黑洞图像以新方式帮助测试了广义相对论
weixin_36046580的博客
01-02 177
事件地平线望远镜对M87黑洞的快照再次表明爱因斯坦是对的像这里显示的那样，模拟光和物质绕银河系M87中心的超大质量黑洞运动的方式，有助于物理学家确定黑洞投射在周围物质上的阴影的大小。该大小对于广义相对论的测试至关重要。梅代罗斯(L. MEDEIROS) 当黑洞的第一张图像于2019年4月发布时，它标志着阿尔伯特·爱因斯坦的引力理论或广义相对论的有力证实。该理论不仅描述了物质扭曲时空的...
怎么使用openpose预标关键点？
04-12
<think>好的，用户想了解如何使用OpenPose进行关键点预标注。首先我需要回忆一下OpenPpose的相关知识，并参考提供的资料。 根据引用[3]，用户提到需要按照OpenPose的安装步骤进行配置。虽然步骤看起来多，但实际可能不需要全部完成。可能需要先安装依赖项，比如CMake、CUDA、cuDNN等。然后，从GitHub仓库克隆代码，进行编译和安装。这部分可能需要详细说明，但用户可能更关心如何运行预训练模型进行标注。 引用[1]提到可以使用预训练的OpenPose模型，并根据任务进行微调。这里可能涉及加载模型、输入图像、获取关键点输出。同时，引用[2]指出OpenPose利用关键点之间的先验关系，比如人体部位的连接，这可能影响标注结果的结构。 接下来，用户需要具体的步骤：安装环境、下载模型、运行推理、处理输出。要确保步骤清晰，可能包括代码示例，比如Python脚本调用OpenPose库，或者使用命令行工具处理图像或视频。 另外，用户可能想知道如何处理输出数据，比如保存关键点坐标到文件，或者可视化结果。需要注意不同版本OpenPose的输出格式可能不同，可能需要调整代码。 还需要提醒用户常见问题，比如环境配置中的CUDA版本兼容性，模型路径是否正确，输入图像的尺寸要求等。如果用户需要批量处理，可能需要编写脚本自动化流程。 最后，相关问题的生成应该围绕OpenPose的优化、应用场景、与其他模型的对比等，帮助用户进一步学习。</think>### 使用 OpenPose 进行关键点预标注的方法和步骤 #### 1. **环境配置** - **安装依赖项** 需要 CUDA、cuDNN（GPU 加速）、CMake、Python 等基础环境支持。 ```bash # 示例：Ubuntu 系统安装基础依赖 sudo apt-get install build-essential cmake libopencv-dev ``` - **克隆 OpenPose 仓库** ```bash git clone https://github.com/CMU-Perceptual-Computing-Lab/openpose.git cd openpose ``` - **编译安装** 根据官方文档选择是否启用 GPU 支持，编译完成后生成可执行文件[^3]。 #### 2. **模型下载与准备** - 下载预训练的人体关键点检测模型（通常包含在 OpenPose 的 `models` 目录中）。 - 模型文件包括：`pose_iter_440000.caffemodel`（权重文件）和 `pose_deploy.prototxt`（网络结构文件）。 #### 3. **关键点检测与标注** - **命令行直接运行** 对单张图像或视频进行关键点检测： ```bash ./build/examples/openpose/openpose.bin --image_dir /path/to/images --write_json /output/json_dir ``` 参数说明： - `--image_dir`：输入图像目录 - `--write_json`：输出关键点坐标的 JSON 文件路径 - `--display 0`：关闭实时预览以提升速度 - **Python API 调用** 通过 Python 脚本批量处理： ```python from openpose import pyopenpose as op params = { "model_folder": "models/", "net_resolution": "368x368", "write_json": "output_json/" } opWrapper = op.WrapperPython() opWrapper.configure(params) opWrapper.execute() ``` #### 4. **结果解析与可视化** - **JSON 文件格式** 关键点坐标以 `[x, y, confidence]` 形式存储，按人体部位索引排列（如 0:鼻子，1:颈部等）。 - **可视化标注结果** 使用 OpenCV 绘制关键点和骨骼连接： ```python import cv2 image = cv2.imread("input.jpg") for keypoint in keypoints: x, y, conf = keypoint if conf > 0.2: # 过滤低置信度点 cv2.circle(image, (int(x), int(y)), 3, (0,255,0), -1) cv2.imwrite("output.jpg", image) ``` #### 5. **微调与优化（可选）** - 若需适配特定场景（如动物姿态），可通过修改网络结构或调整损失函数进行模型微调[^1]。 - 调整参数如 `net_resolution` 平衡速度与精度。 --- ### 注意事项 1. **硬件要求**：GPU 可显著加速推理过程（推荐 NVIDIA 显卡）。 2. **输入格式**：支持图像（JPG/PNG）、视频、甚至实时摄像头输入。 3. **输出扩展**：JSON 文件可直接用于训练其他模型（如动作识别、姿态分类）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值