caffe interface --- matlab

文章引自：http://m.blog.csdn.net/article/details?id=51506359

一. 简介
matlab在处理矩阵运算时有很大的优势，但在处理循环时性能不如c,c++ ，所以很多时候，我们需要进行交互编程，本文首先介绍一些基础的入门知识，然后分析一个大型工程应用caffe_，从工程的视角分析，该如何设计好一个大型的交互接口。同时，找到matlab性能的瓶颈，正是我们需要改进的地方。
二.交互编程基础
这部分可参考：
http://blog.csdn.net/bendanban/article/details/37830495
省掉无传参部分，直接从有参数传递部分开始。
我们以一个例子开始：
1.我们需要执行一个矩阵的加法（本来在matlab执行起来更加高效，此处仅为了教学说明），比如在c++的文件名是addFun.cpp,我们希望在matlab中做如下调用：

a = [1,2,3;4,5,6];b = [6,5,4;3,2,1];c = a+bc_add = addFun(a,b)

2.下面开始addFun.cpp函数的编写：

//每个matlab接口必须包含的头文件，有些函数如：mxCreateDoubleMatrix在该文件中声明#include<mex.h>// Do CHECK and throw a Mex error if check failsinline void mxCHECK(bool expr, const char* msg) {    if(!expr) {        mexErrMsgTxt(msg);    }}/**   c = a + b    a,b,c are matrix of the same dimension**///mexFunction是每个matlab接口函数必须的一个入口函数(可以没有，但没有也就没有声明意义了。)，可以理解为c/c++中的main函数，其中参数，返回值也是固定的。//形参int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs分别代表：返回参数个数，返回参数，输入参数个数，输入参数。其中的mxGetM（），mxGetData（）等函数我们在下面的工程分析中予以解释。void mexFunction(int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs) {    mxCHECK(nrhs==2, "Error:must input 2 matrix for add");     int a_rows = mxGetM(prhs[0]);// get rows of a      int a_cols = mxGetN(prhs[0]);// get cols of a      int b_rows = mxGetM(prhs[1]);// get rows of b      int b_cols = mxGetN(prhs[1]);// get cols of b      mxCHECK(a_rows==a_rows && b_cols==b_cols, "Error: cols and rows of two input matrix must same");      // create output buffer      plhs[0] = mxCreateDoubleMatrix(a_rows, a_cols, mxREAL);        // get buffer pointers     double *p_c = (double*)mxGetData(plhs[0]);    double *p_a = (double*)mxGetData(prhs[0]);    double *p_b = (double*)mxGetData(prhs[1]);    // compute c = a + b;    int numEl = a_rows*a_cols;      for (int i = 0; i < numEl; i++) {        p_c[i] = p_a[i] + p_b[i];      }   }

3.做好上面的工作后，我们在matlab命令行中进行编译：

mex addFun.cpp

得到类似addFun.mexa64的文件，这时我们就可以像开始一样进行调用了。（有的版本的matlab还需要对mex进行设置，请参考mex setup）

三.工程分析进阶
本分析基于caffe的matlab接口caffe_.cpp. 优秀的源程序配合优雅的讲解是学习语言最好的资料。
1. 我们上面说道，mexFunction是入口函数，那如果我有多个函数怎么办？难道需要每个函数都做一个.cpp文件进行实现吗？，来看看我们是怎么解决的：

#define MEX_ARGS int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs----------------------------------------------------------------- ** Available commands. **/ //1.我们期望处理多个函数时，能像命令行一样，给一个命令，就能让他执行某个函数，于是我们定义下面的结构体,其中func是一个函数指针指向参数为MEX_ARGS，返回值为void的函数。struct handler_registry {  string cmd;  void (*func)(MEX_ARGS);};//2.然后，定义几个我们需要在matlab中调用的函数// Usage: caffe_('version')static void version(MEX_ARGS) {  mxCHECK(nrhs == 0, "Usage: caffe_('version')");  // Return version string  plhs[0] = mxCreateString(AS_STRING(CAFFE_VERSION));}static void get_solver(MEX_ARGS) {//.......}//3.将上面定义的这些函数进行一些简单的注册，方便后面mexFunction函数中进行调用static handler_registry handlers[] = {  // Public API functions  { "get_solver",         get_solver      },  //.......  { "version",            version         },  // The end.  { "END",                NULL            },};/** ----------------------------------------------------------------- ** matlab entry point. **/// Usage: caffe_(api_command, arg1, arg2, ...)void mexFunction(MEX_ARGS) {  mexLock();  // Avoid clearing the mex file.  mxCHECK(nrhs > 0, "Usage: caffe_(api_command, arg1, arg2, ...)");  // Handle input command  char* cmd = mxArrayToString(prhs[0]);  bool dispatched = false;  // Dispatch to cmd handler  for (int i = 0; handlers[i].func != NULL; i++) {    if (handlers[i].cmd.compare(cmd) == 0) {      handlers[i].func(nlhs, plhs, nrhs-1, prhs+1);      dispatched = true;      break;    }  }  if (!dispatched) {    ostringstream error_msg;    error_msg << "Unknown command '" << cmd << "'";    mxERROR(error_msg.str().c_str());  }  mxFree(cmd);}//4.做了上面这些步骤之后，就只需要简单的如caffe_('verion')进行调用了，是不是设计的感觉还不错呢

