layers {
name: "mydata"
type: MEMORY_DATA
top: "data"
top: "label"
transform_param {
scale: 0.00390625
}
memory_data_param {
batch_size: 10
channels: 1
height: 24
width: 24
}
}
这里必须设置memory_data_param中的四个参数,对应这些参数可以参见源码中caffe.proto文件。现在,我们可以设计一个Classifier类来封装一下:
#ifndef CAFFE_CLASSIFIER_H
#define CAFFE_CLASSIFIER_H
#include <string>
#include <vector>
#include "caffe/net.hpp"
#include "caffe/data_layers.hpp"
#include <opencv2/core.hpp>
using cv::Mat
namespace caffe {
template <typename Dtype>
class Classifier {
public:
explicit Classifier(const string&param_file, const string&weights_file)
Dtype test(vector<Mat>&images, vector<int>&labels, int iter_num)
virtual ~Classifier() {}
inline shared_ptr<Net<Dtype>>net() { return net_}
void predict(vector<Mat>&images, vector<int>*labels)
void predict(vector<Dtype>&data, vector<int>*labels, int num)
void extract_feature(vector<Mat>&images, vector<vector<Dtype>>*out)
protected:
shared_ptr<Net<Dtype>>net_
MemoryDataLayer<Dtype>*m_layer_
int batch_size_
int channels_
int height_
int width_
DISABLE_COPY_AND_ASSIGN(Classifier)
}
}//namespace
#endif //CAFFE_CLASSIFIER_H
构造函数中我们通过模型定义文件(.prototxt)和训练好的模型(.caffemodel)文件构造一个Net对象,并用m_layer_指向Net中的memory data层,以便待会调用MemoryDataLayer中AddMatVector和Reset函数加入数据。
#include <cstdio>
#include <algorithm>
#include <string>
#include <vector>
#include "caffe/net.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/io.hpp"
#include "caffe/util/math_functions.hpp"
#include "caffe/util/upgrade_proto.hpp"
#include "caffe_classifier.h"
namespace caffe {
template <typename Dtype>
Classifier<Dtype>::Classifier(const string&param_file, const string&weights_file) : net_()
{
net_.reset(new Net<Dtype>(param_file, TEST))
net_->CopyTrainedLayersFrom(weights_file)
//m_layer_ = (MemoryDataLayer<Dtype>*)net_->layer_by_name("mnist").get()
m_layer_ = (MemoryDataLayer<Dtype>*)net_->layers()[0].get()
batch_size_ = m_layer_->batch_size()
channels_ = m_layer_->channels()
height_ = m_layer_->height()
width_ = m_layer_->width()
}
template <typename Dtype>
Dtype Classifier<Dtype>::test(vector<Mat>&images, vector<int>&labels, int iter_num)
{
m_layer_->AddMatVector(images, labels)
//
int iterations = iter_num
vector<Blob<Dtype>* >bottom_vec
vector<int>test_score_output_id
vector<Dtype>test_score
Dtype loss = 0
for (int i = 0i <iterations++i) {
Dtype iter_loss
const vector<Blob<Dtype>*>&result =
net_->Forward(bottom_vec, &iter_loss)
loss += iter_loss
int idx = 0
for (int j = 0j <result.size()++j) {
const Dtype* result_vec = result[j]->cpu_data()
for (int k = 0k <result[j]->count()++k, ++idx) {
const Dtype score = result_vec[k]
if (i == 0) {
test_score.push_back(score)
test_score_output_id.push_back(j)
} else {
test_score[idx] += score
}
const std::string&output_name = net_->blob_names()[
net_->output_blob_indices()[j]]
LOG(INFO) <<"Batch " <<i <<", " <<output_name <<" = " <<score
}
}
}
loss /= iterations
LOG(INFO) <<"Loss: " <<loss
return loss
}
template <typename Dtype>
void Classifier<Dtype>::predict(vector<Mat>&images, vector<int>*labels)
{
int original_length = images.size()
if(original_length == 0)
return
int valid_length = original_length / batch_size_ * batch_size_
if(original_length != valid_length)
{
valid_length += batch_size_
for(int i = original_lengthi <valid_lengthi++)
{
images.push_back(images[0].clone())
}
}
vector<int>valid_labels, predicted_labels
valid_labels.resize(valid_length, 0)
m_layer_->AddMatVector(images, valid_labels)
vector<Blob<Dtype>* >bottom_vec
for(int i = 0i <valid_length / batch_size_i++)
{
const vector<Blob<Dtype>*>&result = net_->Forward(bottom_vec)
const Dtype * result_vec = result[1]->cpu_data()
for(int j = 0j <result[1]->count()j++)
{
predicted_labels.push_back(result_vec[j])
}
}
if(original_length != valid_length)
{
images.erase(images.begin()+original_length, images.end())
}
labels->resize(original_length, 0)
std::copy(predicted_labels.begin(), predicted_labels.begin() + original_length, labels->begin())
}
template <typename Dtype>
void Classifier<Dtype>::predict(vector<Dtype>&data, vector<int>*labels, int num)
{
int size = channels_*height_*width_
CHECK_EQ(data.size(), num*size)
int original_length = num
if(original_length == 0)
return
int valid_length = original_length / batch_size_ * batch_size_
if(original_length != valid_length)
{
valid_length += batch_size_
for(int i = original_lengthi <valid_lengthi++)
{
for(int j = 0j <sizej++)
data.push_back(0)
}
}
vector<int>predicted_labels
Dtype * label_ = new Dtype[valid_length]
memset(label_, 0, valid_length)
m_layer_->Reset(data.data(), label_, valid_length)
vector<Blob<Dtype>* >bottom_vec
for(int i = 0i <valid_length / batch_size_i++)
{
const vector<Blob<Dtype>*>&result = net_->Forward(bottom_vec)
const Dtype * result_vec = result[1]->cpu_data()
for(int j = 0j <result[1]->count()j++)
{
predicted_labels.push_back(result_vec[j])
}
}
if(original_length != valid_length)
{
data.erase(data.begin()+original_length*size, data.end())
}
delete [] label_
labels->resize(original_length, 0)
std::copy(predicted_labels.begin(), predicted_labels.begin() + original_length, labels->begin())
}
template <typename Dtype>
void Classifier<Dtype>::extract_feature(vector<Mat>&images, vector<vector<Dtype>>*out)
{
int original_length = images.size()
if(original_length == 0)
return
int valid_length = original_length / batch_size_ * batch_size_
if(original_length != valid_length)
{
valid_length += batch_size_
for(int i = original_lengthi <valid_lengthi++)
{
images.push_back(images[0].clone())
}
}
vector<int>valid_labels
valid_labels.resize(valid_length, 0)
m_layer_->AddMatVector(images, valid_labels)
vector<Blob<Dtype>* >bottom_vec
out->clear()
for(int i = 0i <valid_length / batch_size_i++)
{
const vector<Blob<Dtype>*>&result = net_->Forward(bottom_vec)
const Dtype * result_vec = result[0]->cpu_data()
const int dim = result[0]->count(1)
for(int j = 0j <result[0]->num()j++)
{
const Dtype * ptr = result_vec + j * dim
vector<Dtype>one_
for(int k = 0k <dim++k)
one_.push_back(ptr[k])
out->push_back(one_)
}
}
if(original_length != valid_length)
{
images.erase(images.begin()+original_length, images.end())
out->erase(out->begin()+original_length, out->end())
}
}
INSTANTIATE_CLASS(Classifier)
} // namespace caffe
由于加入的数据个数必须是batch_size的整数倍,所以我们在加入数据时采用填充的方式。
CHECK_EQ(num % batch_size_, 0) <<
"The added data must be a multiple of the batch size." //AddMatVector
在模型文件的最后,我们把训练时的loss层改为argmax层:
layers {
name: "predicted"
type: ARGMAX
bottom: "prob"
top: "predicted"
}
一、问题在成功编译caffe的源码之后,可以在Python环境中使用caffe。
在Ubuntu环境下,打开python解释程序,输入import caffe时:出现以下错误
>>>import caffe
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named caffe
二、解决思路
基本思路是把caffe中的python导入到解释器中
三、解决方法
第一种方法:设置环境变量
在终中输入:
export PYTHONPATH=~/caffe/python #caffe的路径下面的python
则该终端起作用,关掉终端后或重新打开一终端,则失效。
放到配置文件中,可以永久有效果,命令 *** 作如下:
A.把环境变量路径放到 ~/.bashrc文件中
sudo echo export PYTHONPATH="~/caffe/python" >>~/.bashrc
B.使环境变量生效
source ~/.bashrc
第二种方法:通过代码来实现
在每个python代码中使用以下代码: (这个方法在写python代码时有用)
caffe_root = '~/caffe/python '
import sys
sys.path.insert(0, caffe_root + 'python')
import caffe
1) 输入归一化 x_norm = (x-u)/std, 其中u和std是个累计计算的均值和方差。
2)y=alpha×x_norm + beta,对归一化后的x进行比例缩放和位移。其中alpha和beta是通过迭代学习的。
那么caffe中的bn层其实只做了第一件事,scale层做了第二件事,所以两者要一起使用。
一,在Caffe中使用Batch Normalization需要注意以下两点:
1. 要配合Scale层一起使用。
2. 训练的时候,将BN层的use_global_stats设置为false,然后测试的时候将use_global_stats设置为true。
二,基本公式梳理:
Scale层主要完成 top=alpha∗bottom+betatop=alpha∗bottom+beta的过程,则层中主要有两个参数alphaalpha与betabeta,
求导会比较简单。∂y∂x=alpha∂y∂alpha=x∂y∂beta=1。 需要注意的是alphaalpha与betabeta均为向量,针对输入的channelschannels进行的处理,因此不能简单的认定为一个floatfloat的实数。
三,具体实现该部分将结合源码实现解析scalescale层:
在Caffe proto中ScaleParameter中对Scale有如下几个参数:
1,基本成员变量,基本成员变量主要包含了Bias层的参数以及Scale层完成对应通道的标注工作。
2,基本成员函数,主要包含了LayerSetup,Reshape ,Forward和Backward ,内部调用的时候bias_term为true的时候会调用biasLayer的相关函数。
3,Reshape 调整输入输出与中间变量,Reshape层完成许多中间变量的size初始化。
4,Forward 前向计算,前向计算,在BN中国紧跟着BN的归一化输出,完成乘以alpha与+bias的 *** 作,由于alpha与bias均为C的向量,因此需要先进行广播。
5,Backward 反向计算,主要求解三个梯度,对alpha 、beta和输入的bottom(此处的temp)。
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)