基于caffe的多标签端到端车牌识别

最新推荐文章于 2024-05-25 10:40:35 发布
最新推荐文章于 2024-05-25 10:40:35 发布
阅读量4.6k 收藏 15
点赞数 3
文章标签： 深度学习 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013382233/article/details/78850940
版权

最近利用深度学习框架caffe做了一个端到端车牌识别的模型，所用的网络为AlexNet稍加了一些修改，由于数据集太少、网络结构不完善，效果并没有很好，但是一些基本的思路摸清楚了。

一、数据处理

  • 所用的数据为EasyPR提供的数据集，共有1541张车牌图片，按照8：1：1的比例分为train、val和test三个数据集。（数据集太少，后期还会用GAN和真实车牌生成数据）
  • caffe自带的lmdb数据库没有存储多标签数据的功能，所以用hdf5对数据进行存储。车牌共有7个字符，第一个字符为汉字，第二个字符为字母，后面五个字符为数字和字母，所以将标签分为三类：31个汉字标签，24个字母标签，以及34个字母数字标签。
  • opencv读取的图片为H*W*C的形式，根据blob对图片reshape为C*H*W维度。
# 读取labelmap
labeldict_Chi = dict()
labelmap_Chi = open("labelmap_Chinese.txt", "r")
lines = labelmap_Chi.readlines()
for line in lines:
    line = line.strip("\n")
    temp = line.split(" ")
    labeldict_Chi[temp[1]] = temp[0]
labelmap_Chi.close()

labeldict_Letter = dict()
labelmap_Letter = open("labelmap_Letter.txt", "r")
lines = labelmap_Letter.readlines()
for line in lines:
    line = line.strip("\n")
    temp = line.split(" ")
    labeldict_Letter[temp[1]] = temp[0]
labelmap_Letter.close()

labeldict_NL = dict()
labelmap_NL = open("labelmap_Num&Letter.txt", "r")
lines = labelmap_NL.readlines()
for line in lines:
    line = line.strip("\n")
    temp = line.split(" ")
    labeldict_NL[temp[1]] = temp[0]
labelmap_NL.close()

for i in range(2):
    imgs_file = os.listdir(IMG_FILE[i])

    for img_file in imgs_file:
        filename = os.path.join(IMG_FILE[i], img_file)
        image = cv2.imread(filename)
        image = image.reshape(3, 36, 136)

        label = []
        char_Chi = img_file[:3]
        label.append(int(labeldict_Chi[char_Chi]))
        char_Spe = img_file[3:4]
        label.append(int(labeldict_Letter[char_Spe]))
        for char in img_file[4:-4]:
            label.append(int(labeldict_NL[char]))

        IMAGE[i].append(image)
        LABEL[i].append(np.array(label))

    IMAGE[i] = np.array(IMAGE[i], dtype=int)
    LABEL[i] = np.array(LABEL[i], dtype=int)

    meanValue = mean(IMAGE[0])

    print "Creating hdf5..."
    with h5py.File(HDF5_FILE[i], "w") as h5:
        data = IMAGE[i].astype(np.float32) - meanValue
        label = LABEL[i].astype(np.float32)
        h5["data"] = data
        h5["label"] = label
        h5.close()

    print "Creating txt..."
    with open(TXT_FILE[i], "w") as txt:
        txt.write(os.path.join(os.getcwd(), HDF5_FILE[i]))
        txt.close()

np.save("mean_e2e.npy", meanValue)

将图片存入h5文件的时候，需要加上图片的均值，由于caffe计算均值的文件是针对lmdb格式的，所以均值就自己写了一个：

# 计算均值
def mean(images):
    images = images.astype(np.float32)
    meanValue = sum(images) / len(images)
    return meanValue

最后要将h5文件读入到一个txt文件里，这个txt文件存储的就是h5文件的路径。

二、生成网络结构

  • 网络结构使用的是AlexNet结构，对网络结构进行了一些修改：
    • 数据层用的是hdf5数据；
    • 多标签分类，添加了slice层；
    • 最后的输出根据标签数量的不同，输出的特征数有变化。
