caffe实现多标签分类：制作LMDB的方式

最新推荐文章于 2019-07-10 21:21:10 发布
最新推荐文章于 2019-07-10 21:21:10 发布
阅读量866 收藏 1
点赞数
分类专栏： caffe自定义层 文章标签： caffe

Caffe自带的图像转LMDB接口只支持单label，对于多label的任务，可以使用HDF5的格式，也可以通过修改caffe代码来实现，　我的文章Caffe 实现多标签分类　里介绍了怎么通过修改ImageDataLayer来实现Multilabel的任务，　本篇文章介绍怎么通过修改DataLayer来实现带Multilabel的ＬＭＤＢ格式数据输入的分类任务

１．　首先修改代码

        修改下面的几个文件：

        $CAFFE_ROOT/src/caffe/proto/caffe.proto

        $CAFFE_ROOT/src/caffe/layers/data_layer.cpp

        $CAFFE_ROOT/src/caffe/util/io.cpp

        $CAFFE_ROOT/include/caffe/util/io.hpp

        $CAFFE_ROOT/tools/convert_imageset.cpp

　　(1) 修改　caffe.proto

              在　message Datum { }里添加用于容纳labels的一项

　　　　repeated float labels = 8;

          如果你的Label只有int类型，可以用　repeated int32 labels = 8; 

　(2) 修改　data_layer.cpp

         修改函数　DataLayerSetUp()

         新的代码：

vector<int> label_shape(2);
label_shape[0] = batch_size;
label_shape[1] = datum.labels_size();
　　　代码修改前后，右边是修改后的代码


        修改函数　　load_batch()

　　新的代码：

int labelSize = datum.labels_size();
for(int i = 0; i < labelSize; i++){
     top_label[item_id*labelSize + i] = datum.labels(i);
}
代码修改前后，右边是修改后的代码


　　(3) 修改　io.hpp

　　　新的代码

bool ReadFileToDatum(const string& filename, const vector<float> label, Datum* datum);
 
inline bool ReadFileToDatum(const string& filename, Datum* datum) {
  return ReadFileToDatum(filename, vector<float>(), datum);
}
 
bool ReadImageToDatum(const string& filename, const vector<float> label,
    const int height, const int width, const bool is_color,
    const std::string & encoding, Datum* datum);
 
inline bool ReadImageToDatum(const string& filename, const vector<float> label,
    const int height, const int width, const bool is_color, Datum* datum) {
  return ReadImageToDatum(filename, label, height, width, is_color,
                          "", datum);
}
 
inline bool ReadImageToDatum(const string& filename, const vector<float> label,
    const int height, const int width, Datum* datum) {
  return ReadImageToDatum(filename, label, height, width, true, datum);
}
 
inline bool ReadImageToDatum(const string& filename, const vector<float> label,
    const bool is_color, Datum* datum) {
  return ReadImageToDatum(filename, label, 0, 0, is_color, datum);
}
 
inline bool ReadImageToDatum(const string& filename, const vector<float> label,
    Datum* datum) {
  return ReadImageToDatum(filename, label, 0, 0, true, datum);
}
 
inline bool ReadImageToDatum(const string& filename, const vector<float> label,
    const std::string & encoding, Datum* datum) {
  return ReadImageToDatum(filename, label, 0, 0, true, encoding, datum);
}
代码修改前后，右边是修改后的代码

　　(4) 修改　io.cpp

　　　修改函数　ReadImageToDatum()

　　　修改后的代码

bool ReadImageToDatum(const string& filename, const vector<float> label,
    const int height, const int width, const bool is_color,
    const std::string & encoding, Datum* datum) {
  cv::Mat cv_img = ReadImageToCVMat(filename, height, width, is_color);
  if (cv_img.data) {
    if (encoding.size()) {
      if ( (cv_img.channels() == 3) == is_color && !height && !width &&
          matchExt(filename, encoding) )
        return ReadFileToDatum(filename, label, datum);
      std::vector<uchar> buf;
      cv::imencode("."+encoding, cv_img, buf);
      datum->set_data(std::string(reinterpret_cast<char*>(&buf[0]),
                      buf.size()));
      
      datum->clear_labels();
      for (int i = 0; i < label.size(); i++){
         datum->add_labels(label[i]);
      }     
      datum->set_encoded(true);
      return true;
    }
    CVMatToDatum(cv_img, datum);
    
    datum->clear_labels();
    for (int i = 0; i < label.size(); i++){
       datum->add_labels(label[i]);
    }     
    return true;
  } else {
    return false;
  }
}
代码修改前后，右边是修改后的代码

