caffe: unknown layer type/unknown solver type

最新推荐文章于 2022-10-30 11:10:42 发布
最新推荐文章于 2022-10-30 11:10:42 发布
阅读量5.3k 收藏 3
点赞数 3
分类专栏： Caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/raby_gyl/article/details/63262374
版权

Only for windows

caffe 通过定义静态全局对象的形式（利用对象的构造函数），来创建一个静态类型的变量map<type,creator>来存储其所支持的层类型和解决器类型：

static LayerRegisterer<float> g_creator_f_##type(#type, creator<float>);    
static LayerRegisterer<double> g_creator_d_##type(#type, creator<double>)

VS编译生成caffe的静态库lib的时候，不会初始化上面的静态全局对象，也就是不会调用LayerRegisterer/LayerRegisterer的构造函数。其中LayerRegisterer的构造函数如下，其完成的功能是向静态容器（map<type,creator>）中添加键值对，键为string类型，如”PowerLayer”，creator是一个函数指针（函数是用来new一个PowerLayer类对象）。因为静态库不会初始化静态全局对象，因此使用编译的lib会报unknown layer type/unknown solver type 的错误，即在容器中找不到层类型或解决器类型。

template <typename Dtype>
LayerRegisterer<Dtype>::LayerRegisterer(
    const string& type,
    shared_ptr<Layer<Dtype> > (*creator)(const LayerParameter&)) {
  // LOG(INFO) << "Registering layer type: " << type;
  LayerRegistry<Dtype>::AddCreator(type, creator);
}

使用caffe.lib出现的问题：
例如：

  1. unknown solver type: SGD
  2. unknown layer type: Data

等等类似的问题。

方法1：使用caffe.lib,但是加入下面的头文件：

caffe_reg.h

#ifndef CAFFE_REG_H
#define CAFFE_REG_H

//layer

#include<caffe/layers/conv_layer.hpp> 
#include<caffe/layers/pooling_layer.hpp>
#include<caffe/layers/lrn_layer.hpp>
#include<caffe/layers/relu_layer.hpp>
#include<caffe/layers/sigmoid_layer.hpp>
#include<caffe/layers/softmax_layer.hpp>
#include<caffe/layers/tanh_layer.hpp>
#include<caffe/layers/python_layer.hpp>
#include<caffe/layers/absval_layer.hpp>
#include<caffe/layers/accuracy_layer.hpp>
#include<caffe/layers/argmax_layer.hpp>
#include<caffe/layers/batch_norm_layer.hpp>
#include<caffe/layers/batch_reindex_layer.hpp>
#include<caffe/layers/bias_layer.hpp>
#include<caffe/layers/bnll_layer.hpp>
#include<caffe/layers/concat_layer.hpp>
#include<caffe/layers/contrastive_loss_layer.hpp>
#include<caffe/layers/crop_layer.hpp>
#include<caffe/layers/data_layer.hpp>
#include<caffe/layers/deconv_layer.hpp>
#include<caffe/layers/dropout_layer.hpp>
#include<caffe/layers/dummy_data_layer.hpp>
#include<caffe/layers/eltwise_layer.hpp>
#include<caffe/layers/elu_layer.hpp>
#include<caffe/layers/embed_layer.hpp>
#include<caffe/layers/euclidean_loss_layer.hpp>
#include<caffe/layers/exp_layer.hpp>
#include<caffe/layers/filter_layer.hpp>
#include<caffe/layers/flatten_layer.hpp>
#include<caffe/layers/hdf5_data_layer.hpp>
#include<caffe/layers/hdf5_output_layer.hpp>
#include<caffe/layers/hinge_loss_layer.hpp>
#include<caffe/layers/im2col_layer.hpp>
#include<caffe/layers/image_data_layer.hpp>
#include<caffe/layers/infogain_loss_layer.hpp>
#include<caffe/layers/inner_product_layer.hpp>
#include<caffe/layers/input_layer.hpp>
#include<caffe/layers/log_layer.hpp>
#include<caffe/layers/lstm_layer.hpp>
#include<caffe/layers/memory_data_layer.hpp>
#include<caffe/layers/multinomial_logistic_loss_layer.hpp>
#include<caffe/layers/mvn_layer.hpp>
#include<caffe/layers/parameter_layer.hpp>
#include<caffe/layers/power_layer.hpp>
#include<caffe/layers/prelu_layer.hpp>
#include<caffe/layers/reduction_layer.hpp>
#include<caffe/layers/reshape_layer.hpp>
#include<caffe/layers/rnn_layer.hpp>
#include<caffe/layers/scale_layer.hpp>
#include<caffe/layers/sigmoid_cross_entropy_loss_layer.hpp>
#include<caffe/layers/silence_layer.hpp>
#include<caffe/layers/slice_layer.hpp>
#include<caffe/layers/softmax_loss_layer.hpp>
#include<caffe/layers/split_layer.hpp>
#include<caffe/layers/spp_layer.hpp>
#include<caffe/layers/threshold_layer.hpp>
#include<caffe/layers/tile_layer.hpp>
#include<caffe/layers/window_data_layer.hpp>