name: "Plate_E2E"
layer {
  name: "data"
  type: "HDF5Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  hdf5_data_param {
    source: "examples/plate_e2e/train_e2e.txt"
    batch_size: 10
  }
}
layer {
  name: "data"
  type: "HDF5Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  hdf5_data_param {
    source: "examples/plate_e2e/val_e2e.txt"
    batch_size: 10
  }
}
layer {
  name: "slicers"
  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: 96
    kernel_size: 11
    stride: 4
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "conv1"
  top: "conv1"
}
layer {
  name: "norm1"
  type: "LRN"
  bottom: "conv1"
  top: "norm1"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "norm1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "pool1"
  top: "conv2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 256
    pad: 2
    kernel_size: 5
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu2"
  type: "ReLU"
  bottom: "conv2"
  top: "conv2"
}
layer {
  name: "norm2"
  type: "LRN"
  bottom: "conv2"
  top: "norm2"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "norm2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "pool2"
  top: "conv3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 384
    pad: 1
    kernel_size: 3
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "conv3"
  top: "conv3"
}
layer {
  name: "conv4"
  type: "Convolution"
  bottom: "conv3"
  top: "conv4"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 384
    pad: 1
    kernel_size: 3
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu4"
  type: "ReLU"
  bottom: "conv4"
  top: "conv4"
}
layer {
  name: "conv5"
  type: "Convolution"
  bottom: "conv4"
  top: "conv5"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu5"
  type: "ReLU"
  bottom: "conv5"
  top: "conv5"
}
layer {
  name: "fc6"
  type: "InnerProduct"
  bottom: "conv5"
  top: "fc6"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "relu6"
  type: "ReLU"
  bottom: "fc6"
  top: "fc6"
}
layer {
  name: "drop6"
  type: "Dropout"
  bottom: "fc6"
  top: "fc6"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_1"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7_1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu7_1"
  type: "ReLU"
  bottom: "fc7_1"
  top: "fc7_1"
}
layer {
  name: "drop7_1"
  type: "Dropout"
  bottom: "fc7_1"
  top: "fc7_1"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_2"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7_2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu7_2"
  type: "ReLU"
  bottom: "fc7_2"
  top: "fc7_2"
}
layer {
  name: "drop7_2"
  type: "Dropout"
  bottom: "fc7_2"
  top: "fc7_2"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_3"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7_3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu7_3"
  type: "ReLU"
  bottom: "fc7_3"
  top: "fc7_3"
}
layer {
  name: "drop7_3"
  type: "Dropout"
  bottom: "fc7_3"
  top: "fc7_3"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_4"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7_4"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu7_4"
  type: "ReLU"
  bottom: "fc7_4"
  top: "fc7_4"
}
layer {
  name: "drop7_4"
  type: "Dropout"
  bottom: "fc7_4"
  top: "fc7_4"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_5"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7_5"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu7_5"
  type: "ReLU"
  bottom: "fc7_5"
  top: "fc7_5"
}
layer {
  name: "drop7_5"
  type: "Dropout"
  bottom: "fc7_5"
  top: "fc7_5"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_6"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7_6"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu7_6"
  type: "ReLU"
  bottom: "fc7_6"
  top: "fc7_6"
}
layer {
  name: "drop7_6"
  type: "Dropout"
  bottom: "fc7_6"
  top: "fc7_6"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7_7"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7_7"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu7_7"
  type: "ReLU"
  bottom: "fc7_7"
  top: "fc7_7"
}
layer {
  name: "drop7_7"
  type: "Dropout"
  bottom: "fc7_7"
  top: "fc7_7"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc8_1"
  type: "InnerProduct"
  bottom: "fc7_1"
  top: "fc8_1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 31
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "fc8_2"
  type: "InnerProduct"
  bottom: "fc7_2"
  top: "fc8_2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 24
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "fc8_3"
  type: "InnerProduct"
  bottom: "fc7_3"
  top: "fc8_3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 34
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "fc8_4"
  type: "InnerProduct"
  bottom: "fc7_4"
  top: "fc8_4"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 34
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "fc8_5"
  type: "InnerProduct"
  bottom: "fc7_5"
  top: "fc8_5"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 34
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "fc8_6"
  type: "InnerProduct"
  bottom: "fc7_6"
  top: "fc8_6"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 34
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "fc8_7"
  type: "InnerProduct"
  bottom: "fc7_7"
  top: "fc8_7"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 34
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "accuracy_1"
  type: "Accuracy"
  bottom: "fc8_1"
  bottom: "label_1"
  top: "accuracy_1"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_2"
  type: "Accuracy"
  bottom: "fc8_2"
  bottom: "label_2"
  top: "accuracy_2"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_3"
  type: "Accuracy"
  bottom: "fc8_3"
  bottom: "label_3"
  top: "accuracy_3"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_4"
  type: "Accuracy"
  bottom: "fc8_4"
  bottom: "label_4"
  top: "accuracy_4"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_5"
  type: "Accuracy"
  bottom: "fc8_5"
  bottom: "label_5"
  top: "accuracy_5"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_6"
  type: "Accuracy"
  bottom: "fc8_6"
  bottom: "label_6"
  top: "accuracy_6"
  include {
    phase: TEST
  }
}
layer {
  name: "accuracy_7"
  type: "Accuracy"
  bottom: "fc8_7"
  bottom: "label_7"
  top: "accuracy_7"
  include {
    phase: TEST
  }
}
layer {
  name: "loss_1"
  type: "SoftmaxWithLoss"
  bottom: "fc8_1"
  bottom: "label_1"
  top: "loss_1"
  loss_weight: 0.2
}
layer {
  name: "loss_2"
  type: "SoftmaxWithLoss"
  bottom: "fc8_2"
  bottom: "label_2"
  top: "loss_2"
  loss_weight: 0.2
}
layer {
  name: "loss_3"
  type: "SoftmaxWithLoss"
  bottom: "fc8_3"
  bottom: "label_3"
  top: "loss_3"
  loss_weight: 0.2
}
layer {
  name: "loss_4"
  type: "SoftmaxWithLoss"
  bottom: "fc8_4"
  bottom: "label_4"
  top: "loss_4"
  loss_weight: 0.2
}
layer {
  name: "loss_5"
  type: "SoftmaxWithLoss"
  bottom: "fc8_5"
  bottom: "label_5"
  top: "loss_5"
  loss_weight: 0.2
}
layer {
  name: "loss_6"
  type: "SoftmaxWithLoss"
  bottom: "fc8_6"
  bottom: "label_6"
  top: "loss_6"
  loss_weight: 0.2
}
layer {
  name: "loss_7"
  type: "SoftmaxWithLoss"
  bottom: "fc8_7"
  bottom: "label_7"
  top: "loss_7"
  loss_weight: 0.2
}
  • 有两个问题需要总结下：
    • AlexNet在conv5之后又一个pool5层，但是到conv5之后，图片的边界已经不足以再做池化，所以去掉了pool5层；
    • 第一次训练的时候忘记修改最后fc层输出的num_output参数，导致特征分类出现问题。七个fc层的num_output分别是31、24、34、34、34、34、34，分别对应各自标签的类别。