　　修改函数　ReadFileToDatum()

　　修改后的代码

bool ReadFileToDatum(const string& filename, const vector<float> label,
    Datum* datum) {
  std::streampos size;
 
  fstream file(filename.c_str(), ios::in|ios::binary|ios::ate);
  if (file.is_open()) {
    size = file.tellg();
    std::string buffer(size, ' ');
    file.seekg(0, ios::beg);
    file.read(&buffer[0], size);
    file.close();
    datum->set_data(buffer);
    
    datum->clear_labels();
    for (int i = 0; i < label.size(); i++){
       datum->add_labels(label[i]);
    }  
    datum->set_encoded(true);
    return true;
  } else {
    return false;
  }
}
　　　代码修改前后，右边是修改后的代码


　　
　　(5) 修改 convert_imageset.cpp

              修改部分新的代码

std::vector<std::pair<std::string, vector<float> > > lines;
  std::string line, filename;
  
  float label;
  while (std::getline(infile, line)) {
    std::istringstream iss(line);
    iss >> filename;
    std::vector<float> labels;
    while(iss >> label) {
       labels.push_back(label);
    }
    lines.push_back(std::make_pair(filename, labels));
  }
　　　代码修改前后，右边是修改后的代码

2. 编译代码

mark@ubuntu:~/caffe/build$ make all
mark@ubuntu:~/caffe/build$ sudo make install

3. 生成ＬＭＤＢ文件

编译成功后，使用新生成的 convert_imageset 将训练所用的图片转换成ＬＭＤＢ文件

将训练所用图片转换为ＬＭＤＢ文件

mark@ubuntu:~/caffe$ sudo ./build/tools/convert_imageset -shuffle=true  /home/mark/data/  /home/mark/data/train.txt  ./examples/captcha/captcha_train_lmdb

/home/mark/data/　                 是训练所用的图片所在的root目录
/home/mark/data/train.txt　　记录每个训练图片文件的名称和标签，它的内容见下图，训练图片文件的名称和/home/mark/data/拼接起来是训练图片的绝对路径
./examples/captcha/captcha_train_lmdb 是生成的lmdb文件所在目录

同样可以将测试图片转换成ＬＭＤＢ文件

mark@ubuntu:~/caffe$ sudo ./build/tools/convert_imageset -shuffle=true  /home/mark/data/  /home/mark/data/test.txt  ./examples/captcha/captcha_test_lmdb

4. 网络结构和solver

网络结构文件　captcha_train_test_lmdb.prototxt

name: "captcha"
layer {  
  name: "Input"  
  type: "Data"  
  top: "data"  
  top: "label"  
  include {  
    phase: TRAIN  
  }  
  transform_param {  
    scale: 0.00390625
  }  
  data_param {  
    source: "examples/captcha/captcha_train_lmdb"    
    batch_size: 50
    backend: LMDB
  }  
}  

layer {  
  name: "Input"  
  type: "Data"  
  top: "data"  
  top: "label"  
  include {  
    phase: TEST  
  }  
  transform_param {  
    scale: 0.00390625
  }  
  data_param {  
    source: "examples/captcha/captcha_test_lmdb"    
    batch_size: 20
    backend: LMDB
  }  
}    

layer {
  name: "slice"
  type: "Slice"
  bottom: "label"
  top: "label_1"
  top: "label_2"
  top: "label_3"
  top: "label_4"
  slice_param {
    axis: 1
    slice_point:1
    slice_point:2
    slice_point:3
  }
} 

layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 20
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "pool1"
  top: "conv2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 50
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "ip1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "ip1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "ip1"
  top: "ip1"
}