//solver
#include<caffe/sgd_solvers.hpp>


namespace caffe
{
    // 59 layers
    extern INSTANTIATE_CLASS(ConvolutionLayer);
    extern INSTANTIATE_CLASS(PoolingLayer);
    extern INSTANTIATE_CLASS(LRNLayer);
    extern INSTANTIATE_CLASS(ReLULayer);
    extern INSTANTIATE_CLASS(SigmoidLayer);
    extern INSTANTIATE_CLASS(SoftmaxLayer);
    extern INSTANTIATE_CLASS(TanHLayer);
    extern INSTANTIATE_CLASS(PythonLayer);
    extern INSTANTIATE_CLASS(AbsValLayer);
    extern INSTANTIATE_CLASS(AccuracyLayer);
    extern INSTANTIATE_CLASS(ArgMaxLayer);
    extern INSTANTIATE_CLASS(BatchNormLayer);
    extern INSTANTIATE_CLASS(BatchReindexLayer);
    extern INSTANTIATE_CLASS(BiasLayer);
    extern INSTANTIATE_CLASS(BNLLLayer);
    extern INSTANTIATE_CLASS(ConcatLayer);
    extern INSTANTIATE_CLASS(ContrastiveLossLayer);
    extern INSTANTIATE_CLASS(CropLayer);
    extern INSTANTIATE_CLASS(DataLayer);
    extern INSTANTIATE_CLASS(DeconvolutionLayer);
    extern INSTANTIATE_CLASS(DropoutLayer);
    extern INSTANTIATE_CLASS(DummyDataLayer);
    extern INSTANTIATE_CLASS(EltwiseLayer);
    extern INSTANTIATE_CLASS(ELULayer);
    extern INSTANTIATE_CLASS(EmbedLayer);
    extern INSTANTIATE_CLASS(EuclideanLossLayer);
    extern INSTANTIATE_CLASS(ExpLayer);
    extern INSTANTIATE_CLASS(FilterLayer);
    extern INSTANTIATE_CLASS(FlattenLayer);
    extern INSTANTIATE_CLASS(HDF5DataLayer);
    extern INSTANTIATE_CLASS(HDF5OutputLayer);
    extern INSTANTIATE_CLASS(HingeLossLayer);
    extern INSTANTIATE_CLASS(Im2colLayer);
    extern INSTANTIATE_CLASS(ImageDataLayer);
    extern INSTANTIATE_CLASS(InfogainLossLayer);
    extern INSTANTIATE_CLASS(InnerProductLayer);
    extern INSTANTIATE_CLASS(InputLayer);
    extern INSTANTIATE_CLASS(LogLayer);
    extern INSTANTIATE_CLASS(LSTMLayer);
    extern INSTANTIATE_CLASS(LSTMUnitLayer);
    extern INSTANTIATE_CLASS(MemoryDataLayer);
    extern INSTANTIATE_CLASS(MultinomialLogisticLossLayer);
    extern INSTANTIATE_CLASS(MVNLayer);
    extern INSTANTIATE_CLASS(ParameterLayer);
    extern INSTANTIATE_CLASS(PowerLayer);
    extern INSTANTIATE_CLASS(PReLULayer);
    extern INSTANTIATE_CLASS(ReductionLayer);
    extern INSTANTIATE_CLASS(ReshapeLayer);
    extern INSTANTIATE_CLASS(RNNLayer);
    extern INSTANTIATE_CLASS(ScaleLayer);
    extern INSTANTIATE_CLASS(SigmoidCrossEntropyLossLayer);
    extern INSTANTIATE_CLASS(SilenceLayer);
    extern INSTANTIATE_CLASS(SliceLayer);
    extern INSTANTIATE_CLASS(SoftmaxWithLossLayer);
    extern INSTANTIATE_CLASS(SplitLayer);
    extern INSTANTIATE_CLASS(SPPLayer);
    extern INSTANTIATE_CLASS(ThresholdLayer);
    extern INSTANTIATE_CLASS(TileLayer);
    extern INSTANTIATE_CLASS(WindowDataLayer);

