caffe的一些接口

#include <stdio.h>
#include <string.h>
#include <fstream>
#include <iostream>
#include <iosfwd>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <caffe/caffe.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include "E:/workspace/caffe-windows-master/src/caffe/proto/caffe.pb.h"


using namespace std;
using namespace caffe;
unsigned int get_layer_index(boost::shared_ptr<Net<float>>&net, char* query_layer_name)
{
string str_query(query_layer_name);
vector<string> const& layer_names = net->layer_names();
for (auto i = 0; i != layer_names.size(); i++)
{
if (str_query == layer_names[i])
{
return i;
}
}
LOG(FATAL) << "unknown layer name:" << str_query;
}
unsigned int get_blob_index(boost::shared_ptr<Net<float>>& net, char *query_blob)
{
string str_query(query_blob);
vector<string>const &blob_names = net->blob_names();
for (unsigned int i = 0; i != blob_names.size(); ++i)
{
if (str_query == blob_names[i]) return i;
}
LOG(FATAL) << "unknown blob name" << str_query;
}
void get_blob_features(boost::shared_ptr< Net<float> > & net, float *data_ptr, char* layer_name)
{
unsigned int id = get_layer_index(net, layer_name);
const vector<Blob<float>*>& output_blobs = net->top_vecs()[id];
for (unsigned int i = 0; i < output_blobs.size(); ++i)
{
switch (Caffe::mode()) {
case Caffe::CPU:
memcpy(data_ptr, output_blobs[i]->cpu_data(),sizeof(float) * output_blobs[i]->count());
break;
case Caffe::GPU:
cudaMemcpy(data_ptr, output_blobs[i]->gpu_data(),sizeof(float) * output_blobs[i]->count(), cudaMemcpyDeviceToHost);
break;
default:
LOG(FATAL) << "Unknown Caffe mode.";
}
}
}
//不知道干嘛用的
#define PRINT_SHAPE1(x) \
    outfile << (x).num() << "\t" << (x).channels() << "\t" << (x).height() << "\t" << (x).width() << "\n"; 
#define PRINT_SHAPE2(x) \
    outfile << (x)->num() << "\t" << (x)->channels() << "\t" << (x)->height() << "\t" << (x)->width() << "\n"; 
#define PRINT_DATA(x) \
    outfile << (x)[0] << "\t" << (x)[1] << "\n";


int main(int argc, char* argv[])
{


ofstream outfile("C:\\Users\\janemyleng\\Desktop\\a.txt", ios::out);
char* proto = "E://workspace//caffe-windows-master//models//colour//deploy.prototxt";
char* model = "E://workspace//caffe-windows-master//models//colour//car.caffemodel";
char* mean_file = "E://workspace//caffe-windows-master//models//colour//mean.binaryproto";
//caffe::set_model(caffe::cpu)
Caffe::set_mode(Caffe::GPU);
Caffe::SetDevice(0);
Phase phase = TEST;
//Caffe::NetParameter parm;


//load net model
boost::shared_ptr<Net<float>> net(new caffe::Net<float>(proto,phase));
net->CopyTrainedLayersFrom(model);
const vector<boost::shared_ptr<Layer<float>>> layers = net->layers();
vector<string> layer_names = net->layer_names();
boost::shared_ptr<Layer<float>> layer;
boost::shared_ptr<Blob<float>> blob;


//show input blob size
Blob<float>* input_blobs = net->input_blobs()[0];
outfile << "input blob size:\n";
PRINT_SHAPE2(input_blobs);


//processing blobs of each layer,namely,weights and bias;
const float *mem_ptr;
CHECK(layers.size() == layer_names.size());
outfile << "\nLayers:" << layers.size() << endl;
vector<boost::shared_ptr<Blob<float>>> layer_blobs;
for (int i = 0; i < layers.size(); ++i)
{
layer_blobs = layers[i]->blobs();
outfile << "\n[" << i + 1 << "]layer name:" << layer_names[i] << ",type:" << layers[i]->type()<< endl;
outfile << "#Blobs:" << layer_blobs.size() << endl;
for (int j = 0; j < layer_blobs.size(); ++j)
{
blob = layer_blobs[j];
PRINT_SHAPE2(blob);
/*mem_ptr = blob->cpu_data;
PRINT_DATA(mem_ptr);*/
}
}
//get weights and bias from layer name
char *query_layer_name = "conv1";
const float *weight_ptr, *bias_ptr;
unsigned int layer_id = get_layer_index(net,query_layer_name);
layer = net->layers()[layer_id];
vector<boost::shared_ptr<Blob<float>>> blobs = layer->blobs();
if (blobs.size()>0)
{
std::cout << "\nweights and bias from layer: " << query_layer_name << "\n";
weight_ptr = (const float *)blobs[0]->cpu_data();
for (int j = 0; j != blobs[0]->count(); j++)
{
outfile<< *weight_ptr << "  ";

}
PRINT_DATA(weight_ptr);
bias_ptr = (const float *)blobs[1]->cpu_data();
PRINT_DATA(bias_ptr);
}
/*fstream input("E://workspace//caffe-windows-master//models//colour//car.caffemodel", ios::in | ios::binary);
Net<float> caffe_net(deploy_file, TRAIN);
caffe_net.CopyTrainedLayersFrom(model);
Net<float>* net = &caffe_net;*/


//读取均值文件
Blob<float> image_mean;
BlobProto blob_proto;
const float* mean_ptr;
unsigned int num_pixel;
//const float*weight_ptr, *bias_ptr;
bool succeed = ReadProtoFromBinaryFile(mean_file,&blob_proto);
if (succeed)
{
image_mean.FromProto(blob_proto);
num_pixel = image_mean.count();//1*3*32*32
mean_ptr = (const float*)image_mean.cpu_data();
}
//std::vector<boost::shared_ptr<Blob<float>  >> blobs = caffe_net.layers()[0]->blobs();



// modify weights from layer name
blob = net->layers()[layer_id]->blobs()[0];
unsigned int data_size = blob->count();
float *data_ptr = new float[data_size];
caffe_copy(blob->count(), weight_ptr, data_ptr);
float *w_ptr = NULL;
data_ptr[0] = 1.1111f;
data_ptr[1] = 2.2222f;
switch (Caffe::mode())
{
case Caffe::CPU:
w_ptr = blob->mutable_cpu_data();
break;
case Caffe::GPU:
w_ptr = blob->mutable_gpu_data();
break;
default:
LOG(FATAL) << "Unknown Caffe mode";
}
caffe_copy(blob->count(), data_ptr, w_ptr);
weight_ptr = (const float *)blob->cpu_data();
delete[] data_ptr;
std::cout << "\nnew weights and bias from layer: " << query_layer_name << "\n";
PRINT_DATA(weight_ptr);



system("pause");
return 0;
}