layer {
  name: "ip2"
  type: "InnerProduct"
  bottom: "ip1"
  top: "ip2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 100
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_1"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_2"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_3"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_3"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_4"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_4"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "accuracy1"
  type: "Accuracy"
  bottom: "ip3_1"
  bottom: "label_1"
  top: "accuracy1"
  include {
    phase: TEST
  }
}
layer {
  name: "loss1"
  type: "SoftmaxWithLoss"
  bottom: "ip3_1"
  bottom: "label_1"
  top: "loss1"
}

layer {
  name: "accuracy2"
  type: "Accuracy"
  bottom: "ip3_2"
  bottom: "label_2"
  top: "accuracy2"
  include {
    phase: TEST
  }
}
layer {
  name: "loss2"
  type: "SoftmaxWithLoss"
  bottom: "ip3_2"
  bottom: "label_2"
  top: "loss2"
}

layer {
  name: "accuracy3"
  type: "Accuracy"
  bottom: "ip3_3"
  bottom: "label_3"
  top: "accuracy3"
  include {
    phase: TEST
  }
}
layer {
  name: "loss3"
  type: "SoftmaxWithLoss"
  bottom: "ip3_3"
  bottom: "label_3"
  top: "loss3"
}

layer {
  name: "accuracy4"
  type: "Accuracy"
  bottom: "ip3_4"
  bottom: "label_4"
  top: "accuracy4"
  include {
    phase: TEST
  }
}
layer {
  name: "loss4"
  type: "SoftmaxWithLoss"
  bottom: "ip3_4"
  bottom: "label_4"
  top: "loss4"
}
solver文件　captcha_solver_lmdb.prototxt
# The train/test net protocol buffer definition
net: "examples/captcha/captcha_train_test_lmdb.prototxt"
# test_iter specifies how many forward passes the test should carry out.
# covering the full 9,800 testing images.
test_iter: 200
# Carry out testing every 200 training iterations.
test_interval: 200
# The base learning rate, momentum and the weight decay of the network.
base_lr: 0.001
momentum: 0.9
weight_decay: 0.0005
# The learning rate policy
lr_policy: "inv"
gamma: 0.0001
power: 0.75
# Display every 100 iterations
display: 100
# The maximum number of iterations
max_iter: 10000
# snapshot intermediate results
snapshot: 5000
snapshot_prefix: "examples/captcha/captcha"
# solver mode: CPU or GPU
solver_mode: GPU

5. 开始训练
mark@ubuntu:~/caffe$ sudo ./build/tools/caffe train --solver=examples/captcha/captcha_solver_lmdb.prototxt

训练完后，生成model文件：   captcha_iter_10000.caffemodel

6. 用生成的model 文件进行测试

首先，需要一个deploy.prototxt文件，在captcha_train_test_lmdb.prototxt的基础上修改，修改后保存为　captcha_deploy_lmdb.prototxt  内容如下

name: "captcha"

input: "data"  
input_dim: 1   # batchsize  
input_dim: 3   # number of channels - rgb  
input_dim: 60  # height
input_dim: 160 # width

layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 20
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "pool1"
  top: "conv2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 50
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "ip1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "ip1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "ip1"
  top: "ip1"
}