solver修改为如下所示，再修改相应的deploy网络结构，就可以开始训练了。

net: "examples/plate_e2e/train_val_e2e.prototxt"
test_iter: 130
test_interval: 100
base_lr: 0.001
lr_policy: "step"
gamma: 0.1
stepsize: 3000
display: 10
max_iter: 15000
momentum: 0.9
weight_decay: 0.0005
snapshot: 3000
snapshot_prefix: "examples/plate_e2e/plate_e2e"
solver_mode: GPU

三、训练

#!/usr/bin/env sh

TOOLS=./build/tools

$TOOLS/caffe train --solver=examples/plate_e2e/solver_e2e.prototxt -gpu all

四、测试

def Test(img):
    # 加载模型
    net = caffe.Net(deploy, caffe_model, caffe.TEST)

    # 注意可以调节预处理批次的大小
    # 由于是处理一张图片，所以把原来的10张的批次改为1
    net.blobs['data'].reshape(1, 3, 36, 136)

    # 加载图片到数据层
    im = cv2.imread(img)
    images = np.array([im.reshape(3, 36, 136)], dtype=np.float32)
    meanValue = mean()
    net.blobs['data'].data[...] =  images - meanValue

    # 前向计算
    out = net.forward()

    # 预测分类
    result = []
    result.append(out['prob_1'].argmax())
    result.append(out['prob_2'].argmax())
    result.append(out['prob_3'].argmax())
    result.append(out['prob_4'].argmax())
    result.append(out['prob_5'].argmax())
    result.append(out['prob_6'].argmax())
    result.append(out['prob_7'].argmax())

    return result

