mirror of
https://github.com/opencv/opencv.git
synced 2024-11-27 20:50:25 +08:00
Unite deep learning image classification samples
This commit is contained in:
Dmitry Kurtaev
parent
e8d94ea87c
commit
8e4fe30db6
1
samples/data/dnn/.gitignore
vendored
1
samples/data/dnn/.gitignore
vendored
@ -1 +0,0 @@
|
||||
*.caffemodel
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,20 +0,0 @@
|
||||
Unlabeled 0 0 0
|
||||
Road 128 64 128
|
||||
Sidewalk 244 35 232
|
||||
Building 70 70 70
|
||||
Wall 102 102 156
|
||||
Fence 190 153 153
|
||||
Pole 153 153 153
|
||||
TrafficLight 250 170 30
|
||||
TrafficSign 220 220 0
|
||||
Vegetation 107 142 35
|
||||
Terrain 152 251 152
|
||||
Sky 70 130 180
|
||||
Person 220 20 60
|
||||
Rider 255 0 0
|
||||
Car 0 0 142
|
||||
Truck 0 0 70
|
||||
Bus 0 60 100
|
||||
Train 0 80 100
|
||||
Motorcycle 0 0 230
|
||||
Bicycle 119 11 32
|
||||
@ -1,502 +0,0 @@
|
||||
#
|
||||
# This prototxt is based on voc-fcn32s/val.prototxt file from
|
||||
# https://github.com/shelhamer/fcn.berkeleyvision.org, which is distributed under
|
||||
# Caffe (BSD) license:
|
||||
# http://caffe.berkeleyvision.org/model_zoo.html#bvlc-model-license
|
||||
#
|
||||
name: "voc-fcn32s"
|
||||
input: "data"
|
||||
input_dim: 1
|
||||
input_dim: 3
|
||||
input_dim: 500
|
||||
input_dim: 500
|
||||
layer {
|
||||
name: "conv1_1"
|
||||
type: "Convolution"
|
||||
bottom: "data"
|
||||
top: "conv1_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 64
|
||||
pad: 100
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu1_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv1_1"
|
||||
top: "conv1_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv1_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv1_1"
|
||||
top: "conv1_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 64
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu1_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv1_2"
|
||||
top: "conv1_2"
|
||||
}
|
||||
layer {
|
||||
name: "pool1"
|
||||
type: "Pooling"
|
||||
bottom: "conv1_2"
|
||||
top: "pool1"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv2_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool1"
|
||||
top: "conv2_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 128
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu2_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv2_1"
|
||||
top: "conv2_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv2_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv2_1"
|
||||
top: "conv2_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 128
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu2_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv2_2"
|
||||
top: "conv2_2"
|
||||
}
|
||||
layer {
|
||||
name: "pool2"
|
||||
type: "Pooling"
|
||||
bottom: "conv2_2"
|
||||
top: "pool2"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv3_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool2"
|
||||
top: "conv3_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 256
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu3_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv3_1"
|
||||
top: "conv3_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv3_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv3_1"
|
||||
top: "conv3_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 256
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu3_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv3_2"
|
||||
top: "conv3_2"
|
||||
}
|
||||
layer {
|
||||
name: "conv3_3"
|
||||
type: "Convolution"
|
||||
bottom: "conv3_2"
|
||||
top: "conv3_3"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 256
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu3_3"
|
||||
type: "ReLU"
|
||||
bottom: "conv3_3"
|
||||
top: "conv3_3"
|
||||
}
|
||||
layer {
|
||||
name: "pool3"
|
||||
type: "Pooling"
|
||||
bottom: "conv3_3"
|
||||
top: "pool3"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv4_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool3"
|
||||
top: "conv4_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu4_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv4_1"
|
||||
top: "conv4_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv4_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv4_1"
|
||||
top: "conv4_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu4_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv4_2"
|
||||
top: "conv4_2"
|
||||
}
|
||||
layer {
|
||||
name: "conv4_3"
|
||||
type: "Convolution"
|
||||
bottom: "conv4_2"
|
||||
top: "conv4_3"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu4_3"
|
||||
type: "ReLU"
|
||||
bottom: "conv4_3"
|
||||
top: "conv4_3"
|
||||
}
|
||||
layer {
|
||||
name: "pool4"
|
||||
type: "Pooling"
|
||||
bottom: "conv4_3"
|
||||
top: "pool4"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv5_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool4"
|
||||
top: "conv5_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu5_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv5_1"
|
||||
top: "conv5_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv5_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv5_1"
|
||||
top: "conv5_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu5_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv5_2"
|
||||
top: "conv5_2"
|
||||
}
|
||||
layer {
|
||||
name: "conv5_3"
|
||||
type: "Convolution"
|
||||
bottom: "conv5_2"
|
||||
top: "conv5_3"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu5_3"
|
||||
type: "ReLU"
|
||||
bottom: "conv5_3"
|
||||
top: "conv5_3"
|
||||
}
|
||||
layer {
|
||||
name: "pool5"
|
||||
type: "Pooling"
|
||||
bottom: "conv5_3"
|
||||
top: "pool5"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "fc6"
|
||||
type: "Convolution"
|
||||
bottom: "pool5"
|
||||
top: "fc6"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 4096
|
||||
pad: 0
|
||||
kernel_size: 7
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu6"
|
||||
type: "ReLU"
|
||||
bottom: "fc6"
|
||||
top: "fc6"
|
||||
}
|
||||
layer {
|
||||
name: "fc7"
|
||||
type: "Convolution"
|
||||
bottom: "fc6"
|
||||
top: "fc7"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 4096
|
||||
pad: 0
|
||||
kernel_size: 1
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu7"
|
||||
type: "ReLU"
|
||||
bottom: "fc7"
|
||||
top: "fc7"
|
||||
}
|
||||
layer {
|
||||
name: "score_fr"
|
||||
type: "Convolution"
|
||||
bottom: "fc7"
|
||||
top: "score_fr"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
pad: 0
|
||||
kernel_size: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "upscore"
|
||||
type: "Deconvolution"
|
||||
bottom: "score_fr"
|
||||
top: "upscore"
|
||||
param {
|
||||
lr_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
bias_term: false
|
||||
kernel_size: 64
|
||||
stride: 32
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "score"
|
||||
type: "Crop"
|
||||
bottom: "upscore"
|
||||
bottom: "data"
|
||||
top: "score"
|
||||
crop_param {
|
||||
axis: 2
|
||||
offset: 19
|
||||
}
|
||||
}
|
||||
@ -1,612 +0,0 @@
|
||||
#
|
||||
# This prototxt is based on voc-fcn8s/val.prototxt file from
|
||||
# https://github.com/shelhamer/fcn.berkeleyvision.org, which is distributed under
|
||||
# Caffe (BSD) license:
|
||||
# http://caffe.berkeleyvision.org/model_zoo.html#bvlc-model-license
|
||||
#
|
||||
name: "voc-fcn8s"
|
||||
input: "data"
|
||||
input_dim: 1
|
||||
input_dim: 3
|
||||
input_dim: 500
|
||||
input_dim: 500
|
||||
layer {
|
||||
name: "conv1_1"
|
||||
type: "Convolution"
|
||||
bottom: "data"
|
||||
top: "conv1_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 64
|
||||
pad: 100
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu1_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv1_1"
|
||||
top: "conv1_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv1_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv1_1"
|
||||
top: "conv1_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 64
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu1_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv1_2"
|
||||
top: "conv1_2"
|
||||
}
|
||||
layer {
|
||||
name: "pool1"
|
||||
type: "Pooling"
|
||||
bottom: "conv1_2"
|
||||
top: "pool1"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv2_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool1"
|
||||
top: "conv2_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 128
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu2_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv2_1"
|
||||
top: "conv2_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv2_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv2_1"
|
||||
top: "conv2_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 128
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu2_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv2_2"
|
||||
top: "conv2_2"
|
||||
}
|
||||
layer {
|
||||
name: "pool2"
|
||||
type: "Pooling"
|
||||
bottom: "conv2_2"
|
||||
top: "pool2"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv3_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool2"
|
||||
top: "conv3_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 256
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu3_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv3_1"
|
||||
top: "conv3_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv3_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv3_1"
|
||||
top: "conv3_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 256
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu3_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv3_2"
|
||||
top: "conv3_2"
|
||||
}
|
||||
layer {
|
||||
name: "conv3_3"
|
||||
type: "Convolution"
|
||||
bottom: "conv3_2"
|
||||
top: "conv3_3"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 256
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu3_3"
|
||||
type: "ReLU"
|
||||
bottom: "conv3_3"
|
||||
top: "conv3_3"
|
||||
}
|
||||
layer {
|
||||
name: "pool3"
|
||||
type: "Pooling"
|
||||
bottom: "conv3_3"
|
||||
top: "pool3"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv4_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool3"
|
||||
top: "conv4_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu4_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv4_1"
|
||||
top: "conv4_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv4_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv4_1"
|
||||
top: "conv4_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu4_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv4_2"
|
||||
top: "conv4_2"
|
||||
}
|
||||
layer {
|
||||
name: "conv4_3"
|
||||
type: "Convolution"
|
||||
bottom: "conv4_2"
|
||||
top: "conv4_3"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu4_3"
|
||||
type: "ReLU"
|
||||
bottom: "conv4_3"
|
||||
top: "conv4_3"
|
||||
}
|
||||
layer {
|
||||
name: "pool4"
|
||||
type: "Pooling"
|
||||
bottom: "conv4_3"
|
||||
top: "pool4"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "conv5_1"
|
||||
type: "Convolution"
|
||||
bottom: "pool4"
|
||||
top: "conv5_1"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu5_1"
|
||||
type: "ReLU"
|
||||
bottom: "conv5_1"
|
||||
top: "conv5_1"
|
||||
}
|
||||
layer {
|
||||
name: "conv5_2"
|
||||
type: "Convolution"
|
||||
bottom: "conv5_1"
|
||||
top: "conv5_2"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu5_2"
|
||||
type: "ReLU"
|
||||
bottom: "conv5_2"
|
||||
top: "conv5_2"
|
||||
}
|
||||
layer {
|
||||
name: "conv5_3"
|
||||
type: "Convolution"
|
||||
bottom: "conv5_2"
|
||||
top: "conv5_3"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 512
|
||||
pad: 1
|
||||
kernel_size: 3
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu5_3"
|
||||
type: "ReLU"
|
||||
bottom: "conv5_3"
|
||||
top: "conv5_3"
|
||||
}
|
||||
layer {
|
||||
name: "pool5"
|
||||
type: "Pooling"
|
||||
bottom: "conv5_3"
|
||||
top: "pool5"
|
||||
pooling_param {
|
||||
pool: MAX
|
||||
kernel_size: 2
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "fc6"
|
||||
type: "Convolution"
|
||||
bottom: "pool5"
|
||||
top: "fc6"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 4096
|
||||
pad: 0
|
||||
kernel_size: 7
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu6"
|
||||
type: "ReLU"
|
||||
bottom: "fc6"
|
||||
top: "fc6"
|
||||
}
|
||||
layer {
|
||||
name: "fc7"
|
||||
type: "Convolution"
|
||||
bottom: "fc6"
|
||||
top: "fc7"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 4096
|
||||
pad: 0
|
||||
kernel_size: 1
|
||||
stride: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "relu7"
|
||||
type: "ReLU"
|
||||
bottom: "fc7"
|
||||
top: "fc7"
|
||||
}
|
||||
layer {
|
||||
name: "score_fr"
|
||||
type: "Convolution"
|
||||
bottom: "fc7"
|
||||
top: "score_fr"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
pad: 0
|
||||
kernel_size: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "upscore2"
|
||||
type: "Deconvolution"
|
||||
bottom: "score_fr"
|
||||
top: "upscore2"
|
||||
param {
|
||||
lr_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
bias_term: false
|
||||
kernel_size: 4
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "score_pool4"
|
||||
type: "Convolution"
|
||||
bottom: "pool4"
|
||||
top: "score_pool4"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
pad: 0
|
||||
kernel_size: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "score_pool4c"
|
||||
type: "Crop"
|
||||
bottom: "score_pool4"
|
||||
bottom: "upscore2"
|
||||
top: "score_pool4c"
|
||||
crop_param {
|
||||
axis: 2
|
||||
offset: 5
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "fuse_pool4"
|
||||
type: "Eltwise"
|
||||
bottom: "upscore2"
|
||||
bottom: "score_pool4c"
|
||||
top: "fuse_pool4"
|
||||
eltwise_param {
|
||||
operation: SUM
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "upscore_pool4"
|
||||
type: "Deconvolution"
|
||||
bottom: "fuse_pool4"
|
||||
top: "upscore_pool4"
|
||||
param {
|
||||
lr_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
bias_term: false
|
||||
kernel_size: 4
|
||||
stride: 2
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "score_pool3"
|
||||
type: "Convolution"
|
||||
bottom: "pool3"
|
||||
top: "score_pool3"
|
||||
param {
|
||||
lr_mult: 1
|
||||
decay_mult: 1
|
||||
}
|
||||
param {
|
||||
lr_mult: 2
|
||||
decay_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
pad: 0
|
||||
kernel_size: 1
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "score_pool3c"
|
||||
type: "Crop"
|
||||
bottom: "score_pool3"
|
||||
bottom: "upscore_pool4"
|
||||
top: "score_pool3c"
|
||||
crop_param {
|
||||
axis: 2
|
||||
offset: 9
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "fuse_pool3"
|
||||
type: "Eltwise"
|
||||
bottom: "upscore_pool4"
|
||||
bottom: "score_pool3c"
|
||||
top: "fuse_pool3"
|
||||
eltwise_param {
|
||||
operation: SUM
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "upscore8"
|
||||
type: "Deconvolution"
|
||||
bottom: "fuse_pool3"
|
||||
top: "upscore8"
|
||||
param {
|
||||
lr_mult: 0
|
||||
}
|
||||
convolution_param {
|
||||
num_output: 21
|
||||
bias_term: false
|
||||
kernel_size: 16
|
||||
stride: 8
|
||||
}
|
||||
}
|
||||
layer {
|
||||
name: "score"
|
||||
type: "Crop"
|
||||
bottom: "upscore8"
|
||||
bottom: "data"
|
||||
top: "score"
|
||||
crop_param {
|
||||
axis: 2
|
||||
offset: 31
|
||||
}
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
background 0 0 0
|
||||
aeroplane 128 0 0
|
||||
bicycle 0 128 0
|
||||
bird 128 128 0
|
||||
boat 0 0 128
|
||||
bottle 128 0 128
|
||||
bus 0 128 128
|
||||
car 128 128 128
|
||||
cat 64 0 0
|
||||
chair 192 0 0
|
||||
cow 64 128 0
|
||||
diningtable 192 128 0
|
||||
dog 64 0 128
|
||||
horse 192 0 128
|
||||
motorbike 64 128 128
|
||||
person 192 128 128
|
||||
pottedplant 0 64 0
|
||||
sheep 128 64 0
|
||||
sofa 0 192 0
|
||||
train 128 192 0
|
||||
tvmonitor 0 64 128
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 46 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 27 KiB |
File diff suppressed because it is too large
Load Diff
@ -14,6 +14,14 @@
|
||||
| [Faster-RCNN](https://github.com/rbgirshick/py-faster-rcnn) | `1.0` | `800x600` | `102.9801, 115.9465, 122.7717` | BGR |
|
||||
| [R-FCN](https://github.com/YuwenXiong/py-R-FCN) | `1.0` | `800x600` | `102.9801 115.9465 122.7717` | BGR |
|
||||
|
||||
|
||||
### Classification
|
||||
| Model | Scale | Size WxH| Mean subtraction | Channels order |
|
||||
|---------------|-------|-----------|--------------------|-------|
|
||||
| GoogLeNet | `1.0` | `224x224` | `104 117 123` | BGR |
|
||||
| [SqueezeNet](https://github.com/DeepScale/SqueezeNet) | `1.0` | `227x227` | `0 0 0` | BGR |
|
||||
|
||||
|
||||
## References
|
||||
* [Models downloading script](https://github.com/opencv/opencv_extra/blob/master/testdata/dnn/download_models.py)
|
||||
* [Configuration files adopted for OpenCV](https://github.com/opencv/opencv_extra/tree/master/testdata/dnn)
|
||||
|
||||
@ -1,181 +0,0 @@
|
||||
/**M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
#include <opencv2/dnn.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/core/utils/trace.hpp>
|
||||
using namespace cv;
|
||||
using namespace cv::dnn;
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
using namespace std;
|
||||
|
||||
/* Find best class for the blob (i. e. class with maximal probability) */
|
||||
static void getMaxClass(const Mat &probBlob, int *classId, double *classProb)
|
||||
{
|
||||
Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix
|
||||
Point classNumber;
|
||||
|
||||
minMaxLoc(probMat, NULL, classProb, NULL, &classNumber);
|
||||
*classId = classNumber.x;
|
||||
}
|
||||
|
||||
static std::vector<String> readClassNames(const char *filename )
|
||||
{
|
||||
std::vector<String> classNames;
|
||||
|
||||
std::ifstream fp(filename);
|
||||
if (!fp.is_open())
|
||||
{
|
||||
std::cerr << "File with classes labels not found: " << filename << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
std::string name;
|
||||
while (!fp.eof())
|
||||
{
|
||||
std::getline(fp, name);
|
||||
if (name.length())
|
||||
classNames.push_back( name.substr(name.find(' ')+1) );
|
||||
}
|
||||
|
||||
fp.close();
|
||||
return classNames;
|
||||
}
|
||||
|
||||
const char* params
|
||||
= "{ help | false | Sample app for loading googlenet model }"
|
||||
"{ proto | bvlc_googlenet.prototxt | model configuration }"
|
||||
"{ model | bvlc_googlenet.caffemodel | model weights }"
|
||||
"{ label | synset_words.txt | names of ILSVRC2012 classes }"
|
||||
"{ image | space_shuttle.jpg | path to image file }"
|
||||
"{ opencl | false | enable OpenCL }"
|
||||
;
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
CV_TRACE_FUNCTION();
|
||||
|
||||
CommandLineParser parser(argc, argv, params);
|
||||
|
||||
if (parser.get<bool>("help"))
|
||||
{
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
String modelTxt = parser.get<string>("proto");
|
||||
String modelBin = parser.get<string>("model");
|
||||
String imageFile = parser.get<String>("image");
|
||||
String classNameFile = parser.get<String>("label");
|
||||
|
||||
Net net;
|
||||
try {
|
||||
//! [Read and initialize network]
|
||||
net = dnn::readNetFromCaffe(modelTxt, modelBin);
|
||||
//! [Read and initialize network]
|
||||
}
|
||||
catch (const cv::Exception& e) {
|
||||
std::cerr << "Exception: " << e.what() << std::endl;
|
||||
//! [Check that network was read successfully]
|
||||
if (net.empty())
|
||||
{
|
||||
std::cerr << "Can't load network by using the following files: " << std::endl;
|
||||
std::cerr << "prototxt: " << modelTxt << std::endl;
|
||||
std::cerr << "caffemodel: " << modelBin << std::endl;
|
||||
std::cerr << "bvlc_googlenet.caffemodel can be downloaded here:" << std::endl;
|
||||
std::cerr << "http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel" << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
//! [Check that network was read successfully]
|
||||
}
|
||||
|
||||
if (parser.get<bool>("opencl"))
|
||||
{
|
||||
net.setPreferableTarget(DNN_TARGET_OPENCL);
|
||||
}
|
||||
|
||||
//! [Prepare blob]
|
||||
Mat img = imread(imageFile);
|
||||
if (img.empty())
|
||||
{
|
||||
std::cerr << "Can't read image from the file: " << imageFile << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
//GoogLeNet accepts only 224x224 BGR-images
|
||||
Mat inputBlob = blobFromImage(img, 1.0f, Size(224, 224),
|
||||
Scalar(104, 117, 123), false); //Convert Mat to batch of images
|
||||
//! [Prepare blob]
|
||||
net.setInput(inputBlob, "data"); //set the network input
|
||||
Mat prob = net.forward("prob"); //compute output
|
||||
|
||||
cv::TickMeter t;
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
CV_TRACE_REGION("forward");
|
||||
//! [Set input blob]
|
||||
net.setInput(inputBlob, "data"); //set the network input
|
||||
//! [Set input blob]
|
||||
t.start();
|
||||
//! [Make forward pass]
|
||||
prob = net.forward("prob"); //compute output
|
||||
//! [Make forward pass]
|
||||
t.stop();
|
||||
}
|
||||
|
||||
//! [Gather output]
|
||||
int classId;
|
||||
double classProb;
|
||||
getMaxClass(prob, &classId, &classProb);//find the best class
|
||||
//! [Gather output]
|
||||
|
||||
//! [Print results]
|
||||
std::vector<String> classNames = readClassNames(classNameFile.c_str());
|
||||
std::cout << "Best class: #" << classId << " '" << classNames.at(classId) << "'" << std::endl;
|
||||
std::cout << "Probability: " << classProb * 100 << "%" << std::endl;
|
||||
//! [Print results]
|
||||
std::cout << "Time: " << (double)t.getTimeMilli() / t.getCounter() << " ms (average from " << t.getCounter() << " iterations)" << std::endl;
|
||||
|
||||
return 0;
|
||||
} //main
|
||||
153
samples/dnn/classification.cpp
Normal file
153
samples/dnn/classification.cpp
Normal file
@ -0,0 +1,153 @@
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <opencv2/dnn.hpp>
|
||||
|
||||
const char* keys =
|
||||
"{ help h | | Print help message. }"
|
||||
"{ input i | | Path to input image or video file. Skip this argument to capture frames from a camera.}"
|
||||
"{ model m | | Path to a binary file of model contains trained weights. "
|
||||
"It could be a file with extensions .caffemodel (Caffe), "
|
||||
".pb (TensorFlow), .t7 or .net (Torch), .weights (Darknet) }"
|
||||
"{ config c | | Path to a text file of model contains network configuration. "
|
||||
"It could be a file with extensions .prototxt (Caffe), .pbtxt (TensorFlow), .cfg (Darknet) }"
|
||||
"{ framework f | | Optional name of an origin framework of the model. Detect it automatically if it does not set. }"
|
||||
"{ classes | | Optional path to a text file with names of classes. }"
|
||||
"{ mean | | Preprocess input image by subtracting mean values. Mean values should be in BGR order and delimited by spaces. }"
|
||||
"{ scale | 1 | Preprocess input image by multiplying on a scale factor. }"
|
||||
"{ width | -1 | Preprocess input image by resizing to a specific width. }"
|
||||
"{ height | -1 | Preprocess input image by resizing to a specific height. }"
|
||||
"{ rgb | | Indicate that model works with RGB input images instead BGR ones. }"
|
||||
"{ backend | 0 | Choose one of computation backends: "
|
||||
"0: default C++ backend, "
|
||||
"1: Halide language (http://halide-lang.org/), "
|
||||
"2: Intel's Deep Learning Inference Engine (https://software.seek.intel.com/deep-learning-deployment)}"
|
||||
"{ target | 0 | Choose one of target computation devices: "
|
||||
"0: CPU target (by default),"
|
||||
"1: OpenCL }";
|
||||
|
||||
using namespace cv;
|
||||
using namespace dnn;
|
||||
|
||||
std::vector<std::string> classes;
|
||||
|
||||
Net readNet(const std::string& model, const std::string& config = "", const std::string& framework = "");
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about("Use this script to run classification deep learning networks using OpenCV.");
|
||||
if (argc == 1 || parser.has("help"))
|
||||
{
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
float scale = parser.get<float>("scale");
|
||||
bool swapRB = parser.get<bool>("rgb");
|
||||
int inpWidth = parser.get<int>("width");
|
||||
int inpHeight = parser.get<int>("height");
|
||||
|
||||
// Parse mean values.
|
||||
Scalar mean;
|
||||
if (parser.has("mean"))
|
||||
{
|
||||
std::istringstream meanStr(parser.get<String>("mean"));
|
||||
std::vector<float> meanValues;
|
||||
float val;
|
||||
while (meanStr >> val)
|
||||
meanValues.push_back(val);
|
||||
CV_Assert(meanValues.size() == 3);
|
||||
mean = Scalar(meanValues[0], meanValues[1], meanValues[2]);
|
||||
}
|
||||
|
||||
// Open file with classes names.
|
||||
if (parser.has("classes"))
|
||||
{
|
||||
std::string file = parser.get<String>("classes");
|
||||
std::ifstream ifs(file.c_str());
|
||||
if (!ifs.is_open())
|
||||
CV_Error(Error::StsError, "File " + file + " not found");
|
||||
std::string line;
|
||||
while (std::getline(ifs, line))
|
||||
{
|
||||
classes.push_back(line);
|
||||
}
|
||||
}
|
||||
|
||||
// Load a model.
|
||||
CV_Assert(parser.has("model"));
|
||||
Net net = readNet(parser.get<String>("model"), parser.get<String>("config"), parser.get<String>("framework"));
|
||||
net.setPreferableBackend(parser.get<int>("backend"));
|
||||
net.setPreferableTarget(parser.get<int>("target"));
|
||||
|
||||
// Create a window
|
||||
static const std::string kWinName = "Deep learning image classification in OpenCV";
|
||||
namedWindow(kWinName, WINDOW_NORMAL);
|
||||
|
||||
// Open a video file or an image file or a camera stream.
|
||||
VideoCapture cap;
|
||||
if (parser.has("input"))
|
||||
cap.open(parser.get<String>("input"));
|
||||
else
|
||||
cap.open(0);
|
||||
|
||||
// Process frames.
|
||||
Mat frame, blob;
|
||||
while (waitKey(1) < 0)
|
||||
{
|
||||
cap >> frame;
|
||||
if (frame.empty())
|
||||
{
|
||||
waitKey();
|
||||
break;
|
||||
}
|
||||
|
||||
// Create a 4D blob from a frame.
|
||||
blobFromImage(frame, blob, scale, Size(inpWidth, inpHeight), mean, swapRB, false);
|
||||
|
||||
// Run a model.
|
||||
net.setInput(blob);
|
||||
Mat out = net.forward();
|
||||
out = out.reshape(1, 1);
|
||||
|
||||
// Get a class with a highest score.
|
||||
Point classIdPoint;
|
||||
double confidence;
|
||||
minMaxLoc(out, 0, &confidence, 0, &classIdPoint);
|
||||
int classId = classIdPoint.x;
|
||||
|
||||
// Put efficiency information.
|
||||
std::vector<double> layersTimes;
|
||||
double t = net.getPerfProfile(layersTimes);
|
||||
std::string label = format("Inference time: %.2f", t * 1000 / getTickFrequency());
|
||||
putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
|
||||
|
||||
// Print predicted class.
|
||||
label = format("%s: %.4f", (classes.empty() ? format("Class #%d", classId).c_str() :
|
||||
classes[classId].c_str()),
|
||||
confidence);
|
||||
putText(frame, label, Point(0, 40), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
|
||||
|
||||
imshow(kWinName, frame);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
Net readNet(const std::string& model, const std::string& config, const std::string& framework)
|
||||
{
|
||||
std::string modelExt = model.substr(model.rfind('.'));
|
||||
if (framework == "caffe" || modelExt == ".caffemodel")
|
||||
return readNetFromCaffe(config, model);
|
||||
else if (framework == "tensorflow" || modelExt == ".pb")
|
||||
return readNetFromTensorflow(model, config);
|
||||
else if (framework == "torch" || modelExt == ".t7" || modelExt == ".net")
|
||||
return readNetFromTorch(model);
|
||||
else if (framework == "darknet" || modelExt == ".weights")
|
||||
return readNetFromDarknet(config, model);
|
||||
else
|
||||
CV_Error(Error::StsError, "Cannot determine an origin framework of model from file " + model);
|
||||
return Net();
|
||||
}
|
||||
98
samples/dnn/classification.py
Normal file
98
samples/dnn/classification.py
Normal file
@ -0,0 +1,98 @@
|
||||
import cv2 as cv
|
||||
import argparse
|
||||
import numpy as np
|
||||
import sys
|
||||
|
||||
backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_HALIDE, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
|
||||
targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL)
|
||||
|
||||
parser = argparse.ArgumentParser(description='Use this script to run classification deep learning networks using OpenCV.')
|
||||
parser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.')
|
||||
parser.add_argument('--model', required=True,
|
||||
help='Path to a binary file of model contains trained weights. '
|
||||
'It could be a file with extensions .caffemodel (Caffe), '
|
||||
'.pb (TensorFlow), .t7 or .net (Torch), .weights (Darknet)')
|
||||
parser.add_argument('--config',
|
||||
help='Path to a text file of model contains network configuration. '
|
||||
'It could be a file with extensions .prototxt (Caffe), .pbtxt (TensorFlow), .cfg (Darknet)')
|
||||
parser.add_argument('--framework', choices=['caffe', 'tensorflow', 'torch', 'darknet'],
|
||||
help='Optional name of an origin framework of the model. '
|
||||
'Detect it automatically if it does not set.')
|
||||
parser.add_argument('--classes', help='Optional path to a text file with names of classes.')
|
||||
parser.add_argument('--mean', nargs='+', type=float, default=[0, 0, 0],
|
||||
help='Preprocess input image by subtracting mean values. '
|
||||
'Mean values should be in BGR order.')
|
||||
parser.add_argument('--scale', type=float, default=1.0,
|
||||
help='Preprocess input image by multiplying on a scale factor.')
|
||||
parser.add_argument('--width', type=int, required=True,
|
||||
help='Preprocess input image by resizing to a specific width.')
|
||||
parser.add_argument('--height', type=int, required=True,
|
||||
help='Preprocess input image by resizing to a specific height.')
|
||||
parser.add_argument('--rgb', action='store_true',
|
||||
help='Indicate that model works with RGB input images instead BGR ones.')
|
||||
parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
|
||||
help="Choose one of computation backends: "
|
||||
"%d: default C++ backend, "
|
||||
"%d: Halide language (http://halide-lang.org/), "
|
||||
"%d: Intel's Deep Learning Inference Engine (https://software.seek.intel.com/deep-learning-deployment)" % backends)
|
||||
parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
|
||||
help='Choose one of target computation devices: '
|
||||
'%d: CPU target (by default), '
|
||||
'%d: OpenCL' % targets)
|
||||
args = parser.parse_args()
|
||||
|
||||
# Load names of classes
|
||||
classes = None
|
||||
if args.classes:
|
||||
with open(args.classes, 'rt') as f:
|
||||
classes = f.read().rstrip('\n').split('\n')
|
||||
|
||||
# Load a network
|
||||
modelExt = args.model[args.model.rfind('.'):]
|
||||
if args.framework == 'caffe' or modelExt == '.caffemodel':
|
||||
net = cv.dnn.readNetFromCaffe(args.config, args.model)
|
||||
elif args.framework == 'tensorflow' or modelExt == '.pb':
|
||||
net = cv.dnn.readNetFromTensorflow(args.model, args.config)
|
||||
elif args.framework == 'torch' or modelExt in ['.t7', '.net']:
|
||||
net = cv.dnn.readNetFromTorch(args.model)
|
||||
elif args.framework == 'darknet' or modelExt == '.weights':
|
||||
net = cv.dnn.readNetFromDarknet(args.config, args.model)
|
||||
else:
|
||||
print('Cannot determine an origin framework of model from file %s' % args.model)
|
||||
sys.exit(0)
|
||||
|
||||
net.setPreferableBackend(args.backend)
|
||||
net.setPreferableTarget(args.target)
|
||||
|
||||
winName = 'Deep learning image classification in OpenCV'
|
||||
cv.namedWindow(winName, cv.WINDOW_NORMAL)
|
||||
|
||||
cap = cv.VideoCapture(args.input if args.input else 0)
|
||||
while cv.waitKey(1) < 0:
|
||||
hasFrame, frame = cap.read()
|
||||
if not hasFrame:
|
||||
cv.waitKey()
|
||||
break
|
||||
|
||||
# Create a 4D blob from a frame.
|
||||
blob = cv.dnn.blobFromImage(frame, args.scale, (args.width, args.height), args.mean, args.rgb, crop=False)
|
||||
|
||||
# Run a model
|
||||
net.setInput(blob)
|
||||
out = net.forward()
|
||||
|
||||
# Get a class with a highest score.
|
||||
out = out.flatten()
|
||||
classId = np.argmax(out)
|
||||
confidence = out[classId]
|
||||
|
||||
# Put efficiency information.
|
||||
t, _ = net.getPerfProfile()
|
||||
label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())
|
||||
cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
|
||||
|
||||
# Print predicted class.
|
||||
label = '%s: %.4f' % (classes[classId] if classes else 'Class #%d' % classId, confidence)
|
||||
cv.putText(frame, label, (0, 40), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
|
||||
|
||||
cv.imshow(winName, frame)
|
||||
1000
samples/dnn/classification_classes_ILSVRC2012.txt
Normal file
1000
samples/dnn/classification_classes_ILSVRC2012.txt
Normal file
File diff suppressed because it is too large
Load Diff
@ -1,24 +0,0 @@
|
||||
from __future__ import print_function
|
||||
import numpy as np
|
||||
import cv2 as cv
|
||||
from cv2 import dnn
|
||||
import timeit
|
||||
|
||||
def timeit_forward(net):
|
||||
print("Runtime:", timeit.timeit(lambda: net.forward(), number=10))
|
||||
|
||||
def get_class_list():
|
||||
with open('synset_words.txt', 'rt') as f:
|
||||
return [x[x.find(" ") + 1:] for x in f]
|
||||
|
||||
blob = dnn.blobFromImage(cv.imread('space_shuttle.jpg'), 1, (224, 224), (104, 117, 123), False)
|
||||
print("Input:", blob.shape, blob.dtype)
|
||||
|
||||
net = dnn.readNetFromCaffe('bvlc_googlenet.prototxt', 'bvlc_googlenet.caffemodel')
|
||||
net.setInput(blob)
|
||||
prob = net.forward()
|
||||
#timeit_forward(net) #Uncomment to check performance
|
||||
|
||||
print("Output:", prob.shape, prob.dtype)
|
||||
classes = get_class_list()
|
||||
print("Best match", classes[prob.argmax()])
|
||||
@ -1,8 +1,10 @@
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <opencv2/dnn.hpp>
|
||||
|
||||
const char* keys =
|
||||
"{ help h | | Print help message. }"
|
||||
"{ input i | | Path to input image or video file. Skip this argument to capture frames from a camera.}"
|
||||
@ -19,7 +21,13 @@ const char* keys =
|
||||
"{ height | -1 | Preprocess input image by resizing to a specific height. }"
|
||||
"{ rgb | | Indicate that model works with RGB input images instead BGR ones. }"
|
||||
"{ thr | .5 | Confidence threshold. }"
|
||||
"{ opencl | | Enable OpenCL }";
|
||||
"{ backend | 0 | Choose one of computation backends: "
|
||||
"0: default C++ backend, "
|
||||
"1: Halide language (http://halide-lang.org/), "
|
||||
"2: Intel's Deep Learning Inference Engine (https://software.seek.intel.com/deep-learning-deployment)}"
|
||||
"{ target | 0 | Choose one of target computation devices: "
|
||||
"0: CPU target (by default),"
|
||||
"1: OpenCL }";
|
||||
|
||||
using namespace cv;
|
||||
using namespace dnn;
|
||||
@ -27,8 +35,6 @@ using namespace dnn;
|
||||
float confThreshold;
|
||||
std::vector<std::string> classes;
|
||||
|
||||
void loadClasses(const std::string& file);
|
||||
|
||||
Net readNet(const std::string& model, const std::string& config = "", const std::string& framework = "");
|
||||
|
||||
void postprocess(Mat& frame, const Mat& out, Net& net);
|
||||
@ -74,7 +80,7 @@ int main(int argc, char** argv)
|
||||
if (!ifs.is_open())
|
||||
CV_Error(Error::StsError, "File " + file + " not found");
|
||||
std::string line;
|
||||
while (ifs >> line)
|
||||
while (std::getline(ifs, line))
|
||||
{
|
||||
classes.push_back(line);
|
||||
}
|
||||
@ -83,17 +89,14 @@ int main(int argc, char** argv)
|
||||
// Load a model.
|
||||
CV_Assert(parser.has("model"));
|
||||
Net net = readNet(parser.get<String>("model"), parser.get<String>("config"), parser.get<String>("framework"));
|
||||
|
||||
if (parser.get<bool>("opencl"))
|
||||
{
|
||||
net.setPreferableTarget(DNN_TARGET_OPENCL);
|
||||
}
|
||||
net.setPreferableBackend(parser.get<int>("backend"));
|
||||
net.setPreferableTarget(parser.get<int>("target"));
|
||||
|
||||
// Create a window
|
||||
static const std::string kWinName = "Deep learning object detection in OpenCV";
|
||||
namedWindow(kWinName, WINDOW_NORMAL);
|
||||
int initialConf = confThreshold * 100;
|
||||
createTrackbar("Confidence threshold", kWinName, &initialConf, 99, callback);
|
||||
createTrackbar("Confidence threshold, %", kWinName, &initialConf, 99, callback);
|
||||
|
||||
// Open a video file or an image file or a camera stream.
|
||||
VideoCapture cap;
|
||||
@ -134,7 +137,7 @@ int main(int argc, char** argv)
|
||||
std::vector<double> layersTimes;
|
||||
double t = net.getPerfProfile(layersTimes);
|
||||
std::string label = format("Inference time: %.2f", t * 1000 / getTickFrequency());
|
||||
putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar());
|
||||
putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
|
||||
|
||||
imshow(kWinName, frame);
|
||||
}
|
||||
@ -240,7 +243,7 @@ void callback(int pos, void*)
|
||||
|
||||
Net readNet(const std::string& model, const std::string& config, const std::string& framework)
|
||||
{
|
||||
std::string modelExt = model.substr(model.find('.'));
|
||||
std::string modelExt = model.substr(model.rfind('.'));
|
||||
if (framework == "caffe" || modelExt == ".caffemodel")
|
||||
return readNetFromCaffe(config, model);
|
||||
else if (framework == "tensorflow" || modelExt == ".pb")
|
||||
|
||||
@ -3,6 +3,9 @@ import argparse
|
||||
import sys
|
||||
import numpy as np
|
||||
|
||||
backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_HALIDE, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
|
||||
targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL)
|
||||
|
||||
parser = argparse.ArgumentParser(description='Use this script to run object detection deep learning networks using OpenCV.')
|
||||
parser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.')
|
||||
parser.add_argument('--model', required=True,
|
||||
@ -28,6 +31,15 @@ parser.add_argument('--height', type=int,
|
||||
parser.add_argument('--rgb', action='store_true',
|
||||
help='Indicate that model works with RGB input images instead BGR ones.')
|
||||
parser.add_argument('--thr', type=float, default=0.5, help='Confidence threshold')
|
||||
parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
|
||||
help="Choose one of computation backends: "
|
||||
"%d: default C++ backend, "
|
||||
"%d: Halide language (http://halide-lang.org/), "
|
||||
"%d: Intel's Deep Learning Inference Engine (https://software.seek.intel.com/deep-learning-deployment)" % backends)
|
||||
parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
|
||||
help='Choose one of target computation devices: '
|
||||
'%d: CPU target (by default), '
|
||||
'%d: OpenCL' % targets)
|
||||
args = parser.parse_args()
|
||||
|
||||
# Load names of classes
|
||||
@ -37,7 +49,7 @@ if args.classes:
|
||||
classes = f.read().rstrip('\n').split('\n')
|
||||
|
||||
# Load a network
|
||||
modelExt = args.model[args.model.find('.'):]
|
||||
modelExt = args.model[args.model.rfind('.'):]
|
||||
if args.framework == 'caffe' or modelExt == '.caffemodel':
|
||||
net = cv.dnn.readNetFromCaffe(args.config, args.model)
|
||||
elif args.framework == 'tensorflow' or modelExt == '.pb':
|
||||
@ -50,6 +62,9 @@ else:
|
||||
print('Cannot determine an origin framework of model from file %s' % args.model)
|
||||
sys.exit(0)
|
||||
|
||||
net.setPreferableBackend(args.backend)
|
||||
net.setPreferableTarget(args.target)
|
||||
|
||||
confThreshold = args.thr
|
||||
|
||||
def postprocess(frame, out):
|
||||
@ -156,6 +171,6 @@ while cv.waitKey(1) < 0:
|
||||
# Put efficiency information.
|
||||
t, _ = net.getPerfProfile()
|
||||
label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())
|
||||
cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))
|
||||
cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
|
||||
|
||||
cv.imshow(winName, frame)
|
||||
|
||||
@ -1,110 +0,0 @@
|
||||
// Sample of using Halide backend in OpenCV deep learning module.
|
||||
// Based on caffe_googlenet.cpp.
|
||||
|
||||
#include <opencv2/dnn.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
using namespace cv;
|
||||
using namespace cv::dnn;
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
|
||||
/* Find best class for the blob (i. e. class with maximal probability) */
|
||||
static void getMaxClass(const Mat &probBlob, int *classId, double *classProb)
|
||||
{
|
||||
Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix
|
||||
Point classNumber;
|
||||
|
||||
minMaxLoc(probMat, NULL, classProb, NULL, &classNumber);
|
||||
*classId = classNumber.x;
|
||||
}
|
||||
|
||||
static std::vector<std::string> readClassNames(const char *filename = "synset_words.txt")
|
||||
{
|
||||
std::vector<std::string> classNames;
|
||||
|
||||
std::ifstream fp(filename);
|
||||
if (!fp.is_open())
|
||||
{
|
||||
std::cerr << "File with classes labels not found: " << filename << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
std::string name;
|
||||
while (!fp.eof())
|
||||
{
|
||||
std::getline(fp, name);
|
||||
if (name.length())
|
||||
classNames.push_back( name.substr(name.find(' ')+1) );
|
||||
}
|
||||
|
||||
fp.close();
|
||||
return classNames;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
std::string modelTxt = "train_val.prototxt";
|
||||
std::string modelBin = "squeezenet_v1.1.caffemodel";
|
||||
std::string imageFile = (argc > 1) ? argv[1] : "space_shuttle.jpg";
|
||||
|
||||
//! [Read and initialize network]
|
||||
Net net = dnn::readNetFromCaffe(modelTxt, modelBin);
|
||||
//! [Read and initialize network]
|
||||
|
||||
//! [Check that network was read successfully]
|
||||
if (net.empty())
|
||||
{
|
||||
std::cerr << "Can't load network by using the following files: " << std::endl;
|
||||
std::cerr << "prototxt: " << modelTxt << std::endl;
|
||||
std::cerr << "caffemodel: " << modelBin << std::endl;
|
||||
std::cerr << "SqueezeNet v1.1 can be downloaded from:" << std::endl;
|
||||
std::cerr << "https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1" << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
//! [Check that network was read successfully]
|
||||
|
||||
//! [Prepare blob]
|
||||
Mat img = imread(imageFile);
|
||||
if (img.empty())
|
||||
{
|
||||
std::cerr << "Can't read image from the file: " << imageFile << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
if (img.channels() != 3)
|
||||
{
|
||||
std::cerr << "Image " << imageFile << " isn't 3-channel" << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
Mat inputBlob = blobFromImage(img, 1.0, Size(227, 227), Scalar(), false, false); // Convert Mat to 4-dimensional batch.
|
||||
//! [Prepare blob]
|
||||
|
||||
//! [Set input blob]
|
||||
net.setInput(inputBlob); // Set the network input.
|
||||
//! [Set input blob]
|
||||
|
||||
//! [Enable Halide backend]
|
||||
net.setPreferableBackend(DNN_BACKEND_HALIDE); // Tell engine to use Halide where it possible.
|
||||
//! [Enable Halide backend]
|
||||
|
||||
//! [Make forward pass]
|
||||
Mat prob = net.forward("prob"); // Compute output.
|
||||
//! [Make forward pass]
|
||||
|
||||
//! [Determine the best class]
|
||||
int classId;
|
||||
double classProb;
|
||||
getMaxClass(prob, &classId, &classProb); // Find the best class.
|
||||
//! [Determine the best class]
|
||||
|
||||
//! [Print results]
|
||||
std::vector<std::string> classNames = readClassNames();
|
||||
std::cout << "Best class: #" << classId << " '" << classNames.at(classId) << "'" << std::endl;
|
||||
std::cout << "Probability: " << classProb * 100 << "%" << std::endl;
|
||||
//! [Print results]
|
||||
|
||||
return 0;
|
||||
} //main
|
||||
@ -1,154 +0,0 @@
|
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html.
|
||||
|
||||
// Copyright (C) 2016, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
|
||||
/*
|
||||
Sample of using OpenCV dnn module with Tensorflow Inception model.
|
||||
*/
|
||||
|
||||
#include <opencv2/dnn.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
using namespace cv;
|
||||
using namespace cv::dnn;
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
using namespace std;
|
||||
|
||||
const String keys =
|
||||
"{help h || Sample app for loading Inception TensorFlow model. "
|
||||
"The model and class names list can be downloaded here: "
|
||||
"https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip }"
|
||||
"{model m |tensorflow_inception_graph.pb| path to TensorFlow .pb model file }"
|
||||
"{image i || path to image file }"
|
||||
"{i_blob | input | input blob name) }"
|
||||
"{o_blob | softmax2 | output blob name) }"
|
||||
"{c_names c | imagenet_comp_graph_label_strings.txt | path to file with classnames for class id }"
|
||||
"{result r || path to save output blob (optional, binary format, NCHW order) }"
|
||||
;
|
||||
|
||||
void getMaxClass(const Mat &probBlob, int *classId, double *classProb);
|
||||
std::vector<String> readClassNames(const char *filename);
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
cv::CommandLineParser parser(argc, argv, keys);
|
||||
|
||||
if (parser.has("help"))
|
||||
{
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
String modelFile = parser.get<String>("model");
|
||||
String imageFile = parser.get<String>("image");
|
||||
String inBlobName = parser.get<String>("i_blob");
|
||||
String outBlobName = parser.get<String>("o_blob");
|
||||
|
||||
if (!parser.check())
|
||||
{
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
String classNamesFile = parser.get<String>("c_names");
|
||||
String resultFile = parser.get<String>("result");
|
||||
|
||||
//! [Initialize network]
|
||||
dnn::Net net = readNetFromTensorflow(modelFile);
|
||||
//! [Initialize network]
|
||||
|
||||
if (net.empty())
|
||||
{
|
||||
std::cerr << "Can't load network by using the mode file: " << std::endl;
|
||||
std::cerr << modelFile << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
//! [Prepare blob]
|
||||
Mat img = imread(imageFile);
|
||||
if (img.empty())
|
||||
{
|
||||
std::cerr << "Can't read image from the file: " << imageFile << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
Mat inputBlob = blobFromImage(img, 1.0f, Size(224, 224), Scalar(), true, false); //Convert Mat to batch of images
|
||||
//! [Prepare blob]
|
||||
inputBlob -= 117.0;
|
||||
//! [Set input blob]
|
||||
net.setInput(inputBlob, inBlobName); //set the network input
|
||||
//! [Set input blob]
|
||||
|
||||
cv::TickMeter tm;
|
||||
tm.start();
|
||||
|
||||
//! [Make forward pass]
|
||||
Mat result = net.forward(outBlobName); //compute output
|
||||
//! [Make forward pass]
|
||||
|
||||
tm.stop();
|
||||
|
||||
if (!resultFile.empty()) {
|
||||
CV_Assert(result.isContinuous());
|
||||
|
||||
ofstream fout(resultFile.c_str(), ios::out | ios::binary);
|
||||
fout.write((char*)result.data, result.total() * sizeof(float));
|
||||
fout.close();
|
||||
}
|
||||
|
||||
std::cout << "Output blob shape " << result.size[0] << " x " << result.size[1] << " x " << result.size[2] << " x " << result.size[3] << std::endl;
|
||||
std::cout << "Inference time, ms: " << tm.getTimeMilli() << std::endl;
|
||||
|
||||
if (!classNamesFile.empty()) {
|
||||
std::vector<String> classNames = readClassNames(classNamesFile.c_str());
|
||||
|
||||
int classId;
|
||||
double classProb;
|
||||
getMaxClass(result, &classId, &classProb);//find the best class
|
||||
|
||||
//! [Print results]
|
||||
std::cout << "Best class: #" << classId << " '" << classNames.at(classId) << "'" << std::endl;
|
||||
std::cout << "Probability: " << classProb * 100 << "%" << std::endl;
|
||||
}
|
||||
return 0;
|
||||
} //main
|
||||
|
||||
|
||||
/* Find best class for the blob (i. e. class with maximal probability) */
|
||||
void getMaxClass(const Mat &probBlob, int *classId, double *classProb)
|
||||
{
|
||||
Mat probMat = probBlob.reshape(1, 1); //reshape the blob to 1x1000 matrix
|
||||
Point classNumber;
|
||||
|
||||
minMaxLoc(probMat, NULL, classProb, NULL, &classNumber);
|
||||
*classId = classNumber.x;
|
||||
}
|
||||
|
||||
std::vector<String> readClassNames(const char *filename)
|
||||
{
|
||||
std::vector<String> classNames;
|
||||
|
||||
std::ifstream fp(filename);
|
||||
if (!fp.is_open())
|
||||
{
|
||||
std::cerr << "File with classes labels not found: " << filename << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
std::string name;
|
||||
while (!fp.eof())
|
||||
{
|
||||
std::getline(fp, name);
|
||||
if (name.length())
|
||||
classNames.push_back( name );
|
||||
}
|
||||
|
||||
fp.close();
|
||||
return classNames;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user