如何调用caffe已经训练好的net

Posted 2023-03-19

参考技术A 关于准确率一直是0.5：

我不了解你是怎么训练的，但是对于二分类问题最后准确率是0.5，有可能是因为最终结果都分到同一类上面去了，这个你需要调用caffe看看网络最终的输出来判断
对于二分类问题，一般训练的时候，正负样本要混合在一起训练（一般在输入层那里设置shuffle来做到），如果没有shuffle，并且你的输入数据正好是前面的是正样本，后面的是负样本，那么就会造成你的网络最开始一直倾向于输出1，在输入一直是正样本的时候，loss的确会下降，然后到负样本的时候，loss一下子跳很高，由于后面全是负样本，网络训练使得它倾向于输出0，就又慢慢降下来了，最终你的网络基本上就是输出值都是1或者都是0了
如果是这种情况，可以在输入层那里设置shuffle为true
当然具体情况具体分析，我也不了解你的情况，只是告诉你有这个可能而已
=====================================================
以下是关于caffe的回答：
你想调用你的模型，最简单的办法是看examples/cpp_classification里面的cpp文件，那是教你如何调用caffe获取分类结果的...（你没接触过caffe的话，建议你直接按照这个文件来操作可能会比较简单，下面我的代码我也不知道没接触过caffe的人看起来难度会有多大）
不过那个代码我看着不太习惯，所以之前自己稍微写了一个简易的版本，不知道怎么上传附件，懒人一个就直接把代码贴在最后了。
先简单解释一下如何使用，把这个代码复制到一个头文件中，然后放在examples里面一个自己创建的文件夹里面，然后写一个main函数调用这个类就可以了，比如：
复制，保存到caffe/examples/myproject/net_operator.hpp，然后同目录下写一个main.cpp，在main函数里面#include "net_operator.hpp"，就可以使用这个类了：
const string net_prototxt = "..."; // 你的网络的prototxt文件，用绝对路径，下面同理
const string pre_trained_file = "..."; // 你训练好的.caffemodel文件
const string img_path = "..."; // 你要测试的图片路径
// 创建NetOperator对象
NetOperator net_operator(net_prototxt, pre_trained_file);
Blob<float> *blob = net_operator.processImage(img_path);
// blob就得到了最后一层的输出结果，至于blob里面是怎么存放数据的，你需要去看看官网对它的定义
写完main.cpp之后，到caffe目录下，make，然后它会编译你写的文件，对应生成的可执行文件。比如按我上面写的那样，make之后就会在caffe/build/examples/myproject文件夹里面生成一个main.bin，执行这个文件就可以了。因为生成的可执行文件并不是直接在代码目录下，所以前面我建议你写的路径用绝对路径
另外如果你要获取的不是最后一层的输出，你需要修改一下processImage函数的返回值，通过NetOperator的成员变量net_来获取你需要的blob，比如有个blob名称为"label"，你想获取这个blob，可以通过net_->blob_by_name("label")来获取，当然获取到的是shared_ptr<Blob<float> >类型的，搜一下boost shared_ptr就知道跟普通指针有什么不同了
好了，接下来是贴代码了：
#include <caffe/caffe.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iosfwd>
#include <memory>
#include <string>
#include <utility>
#include <vector>
using namespace caffe; // NOLINT(build/namespaces)
using std::string;
class NetOperator

public:
NetOperator(const string& net_prototxt);
NetOperator(const string& net_prototxt, const string& trained_file);
~NetOperator()
int batch_size() return batch_size_;
Blob<float>* processImage(const string &img_path, bool is_color = true);
Blob<float>* processImages(const vector<string> &img_paths, bool is_color = true);
private:
void createNet(const string& net_prototxt);
// read the image and store it in the idx position of images in the blob
void readImageToBlob(const string &img_path, int idx = 0, bool is_color = true);
shared_ptr<Net<float> > net_;
cv::Size input_geometry_;
int batch_size_;
int num_channels_;
Blob<float>* input_blob_;
TransformationParameter transform_param_;
shared_ptr<DataTransformer<float> > data_transformer_;
Blob<float> transformed_data_;
;
NetOperator::NetOperator(const string& net_prototxt)
createNet(net_prototxt);