    // 6 sovlers
    extern INSTANTIATE_CLASS(AdaDeltaSolver);
    extern INSTANTIATE_CLASS(AdaGradSolver);
    extern INSTANTIATE_CLASS(AdamSolver);
    extern INSTANTIATE_CLASS(NesterovSolver);
    extern INSTANTIATE_CLASS(RMSPropSolver);
    extern INSTANTIATE_CLASS(SGDSolver);
}

#endif

该方法利用主程序引用即初始化的原理。
很奇怪的是，通过上述的方法，我们发现除了Data和Parameter层不能注册，其他的57个层都能注册。如下：
这里写图片描述

将这两个的extern声明替换为注册：

REGISTER_LAYER_CLASS(Data);
REGISTER_LAYER_CLASS(Parameter);

这样调用的话会触发源文件中全局静态对象的实例化，因为静态变量的作用于是本源文件，因此不会触发变量的重定义问题。但是通不过caffe中layer_factory.cpp中的AddCreator函数中的：

CHECK_EQ(registry.count(type), 0) << "Layer type " << type
                       << " already registered.";

因此，我们屏蔽掉这条语句，然后将后面的语句修改为：

 if (registry.count(type) == 0)
  {
      registry[type] = creator;;
  }
  else
  {
      return;
  }

即如果没有注册就注册，注册过了就返回。
然而重新编译caffe。

注释：

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

完整的caffe_reg.h如下：

#pragma once
#ifndef CAFFE_REG_H
#define CAFFE_REG_H

//layer

#include<caffe/layers/conv_layer.hpp> 
#include<caffe/layers/pooling_layer.hpp>
#include<caffe/layers/lrn_layer.hpp>
#include<caffe/layers/relu_layer.hpp>
#include<caffe/layers/sigmoid_layer.hpp>
#include<caffe/layers/softmax_layer.hpp>
#include<caffe/layers/tanh_layer.hpp>
#include<caffe/layers/python_layer.hpp>
#include<caffe/layers/absval_layer.hpp>
#include<caffe/layers/accuracy_layer.hpp>
#include<caffe/layers/argmax_layer.hpp>
#include<caffe/layers/batch_norm_layer.hpp>
#include<caffe/layers/batch_reindex_layer.hpp>
#include<caffe/layers/bias_layer.hpp>
#include<caffe/layers/bnll_layer.hpp>
#include<caffe/layers/concat_layer.hpp>
#include<caffe/layers/contrastive_loss_layer.hpp>
#include<caffe/layers/crop_layer.hpp>
#include<caffe/layers/data_layer.hpp>
#include<caffe/layers/deconv_layer.hpp>
#include<caffe/layers/dropout_layer.hpp>
#include<caffe/layers/dummy_data_layer.hpp>
#include<caffe/layers/eltwise_layer.hpp>
#include<caffe/layers/elu_layer.hpp>
#include<caffe/layers/embed_layer.hpp>
#include<caffe/layers/euclidean_loss_layer.hpp>
#include<caffe/layers/exp_layer.hpp>
#include<caffe/layers/filter_layer.hpp>
#include<caffe/layers/flatten_layer.hpp>
#include<caffe/layers/hdf5_data_layer.hpp>
#include<caffe/layers/hdf5_output_layer.hpp>
#include<caffe/layers/hinge_loss_layer.hpp>
#include<caffe/layers/im2col_layer.hpp>
#include<caffe/layers/image_data_layer.hpp>
#include<caffe/layers/infogain_loss_layer.hpp>
#include<caffe/layers/inner_product_layer.hpp>
#include<caffe/layers/input_layer.hpp>
#include<caffe/layers/log_layer.hpp>
#include<caffe/layers/lstm_layer.hpp>
#include<caffe/layers/memory_data_layer.hpp>
#include<caffe/layers/multinomial_logistic_loss_layer.hpp>
#include<caffe/layers/mvn_layer.hpp>
#include<caffe/layers/parameter_layer.hpp>
#include<caffe/layers/power_layer.hpp>
#include<caffe/layers/prelu_layer.hpp>
#include<caffe/layers/reduction_layer.hpp>
#include<caffe/layers/reshape_layer.hpp>
#include<caffe/layers/rnn_layer.hpp>
#include<caffe/layers/scale_layer.hpp>
#include<caffe/layers/sigmoid_cross_entropy_loss_layer.hpp>
#include<caffe/layers/silence_layer.hpp>
#include<caffe/layers/slice_layer.hpp>
#include<caffe/layers/softmax_loss_layer.hpp>
#include<caffe/layers/split_layer.hpp>
#include<caffe/layers/spp_layer.hpp>
#include<caffe/layers/threshold_layer.hpp>
#include<caffe/layers/tile_layer.hpp>
#include<caffe/layers/window_data_layer.hpp>