最后的测试结果并不好，还需要对网络结构进行修改和构建，数据集也需要重新扩充，后期会进行更新。

冷月葬婲魂
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
深度学习Caffe实战笔记（2）用LeNet跑车牌识别数据
gybheroin的博客
01-05 1万+
caffe实战之“车牌识别” 上一篇博客写了如何在cpu的情况下配置环境，配置好环境后编译成功，就可以用caffe框架训练卷积神经网络了。今天介绍如何在caffe环境下，跑车牌识别的数据，利用的网络是LeNet，这里只介绍具体caffe实战步骤，网络结构不做具体介绍。1、准备数据在caffe根目录下的data文件夹下新建一个mine文件夹，在mine文件夹新建一个train和val文件夹，在tra
基于caffe框架深度学习的物体识别源码
09-09
本项目是基于Caffe框架实现的物体识别系统，尤其针对超市中的水果和蔬菜进行自动识别，适用于提升自助秤重的智能化水平。Caffe是一个高效、开源的深度学习库，由加州大学伯克利分校开发，它在速度和精度之间取得了很...
基于caffe lenet 中文车牌字符识别实现
03-25
博客地址:https://blog.csdn.net/HUXINY/article/details/88669086 基于caffe lenet 中文车牌字符识别实现，包括数据集，训练好的网络模型
基于caffe实现改进的mtcnn完成车牌识别.docx
05-10
博主https://blog.csdn.net/zhubenfulovepoem/article/details/81234977，文中涉及到“基于颜色定位和形态学定位改进后的mtcnn车牌定位算法”说明。
深度学习之基于Tensorflow卷积神经网络(CNN)的车牌识别系统
最新发布
qq1744828575的博客
05-25 389
一、项目背景与目标车牌识别系统是智能交通系统的重要组成部分，广泛应用于停车场管理、道路监控、车辆追踪等场景。传统的车牌识别方法通常基于图像处理技术和模板匹配算法，但这些方法在处理复杂背景、光照变化、车牌污损等问题时存在较大的局限性。随着深度学习技术的发展，基于CNN的车牌识别系统以其优异的性能逐渐成为研究的热点。本项目旨在利用TensorFlow深度学习框架，构建并训练一个基于CNN的车牌识别系统。该系统能够自动检测图像中的车牌位置，并准确识别车牌上的字符信息。
用caffe框架做号牌识别笔记
tudou880306的专栏
03-27 279
最近在看号牌识别相关的内容，所以记录一下相关步骤和注意事项（怕忘记） 之前研究过tesseract-ocr,但是样本标注是个很费力的事情，需要用到jTessBoxEditor工具，一个一个字符的去标注，像下面这样 而且我标注完后，发现识别率并不高，可能是我数据处理有问题或步骤有问题，后来开始考虑用caffe来做，之前都是用来做目标分类的，然后在github上发现有人做了这个项...
端到端的语音识别建模
weixin_44223902的博客
11-21 424
端到端语音识别的输入和输出 输入：主流的输入特征是fbank.一些论文中也用MFCC以及raw waveform.fbank特征的处理过程一般是对一段语音进行进行预加重、分帧、加窗、短时傅里叶变换、mel滤波、去均值等。一个fbank向量往往对应10ms的语音。 输出：可以是字母，子词，词等等，目前以子词（subword)当作输出比较流行。 ...
caffe多标签源码_image_data_layer
02-01
"caffe多标签源码_image_data_layer"的标题表明我们关注的是对Caffe的原始代码进行修改，以便使其`image_data_layer`能够处理多标签输入，这通常在进行回归任务时会用到。`image_data_layer`是Caffe中的一个核心组件...
caffe多标签-image_data_layer
02-01
标题"caffe多标签-image_data_layer"提示我们需要扩展Caffe的`image_data_layer`，使其能够处理这样的多标签输入。 首先，要理解多标签任务的基本概念。在多标签学习中，一个样本可以属于多个类，这与二元分类（每...
端到端语音识别模型LAS（listen-attention-spell）
weixin_47276710的博客
10-08 1529
端到端语音识别模型LAS概述和代码实现（pytorch）
端到端的语音识别模型
weixin_44070509的博客
01-11 4078
端到端的语音识别模型CTC（李宏毅深度学习HLP课程笔记） 一、CTC 1、模型介绍 CTC可以用于在线流式语音识别，因此encoder部分需要选择uni-directional RNN，模型结构图如下，输入的语音信号经过encoder逐一转换成语音表征，再经过一个线性分类器得到每个时刻输出类别的概率，假设所有的类别个数为V： 一般来说，假设输入的语音长度a，对应的输出label长度为b，则由于语音帧比较长，识别出来的文字序列相对来说较短，所以b << a。在CTC模型中，为了解决alignm
基于深度学习的车牌识别_朱旭辰
11-01
基于深度学习的车牌识别_朱旭辰 仅用于学习交流，禁止商业用途
基于Open CV 3 训练的车牌识别SVM模型
02-24
基于OpenCV3的SVM训练出来的车牌识别模型，能识别全国各地蓝底白字的车牌类型。
基于深度学习的车牌识别
08-30
目标识别是计算机视觉一个重要的研究领域，由此延伸出的车辆型号识别具有重 要的实际应用价值，特别是在当今交通状况复杂的大城市，智能交通系统成为发展趋 势，这离不开对车辆型号进行识别和分类的工作，本文围绕如何利用计算机视觉的方 法进行车辆型号的识别和分类展开了一系列研究： 本文对当前的目标识别和分类的特征和算法做了总结和归纳。分析比较了作为图 像特征描述常见的特征算子，总结归纳了他们的提取方法、特征性能以及相互之间的 关联。另外，介绍了在目标识别工作中常用的分类方法,阐述了他们各自的原理和工作 方法。研究了深度神经网络的理论依据，分析比较了深度神经网络不同的特征学习方 法，以及卷积神经网络的训练方法。分析比较不同特征学习方法的特点选取 k-means 作为本文使用的特征学习方法，利用卷积神经网络结构搭建深度学习模型，进行车辆 车型识别工作。 本文为了测试基于深度学习的车辆型号分类算法的性能在 30 个不同型号共 7158 张图片上进行实验；并在相同数据上利用改进了的 SIFT 特征匹配的算法进行对比实验； 进过实验测试，深度学习方法在进行车型分类的实验中取得 94%的正确率，并在与 SIFT 匹配实验结果对比后进一步证实：深度学习的方法能够应用在车辆型号识别领域
基于C++编程实现车牌牌照的检索
12-10
用C++编程实现车牌牌照的检索，截取车牌牌照，并进行预处理。里面包含详细的程序注释和具体的实现步骤，可以顺利执行，实现效果不错。
车牌识别代码（可直接运行使用）
06-28
步骤一 解压代码，放到合适的路径（不要有中文路径），打开代码，找到CNN_NeuralNet.py里的train_flag = 0 net = char_cnn_net() 语句，将0改成1后运行CNN_NeuralNet.py执行训练步骤，然后再将1改成0后在执行一遍CNN_NeuralNet.py。 步骤二 找到GUI.py直接运行，然后取文件夹中的images中的pictures中的图片进行识别即可 步骤三 识别效果不佳时可以再次执行步骤一中的训练，或者自己改进
Caffe | 多标签训练的三种策略
yuanCruise
01-20 1349
0.多标签问题 在很多深度学习任务中会用到多标签学习，比如做目标检测任务，如下图所示，图片1中物体类别为1，剩余的四个为其位置坐标。图片2中物体类别为2，剩余的四个为其位置坐标。所以即使一张图片中只有一个目标但其仍然是多标签学习问题。 0000001.jpg 1 72 79 232 273 0000002.jpg 2 67 59 155 161 还有一种多标签问题是利用人脸的某些特性来辅助人脸特...
Caffe实现多标签分类
josiechen的博客
09-27 1245
任务我这里给出一个具体的任务咯，要求在以下图片中，识别出汽车品牌和车辆外形。汽车品牌分为：Benz/BMW/Audi 车辆外形分为：Sedan/SUV。这是一个只有72张图片的小数据库,包括了测试和训练集： 这里写图片描述 其中标注是这样的，Audi=0，BMW=1，Benz=2. Sedan =0, SUV=1。所以如果这辆车是奥迪的SUV，标注就是： xx.jpg 0 1。在数据库中，标注已经做
caffe多任务、多标签
weixin_34124651的博客
02-28 182
2019独角兽企业重金招聘Python工程师标准>>> ...
高性能算法-深度学习(DOC37页).doc
02-03
高性能算法-深度学习(DOC37页).doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值