yolo v2之车牌检测后续识别字符（二）

最新推荐文章于 2024-08-05 18:41:17 发布
最新推荐文章于 2024-08-05 18:41:17 发布
阅读量1w 收藏 14
点赞数 2
分类专栏： caffe 文章标签： caffe 多标签分类 caffe 端到端车牌识别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AP1005834/article/details/77007909
版权

一、前言

       这一篇续接前一篇《yolo v2之车牌检测后续识别字符（一）》，主要是生成模型文件、配置文件以及训练、测试模型。

二、python接口生成配置文件、模型文件

       车牌图片端到端识别的模型文件参考自这里，模型图如下所示：


        本来想使用caffe的python接口生成prototxt，结果发现很麻烦，容易出错，直接在可视化工具netscope上对已有prototxt做修改更方便，写模型文件时，注意输入的图片、卷积核大小、pad大小、stride大小、输出图片大小的关系，无论卷积层还是池化层，都有

输入：n, c_i, h_i, w_i 

输出：n, c_o, h_o, w_o

满足： h_o = ( h_i + 2*pad_h - kernel_h) / stride_h +1

           w_o = ( w_i + 2*pad_w - kernel_w ) / stride_w +1

#lpr_train_val.prototxt
name: "Lpr"
layer {
  name: "lpr"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    scale: 0.00390625
    mean_file: "/home/jyang/caffe/LPR/Mean/mean.binaryproto"
  }
  data_param {
    source: "/home/jyang/caffe/LPR/Build_lmdb/train_lmdb"
    batch_size: 32
    backend: LMDB
  }
}
layer {
  name: "lpr"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    scale: 0.00390625
    mean_file: "/home/jyang/caffe/LPR/Mean/mean.binaryproto"
  }
  data_param {
    source: "/home/jyang/caffe/LPR/Build_lmdb/val_lmdb"
    batch_size: 32
    backend: LMDB
  }
}
layer {
  name: "slices"
  type: "Slice"
  bottom: "label"
  top: "label_1"
  top: "label_2"
  top: "label_3"
  top: "label_4"
  top: "label_5"
  top: "label_6"
  top: "label_7"
  slice_param {
    axis: 1
    slice_point: 1
    slice_point: 2
    slice_point: 3
    slice_point: 4
    slice_point: 5
    slice_point: 6
  }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 32
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "conv1"
  top: "conv1"
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "conv1"
  top: "conv2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 32
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu2"
  type: "ReLU"
  bottom: "conv2"
  top: "conv2"
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "pool2"
  top: "conv3"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 64
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "conv3"
  top: "conv3"
}
layer {
  name: "conv4"
  type: "Convolution"
  bottom: "conv3"
  top: "conv4"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 64
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu4"
  type: "ReLU"
  bottom: "conv4"
  top: "conv4"
}
layer {
  name: "pool4"
  type: "Pooling"
  bottom: "conv4"
  top: "pool4"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv5"
  type: "Convolution"
  bottom: "pool4"
  top: "conv5"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 128
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu5"
  type: "ReLU"
  bottom: "conv5"
  top: "conv5"
}
layer {
  name: "conv6"
  type: "Convolution"
  bottom: "conv5"
  top: "conv6"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 128
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu6"
  type: "ReLU"
  bottom: "conv6"
  top: "conv6"
}
layer {
  name: "pool6"
  type: "Pooling"
  bottom: "conv6"
  top: "pool6"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "flat6"
  type: "Flatten"
  bottom: "pool6"
  top: "flat6"
  flatten_param {
    axis: 1
  }
}
layer {
  name: "drop6"
  type: "Dropout"
  bottom: "flat6"
  top: "flat6"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_1"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_1"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_2"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_2"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_3"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_3"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_4"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_4"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_5"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_5"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_6"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_6"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_7"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_7"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "accuracy_1"
  type: "Accuracy"
  bottom: "fc7_1"
  bottom: "label_1"
  top: "accuracy_1"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_2"
  type: "Accuracy"
  bottom: "fc7_2"
  bottom: "label_2"
  top: "accuracy_2"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_3"
  type: "Accuracy"
  bottom: "fc7_3"
  bottom: "label_3"
  top: "accuracy_3"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_4"
  type: "Accuracy"
  bottom: "fc7_4"
  bottom: "label_4"
  top: "accuracy_4"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_5"
  type: "Accuracy"
  bottom: "fc7_5"
  bottom: "label_5"
  top: "accuracy_5"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_6"
  type: "Accuracy"
  bottom: "fc7_6"
  bottom: "label_6"
  top: "accuracy_6"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_7"
  type: "Accuracy"
  bottom: "fc7_7"
  bottom: "label_7"
  top: "accuracy_7"
  include {
    phase: TEST
  }
}
layer {
  name: "loss_1"
  type: "SoftmaxWithLoss"
  bottom: "fc7_1"
  bottom: "label_1"
  top: "loss_1"
  ###权重
  loss_weight: 0.142857                    # 1.0/7=0.142857
}
layer {
  name: "loss_2"
  type: "SoftmaxWithLoss"
  bottom: "fc7_2"
  bottom: "label_2"
  top: "loss_2"
  ###权重
  loss_weight: 0.142857
}
layer {
  name: "loss_3"
  type: "SoftmaxWithLoss"
  bottom: "fc7_3"
  bottom: "label_3"
  top: "loss_3"
  ###权重
  loss_weight: 0.142857
}
layer {
  name: "loss_4"
  type: "SoftmaxWithLoss"
  bottom: "fc7_4"
  bottom: "label_4"
  top: "loss_4"
  ###权重
  loss_weight: 0.142857
}
layer {
  name: "loss_5"
  type: "SoftmaxWithLoss"
  bottom: "fc7_5"
  bottom: "label_5"
  top: "loss_5"
  ###权重
  loss_weight: 0.142857
}
layer {
  name: "loss_6"
  type: "SoftmaxWithLoss"
  bottom: "fc7_6"
  bottom: "label_6"
  top: "loss_6"
  ###权重
  loss_weight: 0.142857
}
layer {
  name: "loss_7"
  type: "SoftmaxWithLoss"
  bottom: "fc7_7"
  bottom: "label_7"
  top: "loss_7"
  ###权重
  loss_weight: 0.142857
}
deploy文件如下： 
#lpr_deploy.prototxt
name: "Lpr"
layer {
  name: "data"
  type: "Input"
  top: "data"
  input_param { 
    shape: { 
      dim: 1 
      dim: 3 
      dim: 72 
      dim: 272 
    } 
  }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 32
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "conv1"
  top: "conv1"
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "conv1"
  top: "conv2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 32
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu2"
  type: "ReLU"
  bottom: "conv2"
  top: "conv2"
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "pool2"
  top: "conv3"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 64
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "conv3"
  top: "conv3"
}
layer {
  name: "conv4"
  type: "Convolution"
  bottom: "conv3"
  top: "conv4"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 64
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu4"
  type: "ReLU"
  bottom: "conv4"
  top: "conv4"
}
layer {
  name: "pool4"
  type: "Pooling"
  bottom: "conv4"
  top: "pool4"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv5"
  type: "Convolution"
  bottom: "pool4"
  top: "conv5"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 128
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu5"
  type: "ReLU"
  bottom: "conv5"
  top: "conv5"
}
layer {
  name: "conv6"
  type: "Convolution"
  bottom: "conv5"
  top: "conv6"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 128
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu6"
  type: "ReLU"
  bottom: "conv6"
  top: "conv6"
}
layer {
  name: "pool6"
  type: "Pooling"
  bottom: "conv6"
  top: "pool6"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "flat6"
  type: "Flatten"
  bottom: "pool6"
  top: "flat6"
  flatten_param {
    axis: 1
  }
}
layer {
  name: "drop6"
  type: "Dropout"
  bottom: "flat6"
  top: "flat6"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_1"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_1"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_2"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_2"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_3"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_3"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_4"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_4"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_5"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_5"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_6"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_6"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc7_7"
  type: "InnerProduct"
  bottom: "flat6"
  top: "fc7_7"
  param {
    lr_mult: 1
    decay_mult: 0
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 65
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "prob_1"
  type: "Softmax"
  bottom: "fc7_1"
  top: "prob_1"
}
layer {
  name: "prob_2"
  type: "Softmax"
  bottom: "fc7_2"
  top: "prob_2"
}
layer {
  name: "prob_3"
  type: "Softmax"
  bottom: "fc7_3"
  top: "prob_3"
}
layer {
  name: "prob_4"
  type: "Softmax"
  bottom: "fc7_4"
  top: "prob_4"
}
layer {
  name: "prob_5"
  type: "Softmax"
  bottom: "fc7_5"
  top: "prob_5"
}
layer {
  name: "prob_6"
  type: "Softmax"
  bottom: "fc7_6"
  top: "prob_6"
}
layer {
  name: "prob_7"
  type: "Softmax"
  bottom: "fc7_7"
  top: "prob_7"
}
solver文件如下： 
#My solver prototxt
net: "/home/jyang/caffe/LPR/Proto/lpr_train_val.prototxt"
test_iter: 338           #10815（张测试图片）/32（batch_size） 取整得338
test_interval: 2236    #71547（张训练图片）/32（batch_size）取整得2236，即2236次迭代后开始一次测试
base_lr: 0.01
display: 100
max_iter: 111800             #50个epoch，50*2236=111800，最大迭代次数为111800
lr_policy: "step"
gamma: 0.1
stepsize: 8000
momentum: 0.9
weight_decay: 0.0005
snapshot: 20000         #20000次迭代保存一次caffemodel
snapshot_prefix: "/home/jyang/caffe/LPR/lpr"
solver_mode: GPU
snapshot_format: BINARYPROTO
三、训练模型
        这里就不画出loss函数了，在LPR文件夹下创建lpr_train.py。 
#lpr_train.py
#!/usr/bin/env python
#coding=utf-8

import caffe

if __name__ =='__main__':
    solver_file = '/home/jyang/caffe/LPR/Proto/lpr_solver.prototxt'                      
    caffe.set_device(0)      #select GPU-0
    caffe.set_mode_gpu()
    solver = caffe.SGDSolver(solver_file)
    solver.solve()
四、模型训练结果
        执行该 lpr_train.py 文件，即开始训练，可看到在验证集上的准确率如下：


       可看到第一个字符的识别率较为低，只有85%左右，其余的均在93%以上

五、使用训练得的模型做预测：

       由于这里用的是python 接口，故先将之前的均值文件Mean.binaryproto 转为 mean.npy ，在Mean文件夹下新建 binToNpy.py ，使用以下代码转换

import numpy as np
import caffe
import sys

blob = caffe.proto.caffe_pb2.BlobProto()
data = open( 'mean.binaryproto' , 'rb' ).read()
blob.ParseFromString(data)
arr = np.array( caffe.io.blobproto_to_array(blob) )
out = arr[0]
np.save( 'mean.npy' , out )

      这样deploy文件、均值文件、 caffemodel文件准备好了，在LPR下创建 predict.py ，载入一张图片作预测

#!/usr/bin/env python
#coding=utf-8

import cv2
import numpy as np
import sys,os
import time

import caffe

caffe_root = '/home/jyang/caffe/'
net_file = caffe_root + 'LPR/Proto/lpr_deploy.prototxt'
caffe_model = caffe_root + 'LPR/lpr_iter_40000.caffemodel'
mean_file = caffe_root + 'LPR/Mean/mean.npy'

img_path = caffe_root + 'LPR/001.png'    #图片路径

labels = {0 :"京", 1 :"沪", 2 :"津", 3 :"渝",4 : "冀" , 5: "晋",6: "蒙", 7: "辽",8: "吉",9: "黑",10: "苏",11: "浙",12: "皖",13: 
         "闽",14: "赣",15: "鲁",16: "豫",17: "鄂",18: "湘",19: "粤",20: "桂",   21: "琼",22: "川",23: "贵",24: "云",
       25:  "藏",26: "陕",27: "甘",28: "青",29: "宁",30: "新",31: "0",32: "1",33: "2",34: "3",35: "4",36: "5",
       37:  "6",38: "7",39: "8",40: "9",41: "A",42: "B",43: "C",44: "D",45: "E",46: "F",47: "G",48: "H",
        49: "J",50: "K",51: "L",52: "M",53: "N",54: "P",55: "Q",56: "R",57: "S",58: "T",59: "U",60: "V",
        61: "W",62: "X",63: "Y",64: "Z" };

if __name__=='__main__':
    net=caffe.Net(net_file,caffe_model,caffe.TEST)
    transformer=caffe.io.Transformer({'data':net.blobs['data'].data.shape})
    transformer.set_transpose('data' ,(2, 0, 1) )
    #读入的是H*W*C（0，1，2），但我们需要的是C*H*W（2，0，1 )
    transformer.set_mean('data', np.load(mean_file).mean(1).mean(1) )
    transformer.set_raw_scale('data' , 255)
    #把数据从[0-1] rescale 至 [0-255]
    transformer.set_channel_swap('data' ,(2 ,1 , 0))
    #在caffe中读入是BGR(0,1,2)，所以要将RGB转化为BGR(2,1,0)
    
    start = time.time()
    img=caffe.io.load_image(img_path )
    img=img[...,::-1] 

    net.blobs['data'].data[...]=transformer.preprocess('data' , img)
    out=net.forward()
    
    prob=('prob_1','prob_2','prob_3','prob_4','prob_5','prob_6','prob_7')
    for k in range(7):
       index = net.blobs[prob[k]].data[0].flatten().argsort()[-1:-6:-1] 
       print labels[index[0]],
    print("\nDone in %.2f s." % (time.time()-start ))

    cv2.imshow( 'demo',img)
    cv2.waitKey(0)
    预测结果
     


结语

      实际测试图片，发现完全正确识别的准确率很低，虽然训练得到的模型在验证集上的识别准确率很高，但是训练集和验证集都是经过样本增强得到的，3922张扩充至80000多张，扩充的样本和真实样本还是存在差距，且即是扩充再多，样本信息还是有限的，导致过拟和了，如果能获得几万张真实的车牌图片，所训练出的模型实用性将会更高。



ForeverYang2015
关注
专栏目录
目标检测YOLO实战应用案例100讲-基于YOLOv4的车牌识别
qq_36130719的博客
09-30 348
车牌字符识别系统是计算机图像识别技术在汽车方面的实际运用，通俗的讲它是通 过以视频监控、图像采集等方式，对选取的目标而进行识别的图像和视频处理系统，它 检测出需要监控的车辆，并通过自动分析和提取所拍摄的车牌进行信息的分析和处理。这种系统一般是通过摄像头拍摄提取车辆图像或视频序列的方式，使用数字图像处理、 计算机视觉等算法和技术，来实现车牌的字符识别。车牌字符识别系统符合应用软件的 特性的同时，也结合了深层次的计算机技术，对提高现代车辆管理效率，对于缓解交通 运输压力等，都起到了非常重要的作用。
【STM32+K210项目】基于K210智能人脸识别+车牌识别系统（完整工程资料源码）
妄北y
08-05 4913
随着时代的进步和科技的迅猛发展，人们对居住安全的重视程度不断提升，对安全防范系统的需求也日益增强。在安防系统中，门禁系统占据着重要的位置。传统的门禁控制方式主要依靠钥匙、密码和门禁卡等，这些方式易于被破解和复制，安全性较低。然而，近年来，生物识别技术的迅速发展和成熟，为解决这一问题提供了新的方案。生物识别技术具备便携性、非易失性、不易遗忘以及难以盗用等优点，逐渐被引入到门禁系统中。传统的小区门禁系统往往依赖人工管理，存在一定的局限性，难以满足用户多样化的需求，也浪费了人力资源。
在YOLO2中增加自己的物体识别（一）
qprevf的博客
05-30 1180
从RCNN, fast RCNN， 到faster RCNN， YOLO, 以及最新的YOLO2， 检测的速度是越来越快了， 最新的YOLO2据作者说可以达到67Fps， 支持的种类达9000.想看效果的请戳这里YOLO2 .这么快速度，当然很多人估计跟我一样，想把它用来检测特定类的物体。这里，我将根据自己查找的一些资料，以及自己的实践，告诉大家怎么在YOLO2中增加识别自己需要的物体。主要分为2部
yolo v2之车牌检测后续识别字符（一）
AP1005834的博客
08-09 1万+
一、前言        本篇续接前一篇 yolo v2 之车牌检测 ，前一篇使用yolo v2已经可以很准确地框出车牌图片了，这里完成后续的车牌字符号码的识别，从车牌框框中要识别出车牌字符，笔者能想到3种思路，1种是同样yolo、SSD等深度学习目标检测的方法直接对车牌内的字符识别；第2种是传统方法从框里切分字符，再训练深度学习的模型对各个字符做识别；第3种方法就是端到端的车牌图片识别。在车牌图
目标检测 | yolov3 原理和介绍
最新发布
hhl_work的博客
08-05 1374
YOLOv3 擅于预测出合适的目标，但无法预测出非常精准的边界框。YOLOv3 小目标预测能力提升，但中大目标的预测反而相对较差。若将速度考量进来，YOLOv3 整体来说表现非常出色。YOLOv3在小目标\密集目标的改进1.grid cell个数增加，YOLOv1（7×7），YOLOv2（13×13），YOLOv3（13×13+26×26+52×52）2.YOLOv2和YOLOv3可以输入任意大小的图片，输入图片越大，产生的grid cell越多，产生的预测框也就越多。
yolo v2 之车牌检测
AP1005834的博客
07-20 1万+
一、前言         本文主要使用yolo v2 训练自己的车牌图片数据，并能够框出测试图片中存在的车牌区域，也即车牌检测。本文参考了博文http://m.blog.csdn.net/qq_34484472/article/details/73135354和http://blog.csdn.net/zhy8623080/article/details/73188542 二、准备工作
基于 YOLOv2 Tiny的车牌检测
zhiliu的专栏
11-04 1136
YOLO安装 源码获取 安装 车牌检测 转换样本格式 修改网络 其他 训练 可视化训练 测试 YOLO安装 源码获取 从 darknet 下载。 git clone https://github.com/pjreddie/darknet.git 安装 修改Makefile文件，启用GPU、CUDNN等，不启用的话，相应值置零： GPU=1 CUDNN...
【电赛开发】2021-F题数字识别-YOLOV2(含无脑训练教程
Kamimiao的博客
11-14 8097
前言: 本教程采用K210跑模板进行数字识别，针对电赛的环境训练出来的效果更好 在比赛中对识别速度要求也不是很高，所以尽量追求正确率，我选择了K210跑YOLOV2模型 介绍: YOLOv2采用了一个新的基础模型（特征提取器），称为Darknet-19，包括19个卷积层和5个maxpooling层，如图所示。Darknet-19与VGG16模型设计原则是一致的，主要采用33卷积，采用22的maxpooling层之后，特征图维度降低2倍，而同时将特征图的channles增加两倍。与NIN(Network in
使用深度学习进行自动车牌检测和识别
小白学视觉
09-26 3074
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达介绍在现代世界的不同方面，信息技术的大规模集成导致了将车辆视为信息系统中的概念资源。由于没有任何数据，自主信息系统就没...
无约束场景下的车牌检测与识别
无约束场景下的车牌检测与识别S´ergi oMontaz zolliSilva[0000−0003−2444−3175]andCla´udi oR ositoJung[0000−0002−4711−5783]巴西南里奥格兰德州阿雷格里港联邦大学信息学院{smsilva，crjung}@ inf.ufrgs....
基于YOLO的非头盔摩托车实时车牌检测
⃝可在www.sciencedirect.com在线获取ScienceDirectICTExpress 7（2021）104www.elsevier.com/locate/icte基于YOLO的非头盔摩托车实时车牌检测Yonten Jamtshoa，Panomkhawn Riyamkolb，Rattapoom ...
基于YOLOV5的车牌定位和识别源码.zip
04-11
这是基于YOLOV5目标检测模型的实时车牌识别，包括对车辆的车牌区域精确定位，利用校正探测器对定位的车牌进行边框校正处理，使用增强神经网络模型对车牌区域进行超分辨率技术处理和光学字符识别。经过多次试验测试，可以对视频中的车辆车牌实时识别以及图片中的车辆车牌进行准确定位和识别，识别速度快，准确率高，比那些传统车牌识别方法效果好很多。效果演示视频：1.https://www.bilibili.com/video/BV1eK4y1m7GQ/ 2.https://www.bilibili.com/video/BV13K4y1K7Pi/
【目标检测·yolo系列】YOLOV2目标检测论文笔记（参考 同济子豪兄的解读）
chentao326的博客
09-18 1148
目录anchor 、 Dimension Clusters 、Direct location prediction在YOLOv2中规定了五种anchor，grid cell数量为奇数限制预测框位置损失函数细粒度特征Multi-Scale Training anchor 、 Dimension Clusters 、Direct location prediction 在YOLOv1中先验框是随机的，在YOLOv2中规定了两个先验框，如下图 如图，①框擅长套高瘦长的物体，②框擅长矮胖宽的物体 由此可以使得模型
tensorflow车牌
weixin_44805418的博客
03-24 178
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 tensor...
C++实现YOLO目标识别图像预处理、后处理
weixin_39538031的博客
06-02 1762
基于C++手写YOLO目标识别图像后处理部分代码
目标检测yolov3+文字识别CRNN 实现文本检测和识别
DeepCBW的博客
05-28 9145
目标检测yolov3+文字识别CRNN 实现文本检测和识别
深度学习目标检测：YOLOv5实现车辆检测(含车辆检测数据集+训练代码)
热门推荐
AI吃大瓜的博客
12-05 7万+
YOLOv5实现车辆检测(含车辆检测数据集+训练代码)；机动车检测，车辆实时检测；车辆目标检测；Pytorch车辆检测
基于 YOLO 的车牌检测与识别
小白学视觉
02-25 6743
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达导读本文将重点介绍 ALPR 的端到端实现。它将侧重于两个过程：车牌检测和检测到的车牌的 OCR。（公众号：OpenCV与AI深度学习）背景介绍 深度学习一直是现代世界发展最快的技术之一。深度学习已经成为我们日常生活的一部分，从语音助手到汽车自动驾驶，它无处不在。其中一项应用是自动车牌识别 (ALPR)。顾名思义，ALP...
YOLOv1，YOLOv2，YOLOv3解读
努力充实，远方可期
02-27 8003
单阶段 YOLO 推荐论文翻译：https://www.jianshu.com/p/a2a22b0c4742 （md格式） 名字解释：You Only Look Once: Unified, Real-Time Object Detection You Only Look Once说的是只需要一次CNN运算，Unified指的是这是一个统一的框架，提供end-to-end的预测，而Real-Tim...
基于yolo v2深度学习检测识别车辆matlab源码
07-02
### 回答1： 基于YOLO(v2)深度学习的车辆检测与识别的MATLAB源码是使用MATLAB编程语言实现的，目的是通过训练深度神经网络实现对车辆的自动检测与识别。 YOLO(v2)是一种目标检测算法，其全称为You Only Look Once，可以实时地从图像中检测多个目标。在车辆检测与识别任务中，YOLO(v2)通过划分图像为多个网格单元，并根据每个单元内的特征预测出车辆的边界框、类别和置信度。 MATLAB源码的实现过程主要包括以下几个步骤： 1. 数据准备：收集和准备用于训练的车辆图像和对应的标签数据。标签数据包括车辆边界框的位置和类别信息。 2. 网络设计：设计一个基于YOLO(v2)网络结构的深度神经网络。该网络包括卷积层、池化层、全连接层、激活函数等。 3. 权重初始化：使用预训练的权重对网络进行初始化，以加快网络的训练速度和提高准确度。 4. 数据增强：对训练数据进行随机平移、旋转、缩放等增强操作，增加训练样本的多样性和数量。 5. 损失函数定义：定义用于训练的损失函数，包括边界框定位损失、类别预测损失和置信度损失。 6. 训练网络：使用训练数据对网络进行训练，并根据损失函数对网络参数进行更新。 7. 测试与评估：使用测试数据对网络进行评估，计算检测与识别的准确率、召回率和F1分数等指标。 8. 模型应用：将训练好的模型应用于新的图像，实现车辆的检测与识别。可以通过调整置信度的阈值来控制检测的精度和召回率。 基于YOLO(v2)深度学习的车辆检测与识别的MATLAB源码可以通过搜索相关资源或参考开源项目获得，也可以根据以上步骤进行自行实现。在使用源码时，需要注意安装相应的深度学习库，如MATLAB的Deep Learning Toolbox，以及确保计算机具备足够的计算资源和显卡支持。 ### 回答2： YOLO v2是一种基于深度学习的目标检测算法，能够在图像中实时地检测和识别多个目标。通过使用YOLO v2算法，我们可以编写MATLAB源码来实现车辆的检测和识别。 首先，在MATLAB中导入YOLO v2的深度学习模型，并将其加载到工作空间中。然后，我们需要准备一些车辆图像数据集，并将其分为训练集和测试集。接下来，我们使用数据集对模型进行训练，以便让模型能够学习和识别车辆。 在模型训练完成后，我们可以使用训练好的模型来进行车辆的检测和识别。首先，我们将一张待检测的图像输入到模型中，模型将输出图像中所有检测到的目标的位置和类别。然后，我们可以根据输出的结果在图像上绘制边界框和类别标签，以便更直观地观察识别结果。 在编写源码时，我们需要考虑一些细节。首先，我们需要设置模型的超参数，如输入图像的尺寸、训练的迭代次数等。其次，我们需要编写代码来导入和预处理图像数据集，并将其分为训练集和测试集。然后，我们需要定义模型的结构和损失函数，并选择合适的优化算法来训练模型。最后，我们可以编写代码来加载训练好的模型，并将其应用于新的图像数据集。 总之，基于YOLO v2的深度学习检测识别车辆的MATLAB源码可以实现车辆的实时检测和识别。通过编写源码，我们可以导入和训练YOLO v2模型，并使用训练好的模型来对车辆图像进行检测和识别。这样，我们可以方便地应用该算法于车辆相关应用中。 ### 回答3： YOLO v2（You Only Look Once v2）是一种深度学习模型，用于车辆检测和识别。其主要特点是快速和准确，能够实时识别图像中的车辆。 基于YOLO v2的车辆检测和识别的MATLAB源码主要包括以下步骤： 1. 数据集准备：收集并整理包含车辆的图像数据集，同时制作标签信息，标注车辆的位置和类别。 2. 数据预处理：对图像进行预处理，如调整大小、翻转、旋转等操作，以提高模型对不同尺度和变化的适应能力。 3. 模型训练：使用YOLO v2的网络架构和深度学习框架（如MATLAB中的Deep Learning Toolbox）进行模型训练。训练过程包括输入前向传播和后向传播，通过优化算法（如梯度下降）调整模型参数，使其逐渐收敛到最佳状态。 4. 模型评估：使用评估数据集对训练好的模型进行评估，计算检测和识别的准确率、召回率和F1值等指标，以评估模型的性能。 5. 结果可视化：将模型在测试图像上的检测和识别结果进行可视化展示，用不同的边界框和类别标签标识出检测到的车辆。 除了以上步骤，还有一些细节需要注意，如数据集的平衡性、模型的超参数调优、数据增强等。此外，为了提高模型的性能和泛化能力，还可以考虑使用预训练的权重参数、引入多尺度检测和注意力机制等技巧。 总结起来，基于YOLO v2的深度学习检测识别车辆的MATLAB源码主要包括数据准备、数据预处理、模型训练、模型评估和结果可视化等步骤，通过优化模型参数和技巧，提高检测和识别的准确率和实时性。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值