我用的是EclipseCDT，可以把Caffe的工程引入进来

首先导入makefile工程到eclipse
       File→New→Project→C/C++ →Makefile Project with Existing Code.
然后选择从现有代码创建一个makefile项目
       选Create a new Makefile Project from existing code
       设置工程名
       设置代码路径
       语言选C++
       工具链选linux GCC
然后就可以把工程引入进来了

以上~

可以自己写个matlab的扩展，使用memorydatalayer进行输入，然后将得到的blob内存数据结合matlab的c接口转换成matlab的矩阵。blob的读取百度可以找到
下面是读取pool5的代码示例：
boost::shared_ptr<caffe::Blob<NetF>> pool5 = _net->blob_by_name("pool5");
    cv::Mat Pool5FeatureMat(pool5->num(), pool5->width()*pool5->height()*pool5->channels(), CV_32F);
    int channel_step = pool5->height()*pool5->width();
    for (size_t n = 0; n < pool5->num(); n++)
    {
        for (size_t c = 0; c < pool5->channels(); c++)
        {
            
            for (size_t h = 0; h < pool5->height(); h++)
            {
                for (size_t w = 0; w < pool5->width(); w++)
                {
                    float value = pool5->data_at(n, c, h, w);
                }
                
            }
        }
    }
然后我们使用matlab的接口就可以自己进行matlab的矩阵转换了，如果是单张图片num一层的循环可以去掉。
下面我给出c++将数组转成matlab的矩阵的代码:
#include <iostream.h>  
#include "xMatrix.h"  
#include "MatlabEngine.h"  
void main()  
{  
    printf("matlab&c++ /n      /  
        visualsan@yahoo.cn  NUAA/  
        2011/n------------------------/n");  
    //matlab 引擎  
    CMatlabEngine  g;  
    //打开  
    cout<<"Open Matlab Engine..../n";  
    if( g.OpenEngine() )  
    {  
        //1.从matlab中获取一个5X5的随机矩阵  
        char tmp[200];  
          
        //准备矩阵5X5  
        double  mr[]=  
        {  
            1.2,4.4,5.5,6.6,7.7,  
            1.12,1.44,15.5,1.66,1.77,  
            21.2,2.44,2.55,2.66,2.77,  
            3.12,3.44,3.55,3.66,3.77,  
            4.12,4.44,4.55,4.66,4.77  
        };  
        //转换为matlab格式，按列存储  
        xMatrixDouble::C2Mat(mr,5,5,mr);  
        xMatrixDouble  xd(5,5,mr);  
        //写入矩阵  
        g.PutVar("text_matrix",xd.GetArray());  
        //计算矩阵的逆矩阵  
        g.EvalString("text_matrix_inv=inv(text_matrix);");  
        mxWrap  text_matrix;  
        mxWrap  text_matrix_inv;  
        //获取名称为text_matrix的矩阵  
        g.GetVar("text_matrix",&text_matrix);  
        xMatrixDouble *pd=(xMatrixDouble*)text_matrix.GetArrayInterface();  
        //获取名称为text_matrix_inv的逆矩阵  
        g.GetVar("text_matrix_inv",&text_matrix_inv);  
        xMatrixDouble *pd_inv=(xMatrixDouble*)text_matrix_inv.GetArrayInterface();  
        //打印矩阵  
        cout<<"原矩阵:/n";  
        for (int i=0;i<xd.GetR();i++)  
        {  
            for (int j=0;j<xd.GetC();j++)  
            {  
                cout<<xd.GetRealAt(i,j)<<" ";  
            }  
            cout<<endl;  
        }  
        cout<<"从matlab中读取的矩阵:/n";  
        for ( i=0;i<pd->GetR();i++)  
        {  
            for (int j=0;j<pd->GetC();j++)  
            {  
                cout<<pd->GetRealAt(i,j)<<" ";  
            }  
            cout<<endl;  
        }  
        cout<<"从matlab中读取的逆矩阵:/n";  
        for ( i=0;i<pd_inv->GetR();i++)  
        {  
            for (int j=0;j<pd_inv->GetC();j++)  
            {  
                cout<<pd_inv->GetRealAt(i,j)<<" ";  
            }  
            cout<<endl;  
        }  
  
        //关闭引擎  
        g.CloseEngine();  
    }  
  
      
}  
顺便把c++读取matlab矩阵的代码也贴出来吧
#include <iostream.h>  
#include "xMatrix.h"  
#include "MatlabEngine.h"  
void main()  
{  
    printf("matlab&c++ /n      /  
        visualsan@yahoo.cn  NUAA/  
        2011/n------------------------/n");  
    //matlab 引擎  
    CMatlabEngine  g;  
    //打开  
    cout<<"Open Matlab Engine..../n";  
    if( g.OpenEngine() )  
    {  
        //1.从matlab中获取一个5X5的随机矩阵  
        char tmp[200];  
        //调用rand生成随机矩阵  
        strcpy(tmp,"rang_natrix=rand(5);");  
        g.EvalString(tmp);  
        mxWrap  rang_natrix;  
        //获取名称为rang_natrix的矩阵  
        g.GetVar("rang_natrix",&rang_natrix);  
        xMatrixDouble *pd=(xMatrixDouble*)rang_natrix.GetArrayInterface();  
        //打印矩阵  
        for (int i=0;i<pd->GetR();i++)  
        {  
            for (int j=0;j<pd->GetC();j++)  
            {  
                cout<<pd->GetRealAt(i,j)<<" ";  
            }  
            cout<<endl;  
        }  
        //关闭引擎  
        g.CloseEngine();  
    }      
}
这样基本你需要的操作就都有了。

现在的caffe版本已经支持多GPU并行了，原理比较简单，就是每个GPU分别算一个batch，n个GPU，实际的batchsize就是n*batch，比如原来用一个GPU，batchsize设置成256，现在用4个GPU，把batchsize设置成64，和原来的一个GPU的运算是等价的。
 
实际使用的时候基本不用设置，和原来一样编译好就可以用了。命令就是在-gpu 后面对多个GPU号用逗号隔开，比如-gpu 1,2,3,4 就是同时使用1-4共4个GPU，GPU编号可以不连续，或者直接用-gpu all，就是使用所有的GPU。
 
官方的github里是这样写的
54
正好我也在用顺手截图
55
可以看到输出的log里提示了使用了两个GPU

我很想详细讲一下的，然而自己才疏学浅，学艺不精，只能大概讲讲，就当抛砖引玉了(⊙v⊙)
 
很多人建议caffe从四个层次来理解：Blob、Layer、Net、Solver，和题主的问题还挺match的
 
1.Blob
Blob是caffe基本的数据结构，用四维矩阵 Batch×Channel×Height×Weight表示，存储了网络的神经元激活值和网络参数，以及相应的梯度（激活值的残差和dW、db)。其中包含有cpu_data、gpu_data、cpu_diff、gpu_diff、mutable_cpu_data、mutable_gpu_data、mutable_cpu_diff、mutable_gpu_diff这一堆很像的东西，分别表示存储在CPU和GPU上的数据（印象中二者的值好像是会自动同步成一致的），其中带data的里面存储的是激活值和W、b，diff中存储的是残差和dW、db，另外带mutable和不带mutable的一对指针所指的位置是相同的，只是不带mutable的只读，而带mutable的可写。
 
2.Layer
Layer代表了神经网络中各种各样的层，组合成一个网络。一般一个图像或样本会从数据层中读进来，然后一层一层的往后传。除了数据层比较特殊之外，其余大部分层都包含4个函数：LayerSetUp、Reshape、Forward、Backward。其中LayerSetup用于初始化层，开辟空间，填充初始值什么的。Reshape是对输入值进行维度变换，比如pooling接全连接层的时候要先拉成一个向量再计算。Forward是前向传播，Backward是后向传播。当然对于我这种喜欢偷懒的童鞋一般学习的时候最喜欢看各种层的Backward函数了，最好是对着公式边推导边看，可以有更直观的理解。
那么数据是如何在层之间传递的呢？每一层都会有一个（或多个）Bottom和top，分别存储输入和输出，比如bottom[0]->cpu_data()存输入的神经元激活值，换成top存输出的，换成cpu_diff()存的是激活值的残差，换成gpu是存在GPU上的数据，再带上mutable就可写了，这些是神经元激活值相关的，如果这个层前后有多个输入输出层，就会有bottom[1]，比如accuracy_layer就有两个输入，fc8和label。而每层的参数会存在this->blobs_里，一般this->blobs_[0]存W，this->blobs_[1]存b，this->blobs_[0]->cpu_data()存的是W的值，this->blobs_[0]->cpu_diff()存的梯度dW，b和db也类似，然后换成gpu是存在GPU上的数据，再带上mutable就可写了。。（各种变量好多好晕，但愿我说清楚了。。）
哦对了，凡是能在GPU上运算的层都会有名字相同的cpp和cu两个文件，cu文件中运算时基本都调用了cuda核函数，可以在math_function.cu中查看。
 
3.Net
Net就是把各种层按train_val.prototxt的定义堆叠在一起，首先进行每个层的初始化，然后不断进行Update，每更新一次就进行一次整体的前向传播和反向传播，然后把每层计算得到的梯度计算进去，完成一次更新，这里注意每层在Backward中只是计算dW和db，而W和b的更新是在Net的Update里最后一起更新的。而且在caffe里训练模型的时候一般会有两个Net，一个train一个test。刚开始训练网络时前面的一大堆输出，网络的结构什么的也都是这里输出的。
 
4.Solver
Solver是按solver.prototxt的参数定义对Net进行训练，首先会初始化一个TrainNet和一个TestNet，然后其中的Step函数会对网络不断进行迭代，主要就是两个步骤反复迭代：①不断利用ComputeUpdateValue计算迭代相关参数，比如计算learning rate，把weight decay加上什么的，②调用Net的Update函数对整个网络进行更新。迭代中的一大堆输出也是在这里输出的，比如当前的loss和learning rate什么的。
 
综上，为了把整个过程串起来，可以从tools/caffe这个我们最常用的函数入手，训练一个网络然后跟着数据的流动方向看看一个网络是怎么更新的，然后找自己比较感兴趣的地方细看。我本人主要看各种Layer的实现比较多，对其余的部分理解也有限，希望可以一起讨论~
 
（针对最近大大们头疼的侵权问题，在这里弱弱的加一句：本内容为本人原创，仅授权给CaffeCN使用，如需转载须注明转载来源。(⊙v⊙)）

刚开学比较无聊，我想借这个问题讲一下cnn的输入输出维度怎么算的。。
先说结论：一个卷积核是三维的（channel×height×width），每个卷积层有若干卷积核，一个卷积核输出的feature map是二维的，每层输出的feature map数量和卷积核数量相等。
 
以经典的AlexNet为例，先上图
89
输入图像是227×227×3（注1），conv1的卷积核参数是：
kernel_size: 11
stride: 4
num_output: 96
因此实际的卷积核维度是11×11×3，channel是输入的图像的第三维（如果是后面的卷积层，其卷积核的channel是与之做卷积的输入的feature map的数量），即3，做卷积的时候，是11×11×3的卷积核和输入图像里的11×11×3的块进行卷积，得到一个值，卷积的过程是在height和width上滑动，第三维上不滑动，因此得到的feature map是二维的，公式是
$$\text{FeaSize}=\lfloor\frac{\text{InputSize}-\text{KernelSize}}{\text{Stride}}\rfloor+1$$
（注意这里是下取整，pooling是上取整，二者是反着的）
因此conv1输出的feature map size为$$\lfloor\frac{227-11}{4}\rfloor+1=55$$
输出的feature map数量和卷积核数量相同，为96，因此conv1的输出是55×55×96
 
后面的层类似，只要注意卷积核的第三维是由输入的feature map的数量决定就可以了，这一点从图上也可以看出来。
 
最后祝大家春节快乐~
 
注1：论文里是224×224×3，caffe官网的例子里是227×227×3，这里以官网的例子为例。
 
（针对最近大大们头疼的侵权问题，在这里弱弱的加一句：本内容为本人原创，仅授权给CaffeCN社区（caffecn.cn）使用，如需转载须注明转载来源。(⊙v⊙)）

简单说下。
假设你的batch size是32，你单卡，每次迭代处理的就是32张图像。
你现在换了两卡，并行处理，你实际上每次迭代处理的图像就是64张。
训练速度的提升，体现在每次迭代的loss下降更多，收敛更快。
也就是说，以前可能需要100万次迭代才能收敛，现在可能50-70万次就可以了。
所以从这个角度说，训练时间缩短了，训练速度提升了。