2.我们上面用到了很多的mex函数，这里来进行一下总结。大致分为，数据类型，处理输入，处理输出这几类。
这里也给出一个参考：http://blog.sina.com.cn/s/blog_731961510101bqd6.html
数据类型：
mxArray结构体 ，C语言与MATLAB之间的接口是通过一个由C语言编写的mxArray结构体数组。
针对MATLAB中所有数据类型，如数值阵列（双精度、单精度、int8、int16、uint16、int32、uint32等）、字符串、离散矩阵、单元阵列、结构体、对象、多维阵列、逻辑阵列、空阵列。这些MATLAB的数据类型都能用mxArray结构体来定义。
mxREAL
处理输出：
mxCreateString（），mxCreateDoubleScalar（），mxCreateDoubleMatrix（），
mxCreateStructMatrix（），mxCreateNumericMatrix（），mxCreateCellMatrix（）等
处理输入：
mxGetNumberOfElements（），mxGetData（），mxGetPr(), mxGetField(), mxGetScalar(),mxGetDimensions()等
好了，先讲这么多，有兴趣的可以参考参考下面的附件。
附件

//// caffe_.cpp provides wrappers of the caffe::Solver class, caffe::Net class,// caffe::Layer class and caffe::Blob class and some caffe::Caffe functions,// so that one could easily use Caffe from matlab.// Note that for matlab, we will simply use float as the data type.// Internally, data is stored with dimensions reversed from Caffe's:// e.g., if the Caffe blob axes are (num, channels, height, width),// the matcaffe data is stored as (width, height, channels, num)// where width is the fastest dimension.#include <sstream>#include <string>#include <vector>#include "mex.h"#include "caffe/caffe.hpp"#define MEX_ARGS int nlhs, mxArray **plhs, int nrhs, const mxArray **prhsusing namespace caffe;  // NOLINT(build/namespaces)// Do CHECK and throw a Mex error if check failsinline void mxCHECK(bool expr, const char* msg) {  if (!expr) {    mexErrMsgTxt(msg);  }}inline void mxERROR(const char* msg) { mexErrMsgTxt(msg); }// Check if a file exists and can be openedvoid mxCHECK_FILE_EXIST(const char* file) {  std::ifstream f(file);  if (!f.good()) {    f.close();    std::string msg("Could not open file ");    msg += file;    mxERROR(msg.c_str());  }  f.close();}// The pointers to caffe::Solver and caffe::Net instancesstatic vector<shared_ptr<Solver<float> > > solvers_;static vector<shared_ptr<Net<float> > > nets_;// init_key is generated at the beginning and everytime you call resetstatic double init_key = static_cast<double>(caffe_rng_rand());/** ----------------------------------------------------------------- ** data conversion functions **/// Enum indicates which blob memory to useenum WhichMemory { DATA, DIFF };// Copy matlab array to Blob data or diffstatic void mx_mat_to_blob(const mxArray* mx_mat, Blob<float>* blob,    WhichMemory data_or_diff) {  mxCHECK(blob->count() == mxGetNumberOfElements(mx_mat),      "number of elements in target blob doesn't match that in input mxArray");  const float* mat_mem_ptr = reinterpret_cast<const float*>(mxGetData(mx_mat));  float* blob_mem_ptr = NULL;  switch (Caffe::mode()) {  case Caffe::CPU:    blob_mem_ptr = (data_or_diff == DATA ?        blob->mutable_cpu_data() : blob->mutable_cpu_diff());    break;  case Caffe::GPU:    blob_mem_ptr = (data_or_diff == DATA ?        blob->mutable_gpu_data() : blob->mutable_gpu_diff());    break;  default:    mxERROR("Unknown Caffe mode");  }  caffe_copy(blob->count(), mat_mem_ptr, blob_mem_ptr);}// Copy Blob data or diff to matlab arraystatic mxArray* blob_to_mx_mat(const Blob<float>* blob,    WhichMemory data_or_diff) {  const int num_axes = blob->num_axes();  vector<mwSize> dims(num_axes);  for (int blob_axis = 0, mat_axis = num_axes - 1; blob_axis < num_axes;       ++blob_axis, --mat_axis) {    dims[mat_axis] = static_cast<mwSize>(blob->shape(blob_axis));  }  // matlab array needs to have at least one dimension, convert scalar to 1-dim  if (num_axes == 0) {    dims.push_back(1);  }  mxArray* mx_mat =      mxCreateNumericArray(dims.size(), dims.data(), mxSINGLE_CLASS, mxREAL);  float* mat_mem_ptr = reinterpret_cast<float*>(mxGetData(mx_mat));  const float* blob_mem_ptr = NULL;  switch (Caffe::mode()) {  case Caffe::CPU:    blob_mem_ptr = (data_or_diff == DATA ? blob->cpu_data() : blob->cpu_diff());    break;  case Caffe::GPU:    blob_mem_ptr = (data_or_diff == DATA ? blob->gpu_data() : blob->gpu_diff());    break;  default:    mxERROR("Unknown Caffe mode");  }  caffe_copy(blob->count(), blob_mem_ptr, mat_mem_ptr);  return mx_mat;}// Convert vector<int> to matlab row vectorstatic mxArray* int_vec_to_mx_vec(const vector<int>& int_vec) {  mxArray* mx_vec = mxCreateDoubleMatrix(int_vec.size(), 1, mxREAL);  double* vec_mem_ptr = mxGetPr(mx_vec);  for (int i = 0; i < int_vec.size(); i++) {    vec_mem_ptr[i] = static_cast<double>(int_vec[i]);  }  return mx_vec;}// Convert vector<string> to matlab cell vector of stringsstatic mxArray* str_vec_to_mx_strcell(const vector<std::string>& str_vec) {  mxArray* mx_strcell = mxCreateCellMatrix(str_vec.size(), 1);  for (int i = 0; i < str_vec.size(); i++) {    mxSetCell(mx_strcell, i, mxCreateString(str_vec[i].c_str()));  }  return mx_strcell;}/** ----------------------------------------------------------------- ** handle and pointer conversion functions ** a handle is a struct array with the following fields **   (uint64) ptr      : the pointer to the C++ object **   (double) init_key : caffe initialization key **/// Convert a handle in matlab to a pointer in C++. Check if init_key matchestemplate <typename T>static T* handle_to_ptr(const mxArray* mx_handle) {  mxArray* mx_ptr = mxGetField(mx_handle, 0, "ptr");  mxArray* mx_init_key = mxGetField(mx_handle, 0, "init_key");  mxCHECK(mxIsUint64(mx_ptr), "pointer type must be uint64");  mxCHECK(mxGetScalar(mx_init_key) == init_key,      "Could not convert handle to pointer due to invalid init_key. "      "The object might have been cleared.");  return reinterpret_cast<T*>(*reinterpret_cast<uint64_t*>(mxGetData(mx_ptr)));}// Create a handle struct vector, without setting up each handle in ittemplate <typename T>static mxArray* create_handle_vec(int ptr_num) {  const int handle_field_num = 2;  const char* handle_fields[handle_field_num] = { "ptr", "init_key" };  return mxCreateStructMatrix(ptr_num, 1, handle_field_num, handle_fields);}// Set up a handle in a handle struct vector by its indextemplate <typename T>static void setup_handle(const T* ptr, int index, mxArray* mx_handle_vec) {  mxArray* mx_ptr = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL);  *reinterpret_cast<uint64_t*>(mxGetData(mx_ptr)) =      reinterpret_cast<uint64_t>(ptr);  mxSetField(mx_handle_vec, index, "ptr", mx_ptr);  mxSetField(mx_handle_vec, index, "init_key", mxCreateDoubleScalar(init_key));}// Convert a pointer in C++ to a handle in matlabtemplate <typename T>static mxArray* ptr_to_handle(const T* ptr) {  mxArray* mx_handle = create_handle_vec<T>(1);  setup_handle(ptr, 0, mx_handle);  return mx_handle;}// Convert a vector of shared_ptr in C++ to handle struct vectortemplate <typename T>static mxArray* ptr_vec_to_handle_vec(const vector<shared_ptr<T> >& ptr_vec) {  mxArray* mx_handle_vec = create_handle_vec<T>(ptr_vec.size());  for (int i = 0; i < ptr_vec.size(); i++) {    setup_handle(ptr_vec[i].get(), i, mx_handle_vec);  }  return mx_handle_vec;}/** ----------------------------------------------------------------- ** matlab command functions: caffe_(api_command, arg1, arg2, ...) **/// Usage: caffe_('get_solver', solver_file);static void get_solver(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsChar(prhs[0]),      "Usage: caffe_('get_solver', solver_file)");  char* solver_file = mxArrayToString(prhs[0]);  mxCHECK_FILE_EXIST(solver_file);  SolverParameter solver_param;  ReadSolverParamsFromTextFileOrDie(solver_file, &solver_param);  shared_ptr<Solver<float> > solver(      SolverRegistry<float>::CreateSolver(solver_param));  solvers_.push_back(solver);  plhs[0] = ptr_to_handle<Solver<float> >(solver.get());  mxFree(solver_file);}// Usage: caffe_('solver_get_attr', hSolver)static void solver_get_attr(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('solver_get_attr', hSolver)");  Solver<float>* solver = handle_to_ptr<Solver<float> >(prhs[0]);  const int solver_attr_num = 2;  const char* solver_attrs[solver_attr_num] = { "hNet_net", "hNet_test_nets" };  mxArray* mx_solver_attr = mxCreateStructMatrix(1, 1, solver_attr_num,      solver_attrs);  mxSetField(mx_solver_attr, 0, "hNet_net",      ptr_to_handle<Net<float> >(solver->net().get()));  mxSetField(mx_solver_attr, 0, "hNet_test_nets",      ptr_vec_to_handle_vec<Net<float> >(solver->test_nets()));  plhs[0] = mx_solver_attr;}// Usage: caffe_('solver_get_iter', hSolver)static void solver_get_iter(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('solver_get_iter', hSolver)");  Solver<float>* solver = handle_to_ptr<Solver<float> >(prhs[0]);  plhs[0] = mxCreateDoubleScalar(solver->iter());}// Usage: caffe_('solver_get_max_iter', hSolver)static void solver_get_max_iter(MEX_ARGS) {    mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),        "Usage: caffe_('solver_get_max_iter', hSolver)");    Solver<float>* solver = handle_to_ptr<Solver<float> >(prhs[0]);    plhs[0] = mxCreateDoubleScalar(solver->max_iter());}// Usage: caffe_('solver_restore', hSolver, snapshot_file)static void solver_restore(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]),      "Usage: caffe_('solver_restore', hSolver, snapshot_file)");  Solver<float>* solver = handle_to_ptr<Solver<float> >(prhs[0]);  char* snapshot_file = mxArrayToString(prhs[1]);  mxCHECK_FILE_EXIST(snapshot_file);  solver->Restore(snapshot_file);  mxFree(snapshot_file);}// Usage: caffe_('solver_solve', hSolver)static void solver_solve(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('solver_solve', hSolver)");  Solver<float>* solver = handle_to_ptr<Solver<float> >(prhs[0]);  solver->Solve();}// Usage: caffe_('solver_step', hSolver, iters)static void solver_step(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsDouble(prhs[1]),      "Usage: caffe_('solver_step', hSolver, iters)");  Solver<float>* solver = handle_to_ptr<Solver<float> >(prhs[0]);  int iters = mxGetScalar(prhs[1]);  solver->Step(iters);}// Usage: caffe_('get_net', model_file, phase_name)static void get_net(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsChar(prhs[0]) && mxIsChar(prhs[1]),      "Usage: caffe_('get_net', model_file, phase_name)");  char* model_file = mxArrayToString(prhs[0]);  char* phase_name = mxArrayToString(prhs[1]);  mxCHECK_FILE_EXIST(model_file);  Phase phase;  if (strcmp(phase_name, "train") == 0) {      phase = TRAIN;  } else if (strcmp(phase_name, "test") == 0) {      phase = TEST;  } else {    mxERROR("Unknown phase");  }  shared_ptr<Net<float> > net(new caffe::Net<float>(model_file, phase));  nets_.push_back(net);  plhs[0] = ptr_to_handle<Net<float> >(net.get());  mxFree(model_file);  mxFree(phase_name);}// Usage: caffe_('net_set_phase', hNet, phase_name)static void net_set_phase(MEX_ARGS) {    mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]),        "Usage: caffe_('net_set_phase', hNet, phase_name)");    Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);    char* phase_name = mxArrayToString(prhs[1]);    Phase phase;    if (strcmp(phase_name, "train") == 0) {        phase = TRAIN;    }    else if (strcmp(phase_name, "test") == 0) {        phase = TEST;    }    else {        mxERROR("Unknown phase");    }    net->SetPhase(phase);    mxFree(phase_name);}// Usage: caffe_('net_get_attr', hNet)static void net_get_attr(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('net_get_attr', hNet)");  Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);  const int net_attr_num = 6;  const char* net_attrs[net_attr_num] = { "hLayer_layers", "hBlob_blobs",      "input_blob_indices", "output_blob_indices", "layer_names", "blob_names"};  mxArray* mx_net_attr = mxCreateStructMatrix(1, 1, net_attr_num,      net_attrs);  mxSetField(mx_net_attr, 0, "hLayer_layers",      ptr_vec_to_handle_vec<Layer<float> >(net->layers()));  mxSetField(mx_net_attr, 0, "hBlob_blobs",      ptr_vec_to_handle_vec<Blob<float> >(net->blobs()));  mxSetField(mx_net_attr, 0, "input_blob_indices",      int_vec_to_mx_vec(net->input_blob_indices()));  mxSetField(mx_net_attr, 0, "output_blob_indices",      int_vec_to_mx_vec(net->output_blob_indices()));  mxSetField(mx_net_attr, 0, "layer_names",      str_vec_to_mx_strcell(net->layer_names()));  mxSetField(mx_net_attr, 0, "blob_names",      str_vec_to_mx_strcell(net->blob_names()));  plhs[0] = mx_net_attr;}// Usage: caffe_('net_forward', hNet)static void net_forward(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('net_forward', hNet)");  Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);  net->ForwardPrefilled();}// Usage: caffe_('net_backward', hNet)static void net_backward(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('net_backward', hNet)");  Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);  net->Backward();}// Usage: caffe_('net_copy_from', hNet, weights_file)static void net_copy_from(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]),      "Usage: caffe_('net_copy_from', hNet, weights_file)");  Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);  char* weights_file = mxArrayToString(prhs[1]);  mxCHECK_FILE_EXIST(weights_file);  net->CopyTrainedLayersFrom(weights_file);  mxFree(weights_file);}// Usage: caffe_('net_reshape', hNet)static void net_reshape(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('net_reshape', hNet)");  Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);  net->Reshape();}// Usage: caffe_('net_save', hNet, save_file)static void net_save(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsChar(prhs[1]),      "Usage: caffe_('net_save', hNet, save_file)");  Net<float>* net = handle_to_ptr<Net<float> >(prhs[0]);  char* weights_file = mxArrayToString(prhs[1]);  NetParameter net_param;  net->ToProto(&net_param, false);  WriteProtoToBinaryFile(net_param, weights_file);  mxFree(weights_file);}// Usage: caffe_('layer_get_attr', hLayer)static void layer_get_attr(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('layer_get_attr', hLayer)");  Layer<float>* layer = handle_to_ptr<Layer<float> >(prhs[0]);  const int layer_attr_num = 1;  const char* layer_attrs[layer_attr_num] = { "hBlob_blobs" };  mxArray* mx_layer_attr = mxCreateStructMatrix(1, 1, layer_attr_num,      layer_attrs);  mxSetField(mx_layer_attr, 0, "hBlob_blobs",      ptr_vec_to_handle_vec<Blob<float> >(layer->blobs()));  plhs[0] = mx_layer_attr;}// Usage: caffe_('layer_get_type', hLayer)static void layer_get_type(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('layer_get_type', hLayer)");  Layer<float>* layer = handle_to_ptr<Layer<float> >(prhs[0]);  plhs[0] = mxCreateString(layer->type());}// Usage: caffe_('blob_get_shape', hBlob)static void blob_get_shape(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('blob_get_shape', hBlob)");  Blob<float>* blob = handle_to_ptr<Blob<float> >(prhs[0]);  const int num_axes = blob->num_axes();  mxArray* mx_shape = mxCreateDoubleMatrix(1, num_axes, mxREAL);  double* shape_mem_mtr = mxGetPr(mx_shape);  for (int blob_axis = 0, mat_axis = num_axes - 1; blob_axis < num_axes;       ++blob_axis, --mat_axis) {    shape_mem_mtr[mat_axis] = static_cast<double>(blob->shape(blob_axis));  }  plhs[0] = mx_shape;}// Usage: caffe_('blob_reshape', hBlob, new_shape)static void blob_reshape(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsDouble(prhs[1]),      "Usage: caffe_('blob_reshape', hBlob, new_shape)");  Blob<float>* blob = handle_to_ptr<Blob<float> >(prhs[0]);  const mxArray* mx_shape = prhs[1];  double* shape_mem_mtr = mxGetPr(mx_shape);  const int num_axes = mxGetNumberOfElements(mx_shape);  vector<int> blob_shape(num_axes);  for (int blob_axis = 0, mat_axis = num_axes - 1; blob_axis < num_axes;       ++blob_axis, --mat_axis) {    blob_shape[blob_axis] = static_cast<int>(shape_mem_mtr[mat_axis]);  }  blob->Reshape(blob_shape);}// Usage: caffe_('blob_get_data', hBlob)static void blob_get_data(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('blob_get_data', hBlob)");  Blob<float>* blob = handle_to_ptr<Blob<float> >(prhs[0]);  plhs[0] = blob_to_mx_mat(blob, DATA);}// Usage: caffe_('blob_set_data', hBlob, new_data)static void blob_set_data(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsSingle(prhs[1]),      "Usage: caffe_('blob_set_data', hBlob, new_data)");  Blob<float>* blob = handle_to_ptr<Blob<float> >(prhs[0]);  mx_mat_to_blob(prhs[1], blob, DATA);}// Usage: caffe_('blob_get_diff', hBlob)static void blob_get_diff(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsStruct(prhs[0]),      "Usage: caffe_('blob_get_diff', hBlob)");  Blob<float>* blob = handle_to_ptr<Blob<float> >(prhs[0]);  plhs[0] = blob_to_mx_mat(blob, DIFF);}// Usage: caffe_('blob_set_diff', hBlob, new_diff)static void blob_set_diff(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsStruct(prhs[0]) && mxIsSingle(prhs[1]),      "Usage: caffe_('blob_set_diff', hBlob, new_diff)");  Blob<float>* blob = handle_to_ptr<Blob<float> >(prhs[0]);  mx_mat_to_blob(prhs[1], blob, DIFF);}// Usage: caffe_('set_mode_cpu')static void set_mode_cpu(MEX_ARGS) {  mxCHECK(nrhs == 0, "Usage: caffe_('set_mode_cpu')");  Caffe::set_mode(Caffe::CPU);}// Usage: caffe_('set_mode_gpu')static void set_mode_gpu(MEX_ARGS) {  mxCHECK(nrhs == 0, "Usage: caffe_('set_mode_gpu')");  Caffe::set_mode(Caffe::GPU);}// Usage: caffe_('set_device', device_id)static void set_device(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsDouble(prhs[0]),      "Usage: caffe_('set_device', device_id)");  int device_id = static_cast<int>(mxGetScalar(prhs[0]));  Caffe::SetDevice(device_id);}// Usage: caffe_('get_init_key')static void get_init_key(MEX_ARGS) {  mxCHECK(nrhs == 0, "Usage: caffe_('get_init_key')");  plhs[0] = mxCreateDoubleScalar(init_key);}// Usage: caffe_('reset')static void reset(MEX_ARGS) {  mxCHECK(nrhs == 0, "Usage: caffe_('reset')");  // Clear solvers and stand-alone nets  mexPrintf("Cleared %d solvers and %d stand-alone nets\n",      solvers_.size(), nets_.size());  solvers_.clear();  nets_.clear();  // Generate new init_key, so that handles created before becomes invalid  init_key = static_cast<double>(caffe_rng_rand());}// Usage: caffe_('read_mean', mean_proto_file)static void read_mean(MEX_ARGS) {  mxCHECK(nrhs == 1 && mxIsChar(prhs[0]),      "Usage: caffe_('read_mean', mean_proto_file)");  char* mean_proto_file = mxArrayToString(prhs[0]);  mxCHECK_FILE_EXIST(mean_proto_file);  Blob<float> data_mean;  BlobProto blob_proto;  bool result = ReadProtoFromBinaryFile(mean_proto_file, &blob_proto);  mxCHECK(result, "Could not read your mean file");  data_mean.FromProto(blob_proto);  plhs[0] = blob_to_mx_mat(&data_mean, DATA);  mxFree(mean_proto_file);}// Usage: caffe_('write_mean', mean_data, mean_proto_file)static void write_mean(MEX_ARGS) {  mxCHECK(nrhs == 2 && mxIsSingle(prhs[0]) && mxIsChar(prhs[1]),      "Usage: caffe_('write_mean', mean_data, mean_proto_file)");  char* mean_proto_file = mxArrayToString(prhs[1]);  int ndims = mxGetNumberOfDimensions(prhs[0]);  mxCHECK(ndims >= 2 && ndims <= 3, "mean_data must have at 2 or 3 dimensions");  const mwSize *dims = mxGetDimensions(prhs[0]);  int width = dims[0];  int height = dims[1];  int channels;  if (ndims == 3)    channels = dims[2];  else    channels = 1;  Blob<float> data_mean(1, channels, height, width);  mx_mat_to_blob(prhs[0], &data_mean, DATA);  BlobProto blob_proto;  data_mean.ToProto(&blob_proto, false);  WriteProtoToBinaryFile(blob_proto, mean_proto_file);  mxFree(mean_proto_file);}// Usage: caffe_('version')static void version(MEX_ARGS) {  mxCHECK(nrhs == 0, "Usage: caffe_('version')");  // Return version string  plhs[0] = mxCreateString(AS_STRING(CAFFE_VERSION));}/** ----------------------------------------------------------------- ** Available commands. **/struct handler_registry {  string cmd;  void (*func)(MEX_ARGS);};static handler_registry handlers[] = {  // Public API functions  { "get_solver",         get_solver      },  { "solver_get_attr",    solver_get_attr },  { "solver_get_iter",    solver_get_iter },  { "solver_get_max_iter", solver_get_max_iter },//added  { "solver_restore",     solver_restore  },  { "solver_solve",       solver_solve    },  { "solver_step",        solver_step     },  { "get_net",            get_net         },  { "net_set_phase",      net_set_phase   },//added  { "net_get_attr",       net_get_attr    },  { "net_forward",        net_forward     },  { "net_backward",       net_backward    },  { "net_copy_from",      net_copy_from   },  { "net_reshape",        net_reshape     },  { "net_save",           net_save        },  { "layer_get_attr",     layer_get_attr  },  { "layer_get_type",     layer_get_type  },  { "blob_get_shape",     blob_get_shape  },  { "blob_reshape",       blob_reshape    },  { "blob_get_data",      blob_get_data   },  { "blob_set_data",      blob_set_data   },  { "blob_get_diff",      blob_get_diff   },  { "blob_set_diff",      blob_set_diff   },  { "set_mode_cpu",       set_mode_cpu    },  { "set_mode_gpu",       set_mode_gpu    },  { "set_device",         set_device      },  { "get_init_key",       get_init_key    },  { "reset",              reset           },  { "read_mean",          read_mean       },  { "write_mean",         write_mean      },  { "version",            version         },  // The end.  { "END",                NULL            },};/** ----------------------------------------------------------------- ** matlab entry point. **/// Usage: caffe_(api_command, arg1, arg2, ...)void mexFunction(MEX_ARGS) {  mexLock();  // Avoid clearing the mex file.  mxCHECK(nrhs > 0, "Usage: caffe_(api_command, arg1, arg2, ...)");  // Handle input command  char* cmd = mxArrayToString(prhs[0]);  bool dispatched = false;  // Dispatch to cmd handler  for (int i = 0; handlers[i].func != NULL; i++) {    if (handlers[i].cmd.compare(cmd) == 0) {      handlers[i].func(nlhs, plhs, nrhs-1, prhs+1);      dispatched = true;      break;    }  }  if (!dispatched) {    ostringstream error_msg;    error_msg << "Unknown command '" << cmd << "'";    mxERROR(error_msg.str().c_str());  }  mxFree(cmd);}