//#include<caffe>
//solver
#include<caffe/sgd_solvers.hpp>


namespace caffe
{

    // 2 layer, 很奇怪，其他57个层可以通过extern，但这两个需要添加注册才可以。
    //extern INSTANTIATE_CLASS(DataLayer);
    //extern INSTANTIATE_CLASS(ParameterLayer);
    REGISTER_LAYER_CLASS(Data);
    REGISTER_LAYER_CLASS(Parameter);


    // 57 layers
    extern INSTANTIATE_CLASS(ConvolutionLayer);
    extern INSTANTIATE_CLASS(PoolingLayer);
    extern INSTANTIATE_CLASS(LRNLayer);
    extern INSTANTIATE_CLASS(ReLULayer);
    extern INSTANTIATE_CLASS(SigmoidLayer);
    extern INSTANTIATE_CLASS(SoftmaxLayer);
    extern INSTANTIATE_CLASS(TanHLayer);
    extern INSTANTIATE_CLASS(PythonLayer);
    extern INSTANTIATE_CLASS(AbsValLayer);
    extern INSTANTIATE_CLASS(AccuracyLayer);
    extern INSTANTIATE_CLASS(ArgMaxLayer);
    extern INSTANTIATE_CLASS(BatchNormLayer);
    extern INSTANTIATE_CLASS(BatchReindexLayer);
    extern INSTANTIATE_CLASS(BiasLayer);
    extern INSTANTIATE_CLASS(BNLLLayer);
    extern INSTANTIATE_CLASS(ConcatLayer);
    extern INSTANTIATE_CLASS(ContrastiveLossLayer);
    extern INSTANTIATE_CLASS(CropLayer);


    extern INSTANTIATE_CLASS(DeconvolutionLayer);
    extern INSTANTIATE_CLASS(DropoutLayer);
    extern INSTANTIATE_CLASS(DummyDataLayer);
    extern INSTANTIATE_CLASS(EltwiseLayer);
    extern INSTANTIATE_CLASS(ELULayer);
    extern INSTANTIATE_CLASS(EmbedLayer);
    extern INSTANTIATE_CLASS(EuclideanLossLayer);
    extern INSTANTIATE_CLASS(ExpLayer);
    extern INSTANTIATE_CLASS(FilterLayer);
    extern INSTANTIATE_CLASS(FlattenLayer);
    extern INSTANTIATE_CLASS(HDF5DataLayer);
    extern INSTANTIATE_CLASS(HDF5OutputLayer);
    extern INSTANTIATE_CLASS(HingeLossLayer);
    extern INSTANTIATE_CLASS(Im2colLayer);
    extern INSTANTIATE_CLASS(ImageDataLayer);
    extern INSTANTIATE_CLASS(InfogainLossLayer);
    extern INSTANTIATE_CLASS(InnerProductLayer);
    extern INSTANTIATE_CLASS(InputLayer);
    extern INSTANTIATE_CLASS(LogLayer);
    extern INSTANTIATE_CLASS(LSTMLayer);
    extern INSTANTIATE_CLASS(LSTMUnitLayer);
    extern INSTANTIATE_CLASS(MemoryDataLayer);
    extern INSTANTIATE_CLASS(MultinomialLogisticLossLayer);
    extern INSTANTIATE_CLASS(MVNLayer);
    extern INSTANTIATE_CLASS(PowerLayer);
    extern INSTANTIATE_CLASS(PReLULayer);
    extern INSTANTIATE_CLASS(ReductionLayer);
    extern INSTANTIATE_CLASS(ReshapeLayer);
    extern INSTANTIATE_CLASS(RNNLayer);
    extern INSTANTIATE_CLASS(ScaleLayer);
    extern INSTANTIATE_CLASS(SigmoidCrossEntropyLossLayer);
    extern INSTANTIATE_CLASS(SilenceLayer);
    extern INSTANTIATE_CLASS(SliceLayer);
    extern INSTANTIATE_CLASS(SoftmaxWithLossLayer);
    extern INSTANTIATE_CLASS(SplitLayer);
    extern INSTANTIATE_CLASS(SPPLayer);
    extern INSTANTIATE_CLASS(ThresholdLayer);
    extern INSTANTIATE_CLASS(TileLayer);
    extern INSTANTIATE_CLASS(WindowDataLayer);