NetOperator::NetOperator(const string& net_prototxt, const string& trained_file)
createNet(net_prototxt);
net_->CopyTrainedLayersFrom(trained_file);

void NetOperator::createNet(const string& net_prototxt)
#ifdef CPU_ONLY
Caffe::set_mode(Caffe::CPU);
#else
Caffe::set_mode(Caffe::GPU);
#endif
net_.reset(new Net<float>(net_prototxt, TEST));
CHECK_EQ(net_->num_inputs(), 1) << "Network should have exactly one input.";
CHECK_EQ(net_->num_outputs(), 1) << "Network should have exactly one output.";
Blob<float>* input_layer = net_->input_blobs()[0];
batch_size_ = input_layer->num();
num_channels_ = input_layer->channels();
CHECK(num_channels_ == 3 || num_channels_ == 1)
<< "Input layer should have 1 or 3 channels.";
input_geometry_ = cv::Size(input_layer->width(), input_layer->height());
// reshape the output shape of the DataTransformer
vector<int> top_shape(4);
top_shape[0] = 1;
top_shape[1] = num_channels_;
top_shape[2] = input_geometry_.height;
top_shape[3] = input_geometry_.width;
this->transformed_data_.Reshape(top_shape);

Blob<float>* NetOperator::processImage(const string &img_path, bool is_color)
// reshape the net for the input
input_blob_ = net_->input_blobs()[0];
input_blob_->Reshape(1, num_channels_,
input_geometry_.height, input_geometry_.width);
net_->Reshape();
readImageToBlob(img_path, 0, is_color);
net_->ForwardPrefilled();
return net_->output_blobs()[0];

Blob<float>* NetOperator::processImages(const vector<string> &img_paths, bool is_color)
int img_num = img_paths.size();
// reshape the net for the input
input_blob_ = net_->input_blobs()[0];
input_blob_->Reshape(img_num, num_channels_,
input_geometry_.height, input_geometry_.width);
net_->Reshape();
for (int i=0; i<img_num; i++)
readImageToBlob(img_paths[i], i, is_color);

net_->ForwardPrefilled();
return net_->output_blobs()[0];

void NetOperator::readImageToBlob(const string &img_path, int idx, bool is_color)
// read the image and resize to the target size
cv::Mat img;
int cv_read_flag = (is_color ? CV_LOAD_IMAGE_COLOR :
CV_LOAD_IMAGE_GRAYSCALE);
cv::Mat cv_img_origin = cv::imread(img_path, cv_read_flag);
if (!cv_img_origin.data)
LOG(ERROR) << "Could not open or find file " << img_path;
return ;

if (input_geometry_.height > 0 && input_geometry_.width > 0)
cv::resize(cv_img_origin, img, input_geometry_);
else
img = cv_img_origin;

// transform the image to a blob using DataTransformer
// create a DataTransformer using default TransformationParameter (no transformation)
data_transformer_.reset(
new DataTransformer<float>(transform_param_, TEST));
data_transformer_->InitRand();
// set the output of DataTransformer to the idx image of the input blob
int offset = input_blob_->offset(idx);
this->transformed_data_.set_cpu_data(input_blob_->mutable_cpu_data() + offset);
// transform the input image
data_transformer_->Transform(img, &(this->transformed_data_));

Caffe：如何使用已经训练好的模型一次检查多个数据集的准确性？

【中文标题】Caffe：如何使用已经训练好的模型一次检查多个数据集的准确性？

【英文标题】：Caffe: How to check accuracies of multiple Data sets with already trained model at a time?

【发布时间】：2016-11-04 13:41:12

【问题描述】：

在 Caffe 框架中使用 2 个类别的 10k 图像训练 LeNet 模型后，我得到了包含权重和偏差的模型 lenet_iter_4000.caffemodel。我想一次检查 5k 新测试图像（在训练时不属于测试图像的一部分）的准确性。我为所有这些 5k 图像创建了 lmdb 文件。我知道如何使用以下方法测试图像。

./build/tools/caffe test --model=examples/mnist/lenet_train_test.prototxt --weights=examples/mnist/lenet_iter_4000.caffemodel