layer {
  name: "ip2"
  type: "InnerProduct"
  bottom: "ip1"
  top: "ip2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 100
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_1"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_2"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_3"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_3"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "ip3_4"
  type: "InnerProduct"
  bottom: "ip2"
  top: "ip3_4"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

layer {
  name: "prob1"
  type: "Softmax"
  bottom: "ip3_1"
  top: "prob1"
}
layer {
  name: "prob2"
  type: "Softmax"
  bottom: "ip3_2"
  top: "prob2"
}
layer {
  name: "prob3"
  type: "Softmax"
  bottom: "ip3_3"
  top: "prob3"
}
layer {
  name: "prob4"
  type: "Softmax"
  bottom: "ip3_4"
  top: "prob4"
}

编写测试代码：

import numpy as np    
import os    
import sys   
os.environ['GLOG_minloglevel'] = '3'   
import caffe    
    
CAFFE_ROOT = '/home/mark/caffe'    
deploy_file_name = 'captcha_deploy_lmdb.prototxt'    
model_file_name  = 'captcha_iter_10000.caffemodel'   
  
IMAGE_HEIGHT = 60  
IMAGE_WIDTH = 160  
IMAGE_CHANNEL = 3  
  
def classify(imageFileName):  
    deploy_file = CAFFE_ROOT + '/examples/captcha/' + deploy_file_name    
    model_file  = CAFFE_ROOT + '/examples/captcha/' + model_file_name  
    #初始化caffe   
    net = caffe.Net(deploy_file, model_file, caffe.TEST)  
  
    #数据预处理      
    transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})      
    transformer.set_transpose('data', (2, 0, 1))#pycaffe读取的图片文件格式为H×W×C，需转化为C×H×W  
  
    #pycaffe将图片存储为[0, 1], 如果模型输入用的是0~255的原始格式,需要做如下转换  
    #transformer.set_raw_scale('data', 255)     
  
    transformer.set_channel_swap('data', (2, 1, 0))#caffe中图片是BGR格式，而原始格式是RGB，所以要转化   
  
    # 将输入图片格式转化为合适格式（与deploy文件相同）  
    net.blobs['data'].reshape(1, IMAGE_CHANNEL, IMAGE_HEIGHT, IMAGE_WIDTH)  
  
    #读取图片  
    #参数color: True(default)是彩色图，False是灰度图  
    img = caffe.io.load_image(imageFileName, color=True)  
  
    #数据输入、预处理  
    net.blobs['data'].data[...] = transformer.preprocess('data', img)  
  
    #前向迭代，即分类  
    out = net.forward()  
  
    #求出每个标签概率最大值的下标  
    result = []  
    predict1 = out['prob1'][0].argmax()  
    result.append(predict1)  
  
    predict2 = out['prob2'][0].argmax()  
    result.append(predict2)  
  
    predict3 = out['prob3'][0].argmax()  
    result.append(predict3)  
  
    predict4 = out['prob4'][0].argmax()  
    result.append(predict4)      
      
    return result  
          
if __name__ == '__main__':  
  
   imgList = sys.argv[1:]  
   for captcha in imgList:  
       predict = classify(captcha)  
       print "captcha:", captcha, "  predict:", predict 


 
原文：https://blog.csdn.net/sushiqian/article/details/78771546 
 