    // 6 sovlers
    extern INSTANTIATE_CLASS(AdaDeltaSolver);
    extern INSTANTIATE_CLASS(AdaGradSolver);
    extern INSTANTIATE_CLASS(AdamSolver);
    extern INSTANTIATE_CLASS(NesterovSolver);
    extern INSTANTIATE_CLASS(RMSPropSolver);
    extern INSTANTIATE_CLASS(SGDSolver);
}

#endif

测试代码如下：


#include"stdafx.h"
#define  CPU_ONLY
#include"caffe_reg.h"
#include<vector>
#include<iostream>
#include<caffe/caffe.hpp>
#include<caffe/solver_factory.hpp>
using namespace caffe;
using namespace std;

int main(void)
{

    //打印出所有注册的层
    vector<string> typeList = LayerRegistry<float>::LayerTypeList();
    cout << "层数: " << typeList.size() << endl;
    for (int i = 0; i < typeList.size(); i++)
    {
        cout << typeList[i] << " ";
    }
    cout << endl;


    SolverParameter solver_param;
    string solver_file = "lenet_solver1.prototxt";
    ReadSolverParamsFromTextFileOrDie(solver_file, &solver_param);

    //boost::shared_ptr<Solver<float> > solver(
    //  SolverRegistry<float>::CreateSolver(solver_param));

    Solver<float> * solver = SolverRegistry<float>::CreateSolver(solver_param);//Sover<float> 是纯虚函数，所有不能实例化对象，通过指针的形式指向子类。

    const int maxIter = 1;
    float loss[maxIter];
    float accuracy[maxIter];

    int  step[maxIter];
    for (int i = 0; i < maxIter; i++)
    {
        solver->Step(1);
        step[i] = solver->iter();
        loss[i] = *(solver->net()->blob_by_name("loss")->mutable_cpu_data());
        accuracy[i] = *(solver->test_nets()[0]->blob_by_name("accuracy")->mutable_cpu_data());
    }
    FILE *fp = fopen("result.txt", "w");
    for (int i = 0; i < maxIter; i++)
    {
        fprintf(fp, "%d %.4f %.4f\n", step[i], loss[i], accuracy[i]);
    }
}

方法2：使用caffe.dll：

编译dll库，主要参考文章：<编译caffe的dll库>
我们跟随文献6的方法开始。

在下面每个将要修改的.h头文件中都要加入宏定义：

#ifdef BUILD_DLL
#define OS_API __declspec(dllexport)
#else
#define OS_API __declspec(dllimport)
#endif,

blob.hpp

class OS_API Blob

net.hpp

class OS_API Net

caffe.pb.h

class OS_API BlobShape
class OS_API BlobProto
class OS_API BlobProtoVector
class OS_API SolverParameter
class OS_API LayerParameter
class OS_API NetParameter
class OS_API FillerParameter

common.hpp

OS_API void GlobalInit(int* pargc, char*** pargv);
class OS_API Caffe
class OS_API RNG

io.hpp

OS_API bool ReadProtoFromTextFile(const char* filename, Message* proto);
OS_API bool ReadProtoFromBinaryFile(const char* filename, Message* proto);
OS_API void WriteProtoToBinaryFile
OS_API bool ReadImageToDatum
OS_API bool DecodeDatumNative(Datum* datum);
void OS_API WriteProtoToTextFile

db.hpp

class OS_API DB
OS_API DB* GetDB(DataParameter::DB backend);
OS_API DB* GetDB(const string& backend);

benchmark.hpp

class OS_API Timer

upgrade_proto.hpp

OS_API void ReadSolverParamsFromTextFileOrDie
OS_API bool NetNeedsUpgrade(const NetParameter& net_param);
OS_API bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param);
OS_API bool SolverNeedsTypeUpgrade(const SolverParameter& solver_param);
OS_API boolbool UpgradeSolverAsNeeded(const string& param_file, SolverParameter* param);

signal_handler.h

class OS_API SignalHandler

solver.hpp

class OS_API Solver

parallel.hpp

class OS_API P2PSync

layer.hpp

class OS_API Layer

math_functions.hpp

OS_API unsigned int caffe_rng_rand();
OS_API Dtype caffe_cpu_dot(const int n, const Dtype* x, const Dtype* y);
OS_API void caffe_rng_gaussian
OS_API void caffe_rng_bernoulli(const int n, const Dtype p, int* r);