但是我无法一次获得准确度，例如在训练时如果我们输入 test_interval 3000 将获得准确度，我们将在 3000 迭代后获得所有测试图像的准确度。如果我想在训练后的某个时间测试准确性，我必须在 prototxt 中进行更改。 我的问题是：如何在使用经过训练的模型进行训练后获得多个数据集的准确性？

【参考方案1】：

一种快速的解决方案是在训练时获得多个数据集的准确度。您可以通过修改您的solver.prototxt和net.prototxt来实现这一点，如下所示，更具体地说是在solver.prototxt中使用多个“test_state”和多个具有不同“include：stage：”xxx“”的数据层net.prototxt 用于测试多个数据集：

solver.prototxt：

net: "lenet_train_test.prototxt"
#testing stage for your orininal test images
test_state:  stage: "original test" 
#testing stage for your new test images
test_state:  stage: "new 5k test" 
#iterations for original testing
test_iter: xxx
#iterations for your new 5k testing
test_iter: xxx
#Those 2 testings use the same test_interval
test_interval: 500

对应的net.prototxt：

name: "LeNet"
layer 
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include 
    phase: TRAIN
  
  transform_param 
    scale: 0.00390625
  
  data_param 
    source: "examples/mnist/mnist_train_lmdb"
    batch_size: 32
    backend: LMDB
    shuffle: true
  

layer 
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include 
    phase: TEST
    stage: "original test"
  
  transform_param 
    scale: 0.00390625
  
  data_param 
    source: "examples/mnist/mnist_test_lmdb"
    batch_size: 100
    backend: LMDB
  

layer 
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include 
    phase: TEST
    stage: "new 5k test"
  
  transform_param 
    scale: 0.00390625
  
  data_param 
    source: "path/to/your/5k_images_test_lmdb"
    batch_size: 100
    backend: LMDB
  

.
.
.
layer 
  name: "accuracy"
  type: "Accuracy"
  bottom: "ip2"
  bottom: "label"
  top: "accuracy"
  include 
    phase: TEST
  

layer 
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "ip2"
  bottom: "label"
  top: "loss"

并像微调一样使用它们：

./build/tools/caffe train --solver=examples/mnist/solver.prototxt --weights=examples/mnist/lenet_iter_4000.caffemodel

在第 0 次迭代时，求解器将测试多个数据集，您将获得它们的多个精度，然后可以停止求解器。

【讨论】：

我想在使用经过训练的模型进行训练后获得多个数据集的准确度。

您的问题的快速解决方案可以是这样的：/build/tools/caffe train --solver=examples/mnist/lenet_solver.prototxt --weights=examples/mnist/lenet_iter_4000.caffemodel。 lenet_solver.prototxt 和相应的 net.prototxt 应该像我的回答一样修改。

我明白，但我已经训练了几个小时的模型。我想使用该模型进行测试，以节省时间。我已经为 LeNet 提供了示例。但我已经为 1 训练了 AlexNet 模型day.我想使用经过训练的 Alexnet 模型进行测试。

在第 0 次迭代中，求解器将测试您的 2 个数据集，包括您的 5k 图像，您将获得它们的准确度。然后你可以阻止它。这是我能想到的最快的方法。否则，您应该修改 caffe.cpp 中的 test() 函数，就像 Solver::Init() 所做的那样，以维护多个网络进行测试，这有点微不足道。 @BHAV247

Alexnet模型用于测试的解决方案与lenet相同，只是修改sovler.prototxt添加“test_state”和alexnet.prototxt为你的5k测试图像添加一个数据层。测试时间一点也不长。 @BHAV247

【参考方案2】：

只要用caffe的测试工具，检查the interface examples

我来晚了，但是想知道如何将训练模型仅用于测试目的的人可以使用 caffe 的测试工具。如果您训练了模型，并计划在之后使用它，那么您应该在每次迭代时保存权重。我们将最终保存的权重命名为 model_iter_xxxx.caffemodel。

将模型复制到 model_test.prototxt（例如）

添加要在测试阶段考虑的层，即用于测试数据的输入层和准确性层。

运行：caffe test -model path/to/model_test.prototxt -weights path/to/model_iter_xxxx.caffemodel -iterations 100