BigCowPeking
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多标签lmdb数据制作脚本文件
12-12
多标签lmdb数据制作脚本文件
caffe学习系列：训练自己的图片集（超详细教程）
热门推荐
Cche的博客
01-06 6万+
学习的caffe的目的，不是简单的做几个练习，而是最终落实到自己的项目或科研中去。因此，本文介绍一下，从自己的原始图片到lmdb数据，再到训练和测试的整个流程。 一、数据的准备     有条件的同学，可以去ImageNet的官网点击打开链接，下载ImageNet图片来训练。但是我没有下载，因为我注册过程中一直出现bug。     我重新找了500张图片来代替，分为大巴车、恐龙、大象、鲜花和马
caffe下为图像加标签，转换为可执行文件.lmdb格式
爱吃鱼的猫
08-04 9330
caffe对于训练数据格式，支持：lmdb、h5py……，其中lmdb数据格式常用于单标签数据，像分类等，经常使用lmdb的数据格式。对于回归等问题，或者多标签数据，一般使用h5py数据的格式。当然好像还有其它格式的数据可用，本文就主要针对lmdb数据格式的制作方法，进行简单讲解。 以一个简单的例子来介绍一下如何生成自己的图像集。 lmdb数据 lmdb用于单标签数据。为了简
Caffe 实现多标签分类 支持Multi-Label的ＬＭＤＢ数据格式输入
frontworld的博客
12-11 5318
Caffe自带的图像转LMDB接口只支持单label，对于多label的任务，可以使用HDF5的格式，也可以通过修改caffe代码来实现，　我的文章Caffe 实现多标签分类　里介绍了怎么通过修改ImageDataLayer来实现Multilabel的任务，　本篇文章介绍怎么通过修改DataLayer来实现带Multilabel的ＬＭＤＢ格式数据输入的分类任务 １．　首先修改代码       
Caffe中LMDB接口实现多标签数据准备及训练
Hyman's Blog
06-30 1万+
Caffe中使用LMDB实现多标签数据的准备
Caffe制作LMDB数据并进行分类网络训练和测试
jsk_learner的博客
07-10 1652
本篇博客以某项比赛数据、ResNet-50模型为例，讲解了生成自己的train.txt和val.txt文本文件、制作LMDB数据集、生成均值文件、网络训练、网络测试以及使用pycaffe接口进行测试的详细流程。
LMDB_to_TFrecords:将LMDB更改为tfrecords
05-14
LMDB_to_TFrecords 将Caffe LMDB文件更改为tfrecords文件跑步： $ python LMDBtoTFrecords.py --lmdb_path路径/ lmdb_file --output_path路径/output.tfrecords
Caffe多标签分类
01-18
http://blog.csdn.net/shuzfan/article/details/52503683 http://blog.csdn.net/u011762313/article/details/48851015 可参考这两篇博客。
Caffe_MultiLabel_Classification:这是caffe中多标签分类的一个实例。 感谢https中的多标签数据转换工具
05-18
这是caffe中多标签分类的一个实例。 借助HolidayXue的的多标签数据转换工具。 步 1，重新编译 在下载convert_multilabel.cpp，替换convert_imageset.cpp，然后重新编译caffe。 您将获得一个新的exe：convert_...
caffe多标签源码_image_data_layer
02-01
修改caffe源码，使image_data_layer支持多标签输入，主要用于回归任务
Caffe 实现多标签分类
frontworld的博客
12-10 3604
最近在用Ｃａｆｆｅ做验证码识别时，发现没有用Tensorflow简单(tensorflow中可以用one-hot, 参考我的另一篇blog:  http://blog.csdn.net/sushiqian/article/details/78305340 )，需要修改Ｃａｆｆｅ的源码，做完后，觉得也不复杂。 1. 首先，就是修改源码了，本文介绍的方法是修改ImageDataLayer，修改下面的
Caffe中图像写入LMDB（以及多标签）和读取LMDB数据
深藏功与名
11-01 1万+
一个大牛写的教程：《A Practical Introduction to Deep Learning with Caffe and Python》，写的很清晰。 将图像写入LMDB import os import glob import random import numpy as np import cv2 import caffe from caffe.proto im
caffe 根据txt生成多标签LMDB数据
dc90000的博客
04-18 133
1. 前提: 已经准备好train.txt, test.txt文件, 格式如下 此处有坑, 如果是windows下生成txt, 换行符为\r\n, 需要替换成 \n才能在linux运行. 可以使用sed -i "s/\s*$//g" filename统一去掉, 具体参考除去文件中显示的^M符号 已经编译好了支持多标签的caffe, 具体见多标签caffe重新编译 2. 编...
Caffe 中LMDB接口处理多标签（Multi-Label）数据
展翅的空间
02-23 9969
Caffe 中LMDB接口处理多标签（Multi-Label）数据
caffe 实现多标签输入（multilabel、multitask）
GZGlenn的博客
03-23 2万+
caffe 本身并不支持 多类标的输入， 该框架主要用于解决图片分类的问题，而目前，两个重要的问题需要多标签的输入：多任务学习（multi-task）和多标签分类（multi-label），本文针对这两个问题，实现了多标签的输入            目前，网上流行的多标签输入方法主要有以下四种：          1. 最简单，使用mxnet，它本身支持了多标签分类的问题，因此也自带了多标
caffe多标签训练
u014199999的博客
03-02 2012
最近刚接触caffe弄了一个caffe多标签遇到各种蛋疼的问题跟大家分享分享。 一  准备数据这里用的验证码0-9+26个字母字母生成4位数的验证码 二  修改caffe源码涉及到修改的文件有        caffe.proto ,       convert_imageset.cpp,       data_layer.cpp,       io.cpp,       d
caffe多标签训练时注意的点
aboy2018的博客
06-03 156
https://blog.csdn.net/m0_37192554/article/details/85702123
深度学习caffe实战（一）验证码识别
HamTam12
02-22 1万+
利用深度神经网络，多任务学习，进行验证码识别
caffe/caffe.hpp: No such file or directory
最新发布
03-20
caffe/caffe.hpp是Caffe深度学习框架的头文件之一，它包含了Caffe框架的主要功能和接口。如果你在编译或者运行代码时遇到了"caffe/caffe.hpp: No such file or directory"的错误提示，可能是因为编译器无法找到该...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值