OS_API void caffe_rng_bernoulli(const int n, const Dtype p, unsigned int* r);
OS_API void caffe_copy(const int N, const Dtype *X, Dtype *Y);
OS_API void caffe_set(const int N, const Dtype alpha, Dtype *X);
OS_API void caffe_rng_uniform(const int n, const Dtype a, const Dtype b, Dtype* r);

syncedmem.hpp

class OS_API SyncedMemory

solver_factory.hpp

class OS_API SolverRegistry

layer_factory.hpp

class OS_API LayerRegisterer

像文献[6]中所说的那样：“因为这个头文件是根据src\caffe\proto\caffe.proto自动生成的，所以编译的时候还把这个文件改了名字，否则就把修改后的caffe.pb.h又覆盖了”。

我们通过下面的操作来完成上面模糊的说明：

这里写图片描述

上图中没有步骤2，步骤2就是修改：

E:\caffe-windows\scripts\build\include\caffe\proto\caffe.pb.h

matlab训练caffe模型示例代码：

clc;clearvars;close all;
% app caffe class to dir
if exist('../+caffe', 'dir')
  addpath('..');
else
  error('Please run this demo from caffe/matlab/demo');
end

caffe.reset_all;

% caffe.set_mode_cpu();
% solver = caffe.Solver('lenet_solver1.prototxt') ;
% solver.solve();

format long %设置精度，caffe的损失貌似精度在小数点后面好几位  
addpath('..')  
caffe.reset_all%重设网络，否则载入两个网络会卡住  
solver=caffe.Solver('lenet_solver1.prototxt'); %载入网络  
loss=[];%记录相邻两个loss  
accuracy=[];%记录相邻两个accuracy  
hold on%画图用的  
accuracy_init=0;  
loss_init=0;  
for i=1:10000  
    solver.step(1);%每迭代一次就取一次loss和accuracy  
    iter=solver.iter();  
    loss=solver.net.blobs('loss').get_data();%取训练集的loss  
    accuracy=solver.test_nets.blobs('accuracy').get_data();%取验证集的accuracy  
    disp(accuracy);
    %画loss折线图  
    x=[i-1,i];  
    y=[loss_init loss];  
    plot(x,y,'r-')  
    drawnow  
    loss_init=loss;  
end

VS2015训练caffe模型的代码

#include"stdafx.h"
#define  CPU_ONLY

#include<vector>
#include<iostream>
#include<caffe/caffe.hpp>

using namespace caffe;
using namespace std;

int main(void)
{

    SolverParameter solver_param;
    string solver_file = "lenet_solver1.prototxt";
    ReadSolverParamsFromTextFileOrDie(solver_file, &solver_param);

    //boost::shared_ptr<Solver<float> > solver(
    //  SolverRegistry<float>::CreateSolver(solver_param));

    Solver<float> * solver = SolverRegistry<float>::CreateSolver(solver_param);

    const int maxIter = 1;
    float loss[maxIter];
    float accuracy[maxIter];
    int  step[maxIter];
    for (int i = 0; i < maxIter; i++)
    {
        solver->Step(1);
        step[i] = solver->iter();
        loss[i] = *(solver->net()->blob_by_name("loss")->mutable_cpu_data());
        accuracy[i] = *(solver->test_nets()[0]->blob_by_name("accuracy")->mutable_cpu_data());

    }
    FILE *fp = fopen("result.txt", "w");
    for (int i = 0; i < maxIter; i++)
    {
        fprintf(fp, "%d %.4f %.4f\n", step[i], loss[i], accuracy[i]);
    }
}

补：
caffe实现的层59个，6个求解方法。

Convolution
Pooling
LRN
ReLU
Sigmoid
Softmax
TanH
Python
AbsVal
Accuracy
ArgMax
BatchNorm
BatchReindex
Bias
BNLL
Concat
ContrastiveLoss
Crop
Data
Deconvolution
Dropout
DummyData
Eltwise
ELU
Embed
EuclideanLoss
Exp
Filter
Flatten
HDF5Data
HDF5Output
HingeLoss
Im2col
ImageData
InfogainLoss
InnerProduct
Input
Log
LSTM
LSTMUnit
MemoryData
MultinomialLogisticLoss
MVN
Parameter
Power  
PReLU
Reduction
Reshape
RNN
Scale
SigmoidCrossEntropyLoss
Silence
Slice
SoftmaxWithLoss
Split
SPP
Threshold
Tile
WindowData

AdaDeltaSolver
AdaGradSolver
AdamSolver
NesterovSolver
RMSPropSolver
SGDSolver

参考文献:

1.https://github.com/ih4cku/blog/issues/93
2.http://blog.luoyetx.com/2016/02/reading-caffe-3/ [Caffe 源码阅读 Layer 加载机制]
3.https://github.com/BVLC/caffe/issues/4010 [Solvers not registered during building? #4010]
4.https://github.com/BVLC/caffe/pull/4739 [Hide implementation of LayerRegistry::CreatorRegistry and SolverRegistry::CreatorRegistry singletons #4739]
5.http://www.cnblogs.com/JimmyTY/p/5856217.html [Linux C/C++ 链接选项之静态库–whole-archive,–no-whole-archive和–start-group, –end-group]
6. http://blog.csdn.net/ccemmawatson/article/details/51539182 [编译caffe的dll库]
7.http://blog.csdn.net/birdwcp/article/details/53580068 [ Check failed: registry.count(t ype) == 1 (0 vs. 1) Unknown layer type: Input (known types: Input )]

机器学习的小学生
关注
专栏目录
Caffe运行自带Demo出现Unknown layer type错误解决
For record
10-27 8485
错误描述： 参见：https://github.com/BVLC/caffe/issues/1986 运行sh ./example/mnist/train_lenet.sh时出现错误：layer_factory.hpp:77] Check failed: registry.count(type) == 1 (0 vs. 1) Unknown layer type: Data (known ty
Ubuntu18.04+CUDA10.1+OpenCV3.4.12+Python2.7环境下安装caffe
csdn_tclz的博客
12-20 816
几个前提 确认自己的机器上已经成功安装了NVIDIA driver、CUDA、cudnn 详细步骤可参考之前写的安装说明 说明 按照Caffe官方安装教程的说明，有两种安装方式，make(官方版)和cmake(社区支持)，使用make过程中遇到不少坑，最终笔者使用cmake安装成功 开始 1.首先安装后续步骤需要的各种依赖包，依次输入以下命令 sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev lib
caffe静态链接库“Unknown layer type: Convolution (known types: )”和“ 磁盘空间不足”问题的解决办法
u010595179的博客
01-25 4947
这一段时间把caffe在windows环境下编译了一下，tool里面的cpp全部编译成了exe。再用的时候有两个问题让我头疼了好长时间！               第一个问题 “db_lmdb.hpp:14] Check failed: mdb_status == 0 (112 vs. 0) 磁盘空间不足。”                这问题是由于lmdb在wi
Unknown layer type: Python
u012910595的博客
11-07 1483
当用fast-rcnn训练自己的数据集时，遇到registry.count(type) == 1 (0 vs. 1) Unknown layer type: Python 尝试了网上很多种解决方案，修改Makefile文件，修改Makefile.config文件，设置PYTHONPATH，问题都没有解决 最后清理原来已经，make好的caffe框架与和其python的接口，重新make，出乎意
caffe用c++实现调用模型进行推理（测试），出现"Unknown layer type"的错误
wshdkf的博客
04-27 1604
如题，我在windows下，基于happynear的caffe，模仿classification项目，用c++实现调用模型进行推理（测试），但是在进行网络初始化时，出现“Unknown layer type”的错误。为解决这个问题，首先去网上搜索，参考了以下博客：https://blog.csdn.net/fangjin_kl/article/details/50936952https://blo...
Check failed: registry.count(t ype) == 1 (0 vs. 1) Unknown layer type
woyaopojie1990的专栏
01-09 1784
问题：window下面将caffe封装为caffe.lib，自己的工程调用caffe.lib的时候，会出现某一个layer未注册或者已经注册过了等问题。解决方法就是自己建一个头文件，比如mycaffe.h，里面的内容如下： //#ifndef CAFFE_H //#define CAFFE_H #ifndef CAFFE_REG_H #define CAFFE_REG_H #incl
Caffe源码解读：Layer类
小肥柴不是小废柴的博客
11-18 1201
Layer类简介 至少有一个输入，输出Blob。 部分Layer带有权值和偏置项（如：激活层没有权值项） 前向传播对输入Blob处理，得到输出Blob。反向传播对输出的diff进行处理，得到输入的diff ProtoBuffer描述 打开./caffe/src/caffe/caffe.proto文件，找到LayerParameter，查看对应的数据结构...
caffe源码分析-layer
常思考->有目标->重实践->善反思
10-07 1398
本文主要分析caffe layer层，主要内容如下： 从整体上说明下caffe的layer层的类别，以及作用 通过proto定义与类Layer简要说明下Layer的核心成员变量; Layer类的核心成员函数 1. 类Layer overview caffe中的Layer主要分为如下几个模块： 输入层Data Layers Data Layers定义了caffe中网络的输入，依...
Caffe: Net类解析(1)--原创
ricky5000的博客
03-31 5010
Net类是Caffe中的一个核心类, 他将各个Layer和Blob组织到一起, 完成前向和反响传播计算 下面详细解读Net.cpp的代码: ----------------------------------------------------------------------------------------------------------------------------
Caffe - Ubuntu 安装及问题解决
热门推荐
长风破浪会有时，直挂云帆济沧海
06-07 2万+
Caffe - Ubuntu 安装及问题解决 Ubuntu14.04 CUDA 8.0 cuDNN Caffe 安装 Step 1 CUDA安装 要结合使用 Caffe 和 NVIDIA GPU，需要安装CUDA 工具包. Step 2 cuDNN 安装 下载适用于Linux的cuDNN库，这里需要注册加速计算开发人员计划; 下载后，解压缩文件并将其复制到CUDA目录，...
Darknet转换Caffe模型失败：Unknow layer type yolo
Ubuntu18.04局域网共享文件夹，实现win7和Ubuntu本地访问
06-18 742
执行下列转换程序时报错： python darknet2caffe.py cfg/yolov3.cfg weights/last.weights prototxt/yolov3.prototxt caffemodel/yolov3.caffemodel 以下是报错信息： 可能原因：磁盘占满 df -a #查看磁盘使用情况 从图中可以看到snap占了100% 解决办法： sudo apt autoremove --purge snapd 至于Unknow layer type yolo，无视即
解决caffe运行mobilenet报错:registry.count(type) == 1 (0 vs. 1) Unknown layer type: DepthwiseConvolution
schFallingCloud
01-04 722
caffe报错Unknown layer type: DepthwiseConvolution
caffe训练时候的 unknow solver type /unknown layer type错误
xiakj的专栏
12-30 920
改进办法承接上一篇博文。这里主要记录一下解决的思路。 问题原因：好像是一些层的注册问题。 解决办法： 1. 写一个头文件，名称为caffe_reg.h，内容如下： #pragma once #ifndef CAFFE_REG_H #define CAFFE_REG_H //layer #include&lt;caffe/layers/conv_layer.hpp&gt; #inclu...
梳理caffe代码image_data_layer、data_layer、window_data_layer(七)
深藏功与名
04-05 9282
第七个现在才更新，因为有诸多头文件需要先梳理一下（八到十三），不管是新版旧版的caffe，数据成这一块，继承关系是不会变得，可能里面只是一些文件的名字和文件路径修改过了，更加层次化便于以后的开发应用。 先看一张继承图就明白了： 然后按照这个图layer所派生出的这几个类，以新版caffe为例，梳理一遍（每层从左向右梳理）： 首先是后面梳理的internal_thread，这里就不多说了。
caffe中Layer type * already registered和Unknown layer type错误
u013021895的博客
01-15 3588
Unknown layer type： 在该layer的实现文件（在$caffe_root/src/caffe/layers/目录下，如pool层的实现在src/caffe/layers/pooling_layer.cpp）INSTANTIATE_CLASS(PoolingLayer);加入下面这条语句： REGISTER_LAYER_CLASS(Pooling);（记住Pooling后面不要
solver_factory.hpp的理解
Ziyi Liu的专栏
12-25 832
blob中每一个元素是按照float类型来存储的，占4个byte 这里面定义了几个类，先看template <typename Dtype> //模板类 class SolverRegistry { public://定义了两个成员变量 //名为Creator的函数指针，参数为SolverParameter&类型的引用，返回值为一个Solver类型的指针 typedef Solver<Dt
G2O (General Graph Optimization)入门及简单使用
最新发布
晓晨的博客
10-30 7556
g2o全称是General Graph Optimization，也就是图优化，我们在做SLAM后端或者更加常见的任何优化问题（曲线拟合）都可以使用G2O进行处理。
caffe工厂类solver_factory解析
wudi_X的博客
10-11 629
caffe工厂类solver_factory根据solver.prototxt中定义的type类型创建各种solver实例创建代码如下：caffe.cpp shared_ptr&lt;caffe::Solver&lt;float&gt; &gt; solver(caffe::SolverRegistry&lt;float&gt;::CreateSolver(solver_param)...
Caffe Solver解析：深度学习中神经网络求解策略
在Caffe中，Solver配置文件通过设置`type`参数来指定使用哪种优化器，如SGD可以通过`<solver> <type> SGD</type>`来设置。这些优化器的实现细节在代码层面有所不同，比如SGD使用全局函数`SGDUpdate`进行参数更新，而...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值