深度学习框架Caffe到底是怎么支持ResNet的

Caffe（全称Convolutional Architecture for Fast Feature Embedding）是一个兼具表达性、速度和思维模块化的深度学习框架，由伯克利人工智能研究小组和伯克利视觉和学习中心开发。虽然其内核是用C++编写的，但Caffe有Python和Matlab相关接口。Caffe支持多种类型的深度学习架构，面向图像分类和图像分割，还支持CNN、RCNN、LSTM和全连接神经网络设计。Caffe支持基于GPU和CPU的加速计算内核库，如NVIDIA cuDNN和Intel MKL。Caffe是一个深度学习框架，最初开发于加利福尼亚大学伯克利分校。Caffe在BSD许可下开源，使用C++编写，带有Python接口。是贾扬清在加州大学伯克利分校攻读博士期间创建了Caffe项目。项目托管于GitHub，拥有众多贡献者。Caffe应用于学术研究项目、初创原型甚至视觉、语音和多媒体领域的大规模工业应用。雅虎还将Caffe与Apache Spark集成在一起，创建了一个分布式深度学习框架CaffeOnSpark。2017年4月，Facebook发布Caffe2，加入了递归神经网络等新功能。2018年3月底，Caffe2并入PyTorch。

1、caffe和coffe主要区别在于起源、应用场合等方面，caffe起源于意大利语，coffee起源于美式英语。 2、在运用的时候，caffe一般指的是意式咖啡，多出现于意式菜单上，coffee则多出现在咖啡店招牌或者单品上。

CAFFE是什么意思

Caffe　n.卡菲

还不错的。

一、流程1)准备数据集在深度学习中，数据集准备往往是最难的事情，因为数据涉及隐私、商业等各方面，获取难度很大，不过有很多科研机构公布了供学习使用的数据集，我们可以在网上下载。还有一种获取的途径是论文，查阅国内外相关的论文，看他们是如何获取到数据集的，我们也可以使用他 们所采用的数据集。2)数据转换为lmdb格式生成lmdb格式的文件通过脚本来实现，这就需要我们自己编写脚本文件，这里遇到了一些坑，首先使用vim创建脚本文件create1.sh3)计算均值并保存（非必需）图片减去均值再训练，会提高训练速度和精度。因此，一般都会有这个操作。caffe程序提供了一个计算均值的文件compute_image_mean.cpp，我们直接使用就可以了4)创建模型并编写配置文件5)训练和测试如果前面都没有问题，数据准备好了，配置文件也配置好了，这一步就比较简单了。直接训练即可，可以实时在命令行下查看其精度与loss。这种训练方式太麻烦了，我用过一款叫大智大通的产品还不错，免费的，直接上传数据它自己就训练好了，地址是三个w点icccall点com。

配置操作系统：14.04 Ubuntu Kylin 64位cuda版本：7.5GPU：k20c 、cuda 安装我采用.ded包安装式网利用种手安装.run文件式由于楼主第采用该种式安装导致各种驱问题系统重新安装N所换安装1.nvidia官网载.ded安装包（根据自系统选择版本）2. install repository meta-datasudo dpkg -i cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.deb3. Update the Apt repository cachesudo apt-get update4. Install CUDAsudo apt-get install cuda二、环境变量设置1.设置PATH/etc/profile添加环境变量文件添加PATH=/usr/local/cuda-7.5/bin:$PATHexport PATH保存命令使立即效source /etc/profile2.添加lib库/etc/ld.so.conf.d/加入文件cuda.conf/usr/local/cuda-7.5/lib64输入命令sudo ldconfig使立即效执行命令,确定驱功安装cat /pror/driver/nvidia/versionNVRM version: NVIDIA UNIX x86_64 Kernel Module 352.63 Sat Nov 7 21:25:42 PST 2015GCC version: gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04)拷贝例程序dir例程序/usr/local/cuda/samples份copy份编译cuda-install-samples-7.5.sh 3.安装Opencv尽量要手安装Github已经写完整安装脚本：chmod +x *.shsudo./opencv2_4_9.sh4.安装依赖库sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libboost-all-dev libhdf5-serial-dev libgflags-dev libgoogle-glog-dev liblmdb-dev protobuf-compiler5.安装Pythonsudo apt-get install python-dev python-pip执行命令安装编译caffe python wrapper 所需要额外包for req in $(cat requirements.txt); do sudo pip install $req; done建议安装Anaconda包包能独立于系统自带python库并且提供部Caffe需要科运算Python库并且~/.bashrc添加library path# add library pathLD_LIBRARY_PATH=your_anaconda_path/lib:$LD_LIBRARY_PATHexport LD_LIBRARY_PATH6.安装cuDNN（选）CuDNN专门针Deep Learning框架设计套GPU计算加速案目前支持DL库包括CaffeConvNet, Torch7等载 基本原理lib文件加入系统能找lib文件夹 文件加系统能找include文件夹加CUDA文件夹tar-xzvf cudnn-6.5-linux-R1.tgzcd cudnn-6.5-linux-R1sudo cp lib* /usr/local/cuda/lib64/ （该命令解压文件夹运行终端）sudo cp cudnn.h /usr/local/cuda/include/执行发现找库 报错error while loading shared libraries: libcudnn.so.6.5: cannot open shared object file: No such file or directorylib文件夹系统路径用ls -al发现文件权限问题用述命令先删除软连接cd /usr/local/cuda/lib64/sudo rm -rf libcudnn.so libcudnn.so.6.5修改文件权限并创建新软连接sudo chmod u=rwx,g=rx,o=rx libcudnn.so.6.5.18sudo ln -s libcudnn.so.6.5.18libcudnn.so.6.5sudo ln -s libcudnn.so.6.5libcudnn.so7.安装OpenBLAS载编译openBLAS默认安装目录 /opt/OpenBLAS~/.bashrc 添加路径LD_LIBRARY_PATH=/opt/OpenBLAS/lib:$LD_LIBRARY_PATHexport LD_LIBRARY_PATH/etc/ld.so.conf添加文件路径/opt/OpenBLAS/lib添加文件,运行sudo ld config8.修改Makefile.conf(根据官网Makefile.conf.example注释修改)Make all -j12Make testMake runtest编译Matlab wrappermakematcaffe编译Python wrappermakepycaffe

咖啡

Windows 8.1下Caffe环境搭建一、环境准备1.Windows 8.1系统2.Visual Studio 2013 UltimateVisual studio 2013 Ultimate下载地址：二、Visual Studio 2013 Ultimate安装教程（安装+注册）等待下载完成之后，虽然下载文件是ios格式，但我们可以用解压缩工具解压打开。解压好后，双击vs_ultimate.exe，开始安装。新旧版本VS是可以共存的，但是在安装过程中，旧版本的VS一定要先关闭。自定义选择安装路径时，注意所属路径的预留空间要充足，否则安装会失败，同意许可条款，进行下一步。在选择安装的可选功能这里，大家可以根据自己需要勾选，也可以默认全选。把鼠标放在文字上，会弹出各个功能详细描述。选择常用的功能，另外要注意预留空间，开始安装。等待大概30分钟，就可以完成安装。安装过程中，VS会占用很多的系统资源，所以最好不要开启其他软件，等待安装。第一次打开VS2013，需要进行一些基本配置，如开发设置、颜色主题，根据自己的需求设置，然后等待几分钟就可以使用。由于VS2013引入了一种联网 IDE 体验，大家可以使用微软的账户登录，而且其还自动采用联网 IDE 体验的设备上同步设置，包括快捷键、Visual Studio 外观（主题、字体等）各种类别同步的设置。最后要给VS注册一下，不然软件是有30天的试用期。打开VS2013，在工具栏中找到帮助选项卡，点击注册产品，会弹出一个对话框，里面会显示软件的注册状态。点击更改我的产品许可证，会弹出一个对话框，要求输入产品密钥。此时，需要一个产品密钥，提供一个可用的密钥：VS2013_RTM_ULT_CHS KEY： BWG7X-J98B3-W34RT-33B3R-JVYW若密钥失效，大家要自己到网上去搜索了。注册成功后，所有的操作算是基本完成，可以正常使用。三、下载Microsoft/Caffe源码四、编译Caffe源码1. 解压源码（我安装于D盘，根据个人习惯安装于哪个盘，不提倡安装于C盘）2.进入目录 D:caffe-masterwindows将文件“CommonSettings.props.exemple”复制一下，粘贴，并重命名为“CommonSetting.props”在进行此操作的时候，有人也许会遇到这样的问题，文件的后缀名怎么修改呢？提示：如何修改文件的后缀名（W8.1系统）1） 在win8.1中，双击界面中的“这台电脑”，打开资源管理器。点击导航栏中的“查看”选项，勾选“文件扩展名”复选框按钮。2） 此时文件的后面就会出现文件后缀名或文件扩展名了。3） 右键单击需要修改扩展名的文件，然后在列表中选择“重命名”选项。4） 然后输入新的扩展名，鼠标点击桌面空白处。在弹出的窗口中点击“是”按钮即可。3. 打开文件“CommonSetting.props”，加粗字体为修改后的内容，修改位置应该在用写字板方式打开之后，文件的第9-10行，修改内容如下：<CpuOnlyBuild>true</CpuOnlyBuild><UseCuDNN>false</UseCuDNN>4. 双击D:caffe-masterwindows目录下"caffe.sln”,自动打开安装好的VS2013。5. 单击 VS2013”生成"菜单，单击"重新生成解决方案"。开始了漫长时间的编译过程，请耐心等待，微软会自动帮我们生成全部的依赖包。依赖包全部在文件夹D:NugetPackages中。五、编译中可能出现的问题error C2220: 警告被视为错误- 没有生成"libcaffe.lib" 编译过程中出现警告，编译器将警告视为错误。解决方法：1单击"项目"--"libcafee属性","将警告是为错误"改为否。2修改后，单击“生成”--“清除解决方案”，然后单击“生成”--“生成解决方案”。

这个问题首先你要理解batchnormal是做什么的。它其实做了两件事。1) 输入归一化 x_norm = (x-u)/std, 其中u和std是个累计计算的均值和方差。2）y=alpha×x_norm + beta，对归一化后的x进行比例缩放和位移。其中alpha和beta是通过迭代学习的。那么caffe中的bn层其实只做了第一件事。scale层做了第二件事。这样你也就理解了scale层里为什么要设置bias_term=True，这个偏置就对应2）件事里的beta。我在网上讲caffe，欢迎来听讲。

只在Linux环境下用过Caffe，（官方似乎还没给出Windows版本，但有人给出了解决方案：niuzhiheng/caffe · GitHub）。Caffe提供了MATLAB接口，可以直接读取caffemodel中的模型参数，之后想怎么存就是你自己的事啦。以CaffeNet为例：% add path for caffe"s matlab interfaceaddpath("~/Deep.Learning/caffe-master/matlab");% define constant variableskLayerIndConv = 1; % conv_1kLayerIndFCnt = 16; % fc_6kProtoFilePath = "./deploy.prototxt";kModelFilePath = "./bvlc_alexnet.caffemodel";% load caffe modelcaffeNet = caffe.Net(kProtoFilePath, kModelFilePath, "test");% read parameters in the <conv_1> layerconvKnlLst = caffeNet.layer_vec(kLayerIndConv).params(1).get_data();biasVecLst = caffeNet.layer_vec(kLayerIndConv).params(2).get_data();% read parameters in the <fc_6> layerfcntWeiMat = caffeNet.layer_vec(kLayerIndFCnt).params(1).get_data();biasVecLst = caffeNet.layer_vec(kLayerIndFCnt).params(2).get_data();% reset caffe modelcaffe.reset_all();具体的参数编号（params的输入参数），是在prototxt文件定义的。

Caffe是目前深度学习比较优秀好用的一个开源库，采样c++和CUDA实现，具有速度快，模型定义方便等优点。学习了几天过后，发现也有一个不方便的地方，就是在我的程序中调用Caffe做图像分类没有直接的接口。Caffe的数据层可以从数据库（支持leveldb、lmdb、hdf5）、图片、和内存中读入。我们要在程序中使用，当然得从内存中读入，我们首先在模型定义文件中定义数据层：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 = 0; i < 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 = 0; j < result.size(); ++j) { const Dtype* result_vec = result[j]->cpu_data(); for (int k = 0; k < 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_length; i < valid_length; i++) { 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 = 0; i < 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 = 0; j < 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_length; i < valid_length; i++) { for(int j = 0; j < size; j++) 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 = 0; i < 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 = 0; j < 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_length; i < valid_length; i++) { 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 = 0; i < 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 = 0; j < result[0]->num(); j++) { const Dtype * ptr = result_vec + j * dim; vector<Dtype> one_; for(int k = 0; k < 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"}

Ubuntu 14.04 64位机上用Caffe+MNIST训练Lenet网络操作步骤将终端定位到Caffe根目录；2.MNIST数据库并解压缩：$ ./data/mnist/get_mnist.sh3.将其转换成Lmdb数据库格式：$ ./examples/mnist/create_mnist.sh执行完此shell脚本后，会在./examples/mnist下增加两个新目录，mnist_test_lmdb和mnist_train_lmdb4.train model：$ ./examples/mnist/train_lenet.sh(1)、使用LeNet网络(《Gradient-BasedLearning Applied to Document Recognition》)；(2)、使用./examples/mnist/lenet_train_test.prototxtmodel；(3)、使用./examples/mnist/lenet_solver.prototxtmodel；(4)、执行train_lenet.sh脚本，会调用./build/tools目录下的caffe执行文件，此执行文件的实现是./tools目录下的caffe.cpp文件；(5)、执行此脚本后，会生成几个文件，其中./examples/mnist/lenet_iter_10000.caffemodel则是最终训练生成的model文件；(6)、以上默认的是在GPU模式下运行，如果想让其在CPU模式下运行，只需将lenet_solver.prototxt文件中的solver_mode字段值由原来的GPU改为CPU即可。

　　观察caffe-master的第三方程序包，这个与caffe-master本文件夹都需要加上去的。所以在属性表里，先后需要include以下这些：（路径请自行修改）　　D:caffe-masterinclude　　D:NugetPackagesoost.1.59.0.0lib ativeinclude　　D:NugetPackagesglog.0.3.3.0uild ativeinclude　　D:NugetPackagesgflags.2.1.2.1uild ativeinclude　　D:NugetPackagesprotobuf-v120.2.6.1uild ativeinclude　　C:Program FilesNVIDIA GPU Computing ToolkitCUDAv7.5include　　D:NugetPackagesOpenBLAS.0.2.14.1lib ativeinclude　　D:caffe-masterincludecaffelayers　　D:NugetPackagesOpenCV.2.4.10uild ativeinclude　　D:NugetPackagesOpenCV.2.4.10uild ativeincludeopencv　　D:NugetPackagesOpenCV.2.4.10uild ativeincludeopencv2　　最后一项是CUDA的配置路径，找一下应该就可以找到。　　那么我们的附加依赖项需要添加：　　libcaffe.lib　　libprotobuf.lib　　opencv_highgui2410.lib　　opencv_core2410.lib　　opencv_imgproc2410.lib　　libglog.lib　　gflags.lib　　libopenblas.dll.a　　hdf5.lib　　hdf5_hl.lib　　cublas.lib　　cublas_device.lib　　cuda.lib　　cudadevrt.lib　　cudnn.lib　　cudart.lib　　cufft.lib　　cudart_static.lib　　cufftw.lib　　cusparse.lib　　cusolver.lib　　curand.lib　　nppc.lib　　OpenCL.lib　　对了，最后别忘了配置环境变量哟，配置完之后重启一遍：　　D:NugetPackagesgflags.2.1.2.1uild ativex64v120dynamicLib　　D:NugetPackageshdf5-v120-complete.1.8.15.2lib ativeinx64　　D:NugetPackagesglog.0.3.3.0uild ativeinx64v120Releasedynamic　　D:NugetPackagesOpenBLAS.0.2.14.1lib ativeinx64　　D:NugetPackagesgflags.2.1.2.1uild ativex64v120dynamicLib　　D:NugetPackagesOpenCV.2.4.10uild ativeinx64v120Release　　D:caffe-masterBuildx64Release　　 　　那么在做完这些之后，我们就可以在新建工程里使用Caffe的接口了

你好对于caffe中的deconvolution和upsample的区别：1. caffe的deconvolution又被叫做transposed convolution，例如在TensorFlow中。查资料的时候可以多用个关键字。2. upsampling可以通过特定kernel的deconvolution 来实现，顺便把learning rate 设成0.现在可以通过weight_filler去设。老版是在Python接口下用net surgery来做的。3、按照字面意思定义的upsampling，conv+maxpooling+upsampling必然会造成信息丢失，无法做到精确的点对点匹配。而deconvolution 则不一定希望对你有帮助

你想调用你的模型，最简单的办法是看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就知道跟普通指针有什么不同了

训练配置:batchsize=128 caffe自有的imagenet with cuDNN模型快于googlenet with cuDNN VGG16层不用cuDNN慢于caffe自有的imagenet with cuDNN模型VGG19层不用cuDNN慢于caffe自有的imagenet with cuDNN模型一、CAFFE 自带配置，使用cuDNN Forward速度 : 220ms Backward速度 :360ms二、CAFFE 自带配置，不使用cuDNN Forward速度 : 300ms Backward速度 :410ms三、GoogleNet，使用cuDNN Forward速度 : 614ms Backward速度 :1377ms四、GoogleNet，不使用cuDNN Forward速度 : 1145ms Backward速度 :2009ms五、VGG16层，使用cuDNN Forward速度 : 3101ms Backward速度 :8002ms六、VGG19层，使用cuDNN Forward速度 : 3972ms Backward速度 :8540ms

只在Linux环境下用过Caffe，（官方似乎还没给出Windows版本，但有人给出了解决方案：niuzhiheng/caffe · GitHub）。Caffe提供了MATLAB接口，可以直接读取caffemodel中的模型参数，之后想怎么存就是你自己的事啦。以CaffeNet为例：% add path for caffe"s matlab interfaceaddpath("~/Deep.Learning/caffe-master/matlab");% define constant variableskLayerIndConv = 1; % conv_1kLayerIndFCnt = 16; % fc_6kProtoFilePath = "./deploy.prototxt";kModelFilePath = "./bvlc_alexnet.caffemodel";% load caffe modelcaffeNet = caffe.Net(kProtoFilePath, kModelFilePath, "test");% read parameters in the <conv_1> layerconvKnlLst = caffeNet.layer_vec(kLayerIndConv).params(1).get_data();biasVecLst = caffeNet.layer_vec(kLayerIndConv).params(2).get_data();% read parameters in the <fc_6> layerfcntWeiMat = caffeNet.layer_vec(kLayerIndFCnt).params(1).get_data();biasVecLst = caffeNet.layer_vec(kLayerIndFCnt).params(2).get_data();% reset caffe modelcaffe.reset_all();具体的参数编号（params的输入参数），是在prototxt文件定义的。

如何在linux系统下安装caffeCaffe需要预先安装一些依赖项，首先是CUDA驱动。不论是CentOS还是Ubuntu都预装了开源的nouveau显卡驱动（SUSE没有这种问题），如果不禁用，则CUDA驱动不能正确安装。以Ubuntu为例，介绍一

意大利咖啡 　　意大利咖啡Espresso是意式咖啡的精髓，他的做法起源于意大利，在意大利文中是“特别快”的意思，其特征乃是利用蒸汽压力，瞬间将咖啡液抽出。不知道大家有没有喝过意大利咖啡呢?对意大利咖啡有没有了解呢?下面，我将为大家介绍意大利咖啡的相关知识，快来看看吧! 　　意大利咖啡的名称 　　意大利咖啡世界驰名，到意大利旅游有机会一定要品尝一下意大利咖啡。好在意大利的咖啡是国民必须品，价格不贵。在一般的咖啡馆都有明码标价，不过提醒一下，站着喝比坐着喝便宜哦!还有在街头咖啡自动收货机上也有咖啡出售，质量也很好，下面翻译一下常见咖啡意大利名称和简介，大家可以根据自己的喜好选择。 　　Orzo espresso或者cappuccinodu2019orzo：orzo是意大利语里大麦的意思，该种咖啡是非常香醇的大麦浓缩咖啡或卡布奇诺，相当推荐，很多意大利人会以这个代替咖啡给小朋友或不喜欢咖啡因的人喝，由大麦谷类烘培而成，拥有跟咖啡一样的香气，可说是咖啡的替代品。该种咖啡味道略苦而且具有浓郁的芳香气味，并且具有咖啡不具备的特色：任何时间均可饮用，甚至是睡前，因为其不含刺激神经的成分，自然、健康、营养丰富。其中克洛诗丹(Crastan)是意大利最大的速溶咖啡代替品品牌。 　　Caffe这是小小杯的浓缩咖啡，蛮建议尝试看看的，咖啡香浓，加个1-2匙糖进去，非常顺口! 　　Caffe doppio：即double coffee,两份浓缩咖啡的超浓咖啡 　　Caffe lungo：直译为long coffee,一份浓缩咖啡再加入很多的热开水 　　Caffe americano:美式咖啡，是较淡的咖啡，如果你想加牛奶要另外要老板说要加Latte 　　Caffe latte：在意大利点拿铁咖啡可不能单说Latte，否则送上来的是一杯牛奶而已，要说Caffe Latte Cappuccino或“cappuccio”：早餐最受欢迎的卡布奇诺，浓缩咖啡加打泡牛奶，饭后可别点这个，意大利人会觉得很奇怪，太多奶了 　　Caffe macchiato：玛琪雅朵，小小杯的浓缩咖啡加入一点点牛奶，macchiato意思是脏渍，因为咖啡上有牛奶"渍"而得其名。 　　Latte macchiato：它是我们平时说的“拿鉄”咖啡。和Caffemacchiato不同的在於它的牛奶比较多，咖啡只有一点，即为牛奶咖啡如果有朋友喜欢“实惠又大碗”的话，可以点点这个。 　　Caffe corretto：浓缩咖啡加入一杯grappa或其它烈酒 　　Caffe marocchino：米兰越来越流行的咖啡，浓缩咖啡上加可可跟鲜奶油 　　Caffe/cappuccino decaffeinato：低咖啡因的咖啡或卡布奇诺 　　Caffe/cappuccino Hag：Hag是意大利境内较有名的低咖啡因牌子 　　Caffe shakerato:夏天最棒的冰摇咖啡。自十七世纪第一家咖啡馆在水城威尼斯开张至今，咖啡已经成为意大利文化中无可争议的主角之一。 　　据意大利安莎社的统计，意大利人每人每年喝600杯咖啡，在世界上排名第六，位于美国、德国、法国、西班牙和英国之后。另外意大利的蒸馏咖啡咖啡机产量名列世界首位。 　　意大利咖啡的与众不同 　　意大利咖啡之所以与众不同，是因为在它形成被赋予特定的意思。工作之余的意大利人喜欢以咖啡提神，但为了节省时间，他们需要一杯简单而且浓厚的`咖啡，所以才有了其代表饮品Espresso，也就是浓缩咖啡的意思。 　　据了解，这种意大利咖啡不但香浓醇滑，做法也简单，只要将煮沸的开水，利用蒸气压力迫使热水穿过非常幼细并经过挤压的咖啡粉末，吸取咖啡最为浓郁的口味，然后滴入下面的杯中，冲调时不能萃取过分，因此咖啡机必须能够非常迅速地关闭，当咖啡机里滴出带有金黄色的咖啡时，这就是Espresso。由于是浓缩，所以一般都用小杯盛用，而且这种咖啡还被作为花式咖啡的基底。 　　意大利浓缩咖啡用小杯品尝，最好在三口之内喝完。饮用之时，无须加糖加奶，净品其中之味。 　　怎样才算是一杯好的意大利浓缩咖啡呢?主要需考查三个要素： 　　一、完美的意大利浓缩咖啡，表面会覆盖着一层浓郁的赤红色克利玛(是咖啡表面上深褐色的泡沫，含有咖啡中关键的香气分子); 　　二、好的意大利浓缩咖啡喝完后杯内会留有淳郁的香味; 　　三、观察克利玛“挂杯”(残留在杯壁上)的程度。挂杯多的就是好的意大利浓缩咖啡，在国外，如果没有“挂杯”是可以拒绝付账的。 　　意大利咖啡的种类 　　“Espresso”是意大利语“快递”或“快速”的意思。意大利咖啡被称为上好咖啡的根本。虽然意大利的美誉归意大利，而第一台意大利咖啡机却是法国开始进行简单尝试的，然而正如我们今天所知是意大利人将它研制成功。在意大利，一杯意大利咖啡的价格是由政府控制的。对那些想体验一次特苦、特浓咖啡口味的意大利人，他们是用“demitasse”(半杯的意思)来享用这种咖啡的，它包括1.5盎司特浓黑咖啡再加些极好的奶油使其漂浮在咖啡上面。 　　卡布奇诺咖啡(Cappuccino) 一种加入以同量的意大利咖啡和蒸汽泡沫牛奶相混合的意大利咖啡，这种咖啡的颜色就象卡布奇诺教会修士深褐色连兜帽一样，卡布奇诺咖啡因此而得名。传统的卡布奇诺咖啡是三分之一浓缩咖啡，三分之一蒸汽牛奶和三分之一泡沫牛奶。 　　泡沫意大利咖啡(Macchiato) 是加了两汤匙发泡起沫蒸汽牛奶的浓缩咖啡。美式咖啡(Americano) 加热水的浓缩咖啡，其质感与一般冲煮咖啡类似。如此,可以慢慢品偿没有加牛奶的原味浓缩咖啡。 　　奶特/拿铁咖啡(Latte) 加有蒸汽牛奶并有一团泡沫牛奶漂在其上的意大利咖啡。咖啡、牛奶、奶泡的比例为1：2：1。(比卡布奇诺咖啡牛奶味更浓)。 　　克烈特(Corretto) 掺有烈酒的意大利咖啡，如格拉巴(Grappa).　 浪漫情怀(Romano)是在意大利咖啡中加上一条卷曲的柠檬皮。 　　力士烈特(Ristretto)双倍浓度的意大利咖啡。 　　意大利咖啡的区别 　　意大利香浓咖啡(Espresso) 　　意大利香浓咖啡(Espresso)的做法起源于意大利，在意大利文是"特别快"的意思，其特征乃是利用蒸气压力瞬间将咖啡液抽出。 　　意大利香奶咖啡 Latte 　　其做法请参照意大利香浓咖啡的制作)倒入已经预热好的杯子里，然后把热牛倒入杯中;其牛奶量一定要大于此杯容量的1/2;最后把奶沫舀在液体上;加少许的巧克力粉，或肉桂粉。 　　意大利香浓奶沫咖啡Cappuccino 　　一杯真正的香浓奶沫咖啡是由三分之一的咖啡(一份意大利浓缩咖啡)，三分之一热牛奶和三分之一的牛奶沫组成的(杯中的液体为一半浓缩咖啡一半热牛奶)。 　　结语： 意大利咖啡世界驰名，到意大利旅游有机会一定要品尝一下意大利咖啡。好在意大利的咖啡是国民必须品，价格不贵。在一般的咖啡馆都有明码标价，不过提醒一下，站着喝比坐着喝便宜哦! ;

一、问题在成功编译caffe的源码之后，可以在Python环境中使用caffe。在Ubuntu环境下，打开python解释程序，输入import caffe时：出现以下错误>>>import caffeTraceback (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" >> ~/.bashrcB.使环境变量生效source ~/.bashrc第二种方法：通过代码来实现在每个python代码中使用以下代码： (这个方法在写python代码时有用)caffe_root = "~/caffe/python " import sys sys.path.insert(0, caffe_root + "python") import caffe

在训练过程中画出accuracy 和loss曲线能够更直观的观察网络训练的状态，以便更好的优化网络的训练。本文主要介绍在基于caffe框架训练网络时，如何利用caffe自带的一些实用的工具包来绘制曲线。step1:保存日志文件在训练过程中把终端输出的结果保存为一个日志文件，注意文件的后缀名必须是.log,这是因为后面再解析日志文件时有这个要求。如何把终端保存到日志文件，例子如下：$TOOLS/caffe train --solver=$SOLVERFILE 2>&1 |tee out.logstep2:解析日志文件这一步利用caffe中tools/extra文件夹下的parse_log.py来解析日志文件。具体例子如下：python parse_log.py out.log ./ #两个参数，一个是日志文件，另一个是保存的路径运行结束之后会发现在你保存的路径中会生成两个文件out.log.train和out.log.teststep3:绘制accuracy 和loss曲线。利用caffe中tools/extra文件夹下的plot_training_log.py文件来绘制。python plot_training_log.py 2 testloss.png out.log这里要解释下，如果你直接运行这个是会报错的。因为在out.log.test文件是这样的。NumIters,Seconds,TestAccuracy,TestLoss0.0,2.318823,-1,0.360432200.0,10.975734,-1,0.0757681400.0,19.634317,-1,0.0610909600.0,28.295885,-1,0.0554078800.0,36.953475,-1,0.05106061000.0,45.644651,-1,0.0463909load_data的时候第一行是不读的，要么你自己第一行加个#,要么就直接不读第一行。另外在split的时候不是用空格而是用‘,"因此做如下修改。def load_data(data_file, field_idx0, field_idx1):data = [[], []]with open(data_file, "r") as f:num=len(f)for line_num in range(1,num):#此处修改line = f[line_num].strip()#if line[0] != "#":#此处修改fields = line.split(",")#此处修改data[0].append(float(fields[field_idx0].strip()))data[1].append(float(fields[field_idx1].strip()))return data上面还有个地方需要解释就是那个2是什么意思，这个你直接运行下Python plot_training_log.py就会打出帮助信息，就能看见了。以上就是利用caffe自带的工具包绘制曲线的方法。

定义CAFFE为caffe跟目录，caffe的核心代码都在$CAFFE/src/caffe 下，主要有以下部分：net, blob, layer, solver.net.cpp: net定义网络， 整个网络中含有很多layers， net.cpp负责计算整个网络在训练中的forward, backward过程， 即计算forward/backward 时各layer的gradient。layers: 在$CAFFE/src/caffe/layers中的层，在protobuffer (.proto文件中定义message类型，.prototxt或.binaryproto文件中定义message的值) 中调用时包含属性name， type（data/conv/pool…）， connection structure (input blobs and output blobs)，layer-specific parameters（如conv层的kernel大小）。定义一个layer需要定义其setup, forward 和backward过程。blob.cpp: net中的数据和求导结果通过4维的blob传递。一个layer有很多blobs， e.g,对data，weight blob大小为Number * Channels * Height * Width, 如256*3*224*224；对conv层，weight blob大小为 Output 节点数 * Input 节点数 * Height * Width，如AlexNet第一个conv层的blob大小为96 x 3 x 11 x 11；对inner product 层， weight blob大小为 1 * 1 * Output节点数 * Input节点数； bias blob大小为1 * 1 * 1 * Output节点数（ conv层和inner product层一样，也有weight和bias，所以在网络结构定义中我们会看到两个blobs_lr，第一个是weights的，第二个是bias的。类似地，weight_decay也有两个，一个是weight的，一个是bias的）； blob中，mutable_cpu/gpu_data() 和cpu/gpu_data()用来管理memory，cpu/gpu_diff()和 mutable_cpu/gpu_diff()用来计算求导结果。slover.cpp: 结合loss，用gradient更新weights。主要函数： Init(), Solve(), ComputeUpdateValue(), Snapshot(), Restore(),//快照（拷贝）与恢复 网络state Test()；在solver.cpp中有3中solver，即3个类：AdaGradSolver, SGDSolver和NesterovSolver可供选择。关于loss，可以同时有多个loss，可以加regularization（L1/L2）；Protocol buffer：上面已经将过， protocol buffer在 .proto文件中定义message类型，.prototxt或.binaryproto文件中定义message的值；Caffe Caffe的所有message定义在$CAFFE/src/caffe/proto/caffe.proto中。Experiment 在实验中，主要用到两个protocol buffer: solver的和model的，分别定义solver参数（学习率啥的）和model结构(网络结构)。好吧，copy了一大段，不晓得有没有帮助，说点accuracy = 0.5的问题。简单说，就是分错了，好吧我知道这是废话。既然是分错了，那么就要检查下了，首先检查你的训练模型。根据训练过程来看，训练应该是已经收敛了，（反正loss一直在减小）。这句可能是我理解问题，如果模型收敛的话，loss应该趋于平稳，如这样。哦这是对数图。如果没有完全收敛的话，考虑下调整参数吧。说到调参，又是个坑啊。。。这个我也是懵懵懂懂。不过可以参考某些大牛的做法，比如用浅层CNN参数初始化深层CNN，或者学hinton老爷子用DBN来搞个预训练。不过即使是随机初始参数，按道理不应该出现这种accuracy=0.5的情况。个人感觉要么就是训练没有完成，要么就是在做最后二分的那一层有什么问题。。。其实应该先检查训练数据，训练数据搞混了，其他都是白搭。如果检查模型，你可以先看下你参数更新的梯度是否已经趋于零了，然后再看看你二分那一层有木有问题。当然，说了这么多，可能也没啥帮助，如果你哪天改用matlab或者theano了，可以交流下，caffe确实不甚了解。。。在尝试用caffe分类一个自己的二分类图像数据库。根据训练过程来看，训练应该是已经收敛了，（反正loss一直在减小）。然而测试集上的accuracy一直都是=0.5.所以现在想着把生成的模型文件调出来用数据测试下，观察下是什么问题，请问应当如何去实现呢。或者各位如果能指点下，可能是什么原因导致的accuracy = 0.5 不变。那就更好啦。谢谢！

目前是人工智能的时代，国内外像Google、微软、FaceBook、百度和华为等巨头公司纷纷投入较大的资源进行深度学习框架的研发和应用的拓展。表1列出了github上流行的深度学习框架的星数。表1 github上流行的深度学习框架的星数下面有侧重地介绍一下上表中列出的一些深度学习框架。(一)TensorFlowTensorFlow是用C++语言开发的，支持C、Java、Python等多种语言的调用，目前主流的方式通常会使用Python语言来驱动应用。这一特点也是其能够广受欢迎的原因。利用C++语言开发可以保证其运行效率，Python作为上层应用语言，可以为研究人员节省大量的开发时间。TensorFlow相对于其他框架有如下特点。1、灵活TensorFlow与CNTK、MXNET、Theano同属于符号计算构架，允许用户在不需要使用低级语言(如在Caffe中)实现的情况下，开发出新的复杂层类型。基于图运算是其基本特点，通过图上的节点变量可以控制训练中各个环节的变量，尤其在需要对底层操作时，TensorFlow要比其他框架更容易。当然它也有缺点，灵活的操作会增加使用复杂度，从而在一定程度上增加了学习成本。2、便捷、通用作为主流的框架，TensorFlow生成的模型，具有便捷、通用的特点，可以满足更多使用者的需求。TensorFlow可以适用于Mac、Linux、Windows系统上开发。其编译好的模型几乎适用于当今所有的平台系统，并提满足“开箱即用”的模型使用理念，使模型应用起来更简单。3、成熟由于TensorFlow被使用的情况最多，所以其框架的成熟度绝对是第一的。在Google的白皮书上写道，Google内部有大量的产品几乎都用到了TensorFlow，如搜索排序、语音识别、谷歌相册和自然语言处理等。有这么多在该框架上的成功案例，先不说能够提供多少经验技巧，至少可以确保学习者在研究的道路上，遇到挫折时不会怀疑是框架的问题。4、超强的运算性能虽然TensorFlow在大型计算机集群的并行处理中，运算性能仅略低于CNTK，但是，其在个人机器使用场景下，会根据机器的配置自动选择CPU或GPU来运算，这方面做得更加友好与智能化。(二)Caffe当年深度学习的老大。最初是一个强大的图像分类框架，是最容易测试评估性能的标准深度学习框架，并且提供很多预训练模型，尤其该模型的复用价值在其他框架的学习中都会出现，大大提升了现有模型的训练时间。但是现在的Caffe似乎停滞不前，没有更新。尽管Caffe又重新崛起，从架构上看更像是TensorFlow，而且与原来的Caffe也不在一个工程里，可以独立成一个框架来看待，与原Caffe关系不大。(三)CNTKCNTK是一个微软开发的深度学习软件包，以速度快著称，有其独有的神经网络配置语言Brain Script，大大降低了学习门槛。有微软作为后盾，CNTK成为了最具有潜力与Tensor Flow争夺天下的框架。但目前其成熟度要比TensorFlow差太多，即便是发行的版本也会有大大小小的bug。与其他框架一样，CNTK具有文档资料不足的特点。但其与Visual Studio的天生耦合，以及其特定的MS编程风格，使得熟悉Visual Studio工具的小伙伴们从代码角度极易上手。另外，CNTK目前还不支持Mac操作系统。关于深度学习的基础问题可以看下这个网页的视频教程，网页链接，希望我的回答能帮到你。

Caffe的优势上手快：模型与相应优化都是以文本形式而非代码形式给出。 Caffe给出了模型的定义、最优化设置以及预训练的权重，方便立即上手。速度快：能够运行最棒的模型与海量的数据。 Caffe与cuDNN结合使用，测试AlexNet模型，在K40上处理每张图片只需要1.17ms.模块化：方便扩展到新的任务和设置上。 可以使用Caffe提供的各层类型来定义自己的模型。开放性：公开的代码和参考模型用于再现。社区好：可以通过BSD-2参与开发与讨论。

1.配置环境我在自己的笔记本配置的caffe，配置的环境为：Windows 7 64位 + cuda6.5 + Opencv2.49 +VS2013。假设在配置caffe之前，你已经准备好这些。本文中将给出一些编译好的依赖库，如果你也是用的Windows 7 64位+VS2013，可以直接使用。2.准备依赖库在Windows下配置caffe，一个很主要的问题就是依赖库的编译。不像在Ubuntu下那么方便，在Windows下，依赖库都需要使用vs2013进行编译才能使用。下面我将介绍caffe需要的依赖库（如果你也是win7 64位+VS2013，可以直接使用我提供的依赖库）。2.1 boostboost可以下载源码进行编译，也可以直接下载安装文件。我使用的是后者，方便、快捷。我使用的是：boost_1.56_0-msvc-12.0-64.exe注意下载适合你的配置环境的boost版本即可。下载完毕，双击运行安装文件即可。2.2 Glog+Gflag+Protobuf+LevelDB+HDF5+LMDB+Openblas这一部分的很多都是谷歌的开源库，不容易下载（你懂的）。所以我使用的是Neil Z. SHAO‘s Blog提供的编译好的。下载完，解压得到3rdparty文件夹。在下一段将会用到。3.建立caffe工程准备好了caffe需要的依赖库和环境之后，下面就可以建立caffe的vs项目，进行编译了。3.1 下载caffe源码可以从caffe的github主页下载源码。下载地址：Caffe"s GitHub解压文件，假设caffe源码所在目录为CAFFE_ROOT。3.2 准备项目需要的依赖库和系统环境变量经过上一阶段的准备，caffe项目所需的依赖库都已经准备好。1.首先设置系统环境变量(以我的为例):CUDA_PATH_V6_5 安装好cuda6.5之后，会自动添加环境变量CUDA_PATH_V6_5OPENCV_2_49 D:/Tools/opencv2.49/build/BOOST_1_56 D:/Tools/boost_1_56_02.将3rdparty文件夹放到CAFFE_ROOT3.3 用vs建立caffe项目1.用VS2013在CAFFE_ROOT下建立 win32 console application，选择空项目。将项目的平台由32位改为64位2.修改项目属性项目——属性——C/C++——常规——附加包含目录添加：../include;../src；../3rdparty/include;../3rdparty;../3rdparty/include;../3rdparty/include/openblas;../3rdparty/include/hdf5;../3rdparty/include/lmdb;../3rdparty/include/leveldb;../3rdparty/include/gflag;../3rdparty/include/glog;../3rdparty/include/google/protobuf;项目——属相——VC++目录——包含目录添加：$(CUDA_PATH_V6_5)include;$(OPENCV_2_49)include;$(OPENCV_2_49)includeopencv;$(OPENCV_2_49)includeopencv2;$(BOOST_1_56)项目——属性——链接器——常规——附加库目录添加：$(CUDA_PATH_V6_5)lib$(PlatformName);$(OPENCV_2_49)x64vc12lib;$(BOOST_1_56)lib64-msvc-12.0;..3rdpartylib;项目——属性——链接器——输入——附加依赖项debug添加：opencv_ml249d.libopencv_calib3d249d.libopencv_contrib249d.libopencv_core249d.libopencv_features2d249d.libopencv_flann249d.libopencv_gpu249d.libopencv_highgui249d.libopencv_imgproc249d.libopencv_legacy249d.libopencv_objdetect249d.libopencv_ts249d.libopencv_video249d.libopencv_nonfree249d.libopencv_ocl249d.libopencv_photo249d.libopencv_stitching249d.libopencv_superres249d.libopencv_videostab249d.libcudart.libcuda.libnppi.libcufft.libcublas.libcurand.libgflagsd.liblibglog.liblibopenblas.dll.alibprotobufd.liblibprotoc.libleveldbd.liblmdbd.liblibhdf5_D.liblibhdf5_hl_D.libShlwapi.libgflags.liblibprotobuf.libleveldb.liblmdb.liblibhdf5.liblibhdf5_hl.librelease添加：opencv_ml249.libopencv_calib3d249.libopencv_contrib249.libopencv_core249.libopencv_features2d249.libopencv_flann249.libopencv_gpu249.libopencv_highgui249.libopencv_imgproc249.libopencv_legacy249.libopencv_objdetect249.libopencv_ts249.libopencv_video249.libopencv_nonfree249.libopencv_ocl249.libopencv_photo249.libopencv_stitching249.libopencv_superres249.libopencv_videostab249.libcudart.libcuda.libnppi.libcufft.libcublas.libcurand.libgflags.liblibglog.liblibopenblas.dll.alibprotobuf.liblibprotoc.libleveldb.liblmdb.liblibhdf5.liblibhdf5_hl.libShlwapi.lib3.4 编译caffe配置好caffe项目的属性之后，下面就可以一步一步的编译caffe了。3.4.1 编译./src中的文件首先，将../src文件夹中的*.cpp文件添加到工程中。依次编译每一个*.cpp文件。1.编译blob.cpp直接编译时会报错，缺少文件”caffeprotocaffe.pb.h”这个时候需要将proto.exe放到../3rdparty/bin文件夹将GernaratePB.bat放在../scripts文件夹运行bat脚本文件即可生成caffe.pb.h然后就可以成功编译。2.编译common.cpp直接编译这个文件，会出现关于getid和fopen_s的错误。可通过如下步骤修改：在代码前面添加：#include <process.h>修改项目属性：项目——属性——C/C++——预处理器——预处理器定义添加:_CRT_SECURE_NO_WARNINGS在代码中getid的位置进行如下修改：#ifdef _MSC_VERpid = getid();#elsepid = _getid();#endf修改完毕之后，可以成功编译。3.编译net.cpp直接编译这个文件，会出现关于mkstep、close、mkdtemp的错误。需要进行如下修改：在io.hpp头文件中添加：#include “mkstep.h”在io.hpp头文件中，在close()的位置进行如下修改：#ifdef _MSC_VERclose(fd);#else_close(fd);#endif在mkdtemp的位置进行如下修改：#ifndef _MSC_VERchar* mkdtemp_result = mkdtemp(temp_dirname_cstr);#elseerrno_t mkdtemp_result = _mktemp_s(temp_dirname_cstr, sizeof(temp_dirname_cstr));#endif修改完毕，可以成功编译。4.编译solver.cpp直接编译会出现关于snprintf的错误，需要进行如下修改：#ifdef _MSC_VER#define snprinf sprintf_s#endif修改完毕，可以成功编译。5.其他剩余的cpp文件也依次编译3.4.2 编译./src/layers中的文件将./src/layers中的所有的cpp和cu文件都添加到项目中。右键点击cu文件，修改属性。在bnll_layer.cu文件，进行如下修改：float kBNLL_THRESHOLD = 50 ——> #define kBNLL_THRESHOLD 50.0依次编译所有的文件。3.4.3 编译./src/util中的文件将./src/util中所有的文件添加到项目1.在io.cpp中修改ReadProtoFromBinaryFile函数O_RDONLY ——> O_RDONLY | O_BINARY在代码中进行如下修改：#ifdef _MSC_VER#define open _open#endif将close()改为_close()2.在math_functions.cpp中做如下修改：#define __builtin_popcount __popcnt#define __builtin_popcountl __popcnt3.在db.cpp中作如下修改：#ifdef _MSC_VER#include <direct.h>#endif修改CHECK_EQ#ifdef _MSC_VERCHECK_EQ(_mkdir(source.c_str()),0)<<”mkdir”<<source<<”failed”;#elseCHECK_EQ(mkdir(source.c_str(),0744),0)<<”mkidr”<<source<<”failed”;#endif4.依次编译其他文件3.4.4 编译./src/proto中的文件参照上一步，将proto中的文件都添加到项目。修改属性：项目——属性——C/C++——预处理器——预处理器定义添加：_SCL_SECURE_NO_WARNINGS编译所有文件。3.4.5 编译./tools中的文件本文件夹下有多个cpp文件，通过它们的名字就可以知道相应的功能。添加不同的cpp文件到项目中，然后生成项目，就可以得到不同功能的exe文件。将caffe.cpp添加到工程，生成项目，得到caffe.exe文件，可用于训练模型将computer_image_mean.cpp添加到工程，生成项目，得到的exe文件可用于将训练样本转换为caffe使用的leveldb/lmdb数据集。依次类推。自此，caffe在Windows下的编译已经完毕，接下来就可以使用它来训练自己的模型了。

简单来说，CNN是一种算法，caffe是用来运行CNN算法所提供的框架，让你能很快实现CNN

完全的 caffe 新手，研究了一天的 caffe ，虽然糊里糊涂的， GitHub 上找了个项目： https://github.com/BestiVicto... 在网上找了个 Python 代码照猫画虎写成如下：import numpy as npimport matplotlib.pyplot as pltcaffe_root = "/opt/caffe/"import syssys.path.insert(0, caffe_root + "python")import caffeMODEL_FILE = caffe_root + "ILGnet/deploy.prototxt"PRETRAINED = caffe_root + "ILGnet/ILGnet-AVA2.caffemodel"IMAGE_FILE = caffe_root+"examples/images/cat.jpg"mean_file=caffe_root + "ILGnet/AVA2_mean.npy"caffe.set_mode_cpu()net = caffe.Classifier(MODEL_FILE, PRETRAINED,mean=np.load(mean_file).mean(1).mean(1),channel_swap=(2,1,0),raw_scale=255,image_dims=(227, 227))input_image = caffe.io.load_image(IMAGE_FILE)plt.imshow(input_image)prediction = net.predict([input_image])plt.plot(prediction[0])print "predicted class:", prediction[0].argmax()然后就出现： F0423 12:33:29.282009 172 insert_splits.cpp:35] Unknown bottom blob "label" (layer "loss1/loss", bottom index 1)完全新手，估计代码错的很离谱，大家就别嘲笑了哈，想问一下这个如果 Python 实现的话该怎样写？ 希望能得到解答，真诚谢谢~

编译的时候没有把有效的blas库整进去。如果你使用的是openblas，那就将Makefile.config中的BLAS项的值设定为openblas，如果用的是atlas，就改成atlas。之后重新编译，应该就没有这个问题了。

解决方法: （1）搜索工程中的forward_gpu_gemm函数，原调用函数为: 在调用函数中添加一个参数“false”，如下: （2）编译会遇到问题:errorC1083:无法打开包括文件:"device_atomic_functions.hpp"，可以直接把这个头文件给注释掉，工程中多处调用这个头文件，要都注释掉。 注:该解决方法参考自http://www.ithao123.cn/content-10715084.html 3.编译过程中遇到问题 caffe.obj:errorLNK2001:无法解析的外部符号"__declspec(dllimport)void__cdeclgoogle::ShowUsageWithFlagsRestrict(charconst*,charconst*)"(__imp_?ShowUsageWithFlagsRestrict@google@@YAXPEBD0@Z) 2>caffe.obj:errorLNK2001:无法解析的外部符号"__declspec(dllimport)void__cdeclgoogle::SetUsageMessage(classstd::basic_string,classstd::allocator>const&)"(__imp_?SetUsageMessage@google@@YAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z) 2>caffe.obj:errorLNK2001:无法解析的外部符号"__declspec(dllimport)void__cdeclgoogle::SetVersionString(classstd::basic_string,classstd::allocator>const&)"(__imp_?SetVersionString@google@@YAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z) 2>caffe.obj:errorLNK2001:无法解析的外部符号"__declspec(dllimport)public:__cdeclgoogle::FlagRegisterer::FlagRegisterer(charconst*,charconst*,charconst*,charconst*,void*,void*)"(__imp_??0FlagRegisterer@google@@QEAA@PEBD000PEAX1@Z) 2>common.obj:errorLNK2001:无法解析的外部符号"__declspec(dllimport)unsignedint__cdeclgoogle::ParseCommandLineFlags(int*,char***,bool)"(__imp_?ParseCommandLineFlags@google@@YAIPEAHPEAPEAPEAD_N@Z) 2>../../bincaffe.exe:fatalerrorLNK1120:5个无法解析的外部命令 解决方法: （1）下载新的动态链接库:； （2）解压后，替换3rdparty文件夹中的bin、lib、include文件夹； （3）打开各工程属性页，在链接器-》输入-》附加依赖项中添加“libgflags.lib”即可。 4.编译过程主要遇到以上问题，运行classification_demo，结果如下:

推荐tensor， 网上源码多

我认为这个问题我是这样看的，希望可以帮到你。首先Caffe框架主要有五个组件，Blob，Solver，Net，Layer，Proto，其结构图如下图1所示。Solver负责深度网络的训练，每个Solver中包含一个训练网络对象和一个测试网络对象。每个网络则由若干个Layer构成。每个Layer的输入和输出Feature map表示为Input Blob和Output Blob。其次Caffe是目前深度学习比较优秀好用的一个开源库，采样c++和CUDA实现，具有速度快，模型定义方便等优点。学习了几天过后，发现也有一个不方便的地方，就是在我的程序中调用Caffe做图像分类没有直接的接口。再次Caffe网络的构建和Solver的参数定义均由此类型文件完成。Net构建过程中调用ReadProtoFromTextFile将所有的网络参数读入。然后调用上面的流程进行整个caffe网络的构建。这个文件决定了怎样使用存在caffe model中的每个blob是用来做什么的，如果没有了这个文件caffe的模型文件将无法使用，因为模型中只存储了各种各样的blob数据，里面只有float值，而怎样切分这些数据是由prototxt文件决定的。最后因为我自己也不是专业的程序员所以如果有不对的地方欢迎更正。

　　caffe和coffe主要区别在于起源、应用场合等方面，caffe起源于意大利语，coffee起源于美式英语。在运用的时候，caffe一般指的是意式咖啡，多出现于意式菜单上，coffee则多出现在咖啡店招牌或者单品上。 　　caffe和coffe有何不同 　　咖啡是现在很多上班族都非常喜欢喝的一种饮品，它有提神、醒脑的作用，我们在一些饮品店购买咖啡的时候，会发现有的菜单上会写caffee，而有的菜单上则写的是coffee，这是什么原因呢? 　　实际上这二者的意思都是咖啡，在本质上并没有差别，其主要区别在于起源、应用场合等方面。caffe起源于意大利语，在英语中并没有这个词，而写作cafe，而coffee则起源于美式英语。 　　再者，在运用的时候caffe一般指的是意大利咖啡，所以多用于意式咖啡菜单里面。coffee是非常常见的，例如咖啡店的招牌或者是单品咖啡菜单中 ，我们常见的咖啡写法基本上都是它，运用范围也比较广。

caffe官网：berkeleyvision.org/" target="_blank">http://caffe.berkeleyvision.org/1.最原始的最开始版本：伯克利BVLC版https://github.com/BVLC/caffe主要在Linux上运行，有matlab和Python接口傻瓜都能学会的配置教程：Caffe+Ubuntu14.04+CUDA6.5新手安装配置指南：http://www.haodaima.net/art/2823705http://www.cnblogs.com/platero/p/3993877.html学习教程：http://suanfazu.com/t/caffe/2812.贾扬清大大自己的版本：https://github.com/Yangqing/caffe3.caffe-for-windows基本版：https://github.com/niuzhiheng/caffewindows+caffe+vs2013+cuda6.5配置记录：http://www.bubuko.com/infodetail-902302.htmlcaffe for windows 训练cifar10：http://www.th7.cn/system/win/201411/77318.shtmlWindows下编译Caffe并编译Matlab接口：http://www.th7.cn/system/win/201504/102914.shtml4.caffe window改进版运行在VS2013：https://github.com/initialneil/caffe-vs2013配置：https://initialneil.wordpress.com/5.我目前用的版本（happynear大神的）：https://github.com/happynear/caffe-windows配置：http://blog.csdn.net/happynear/article/details/45372231

1、会更新，finetune的过程相当于继续训练，跟直接训练的区别是初始化的时候： a. 直接训练是按照网络定义指定的方式初始化（如高斯随机初始化） b. finetune是用你已经有的参数文件来初始化（就是之前训练好的caffemodel）2、嗯，这个问题有两种情况：比如有4个全连接层A->B->C->D a. 你希望C层的参数不会改变，C前面的AB层的参数也不会改变，这种情况也就是D层的梯度不往前反向传播到D层的输入blob（也就是C层的输出blob 没有得到梯度），你可以通过设置D层的propagate_down为false来做到。 propagate_down的数量与输入blob的数量相同，假如你某个层有2个输入blob，那么你应该在该layer的Param里面写上两行： propagate_down : 0 # 第1个输入blob不会得到反向传播的梯度 propagate_down : 0 # 第2个输入blob不会得到反向传播的梯度 这样的话，你这个layer的梯度就不会反向传播啦，前面的所有layer的参数也就不会改变了 b. 你希望C层的参数不会改变，但是C前面的AB层的参数会改变，这种情况，只是固定了C层的参数，C层得到的梯度依然会反向传播给前面的B层。只需要将对应的参数blob的学习率调整为0：你在layer里面加上param { lr_mult: 0 }就可以了，比如全连接层里面：layer { type: "InnerProduct" param { # 对应第1个参数blob的配置，也就是全连接层的参数矩阵的配置 lr_mult: 0 # 学习率为0，其他参数可以看caffe.proto里面的ParamSpec这个类型 } param { # 对应第2个参数blob的配置，也就是全连接层的偏置项的配置 lr_mult: 0 # 学习率为0 }}不知道这样说你能不能理解

首先修改配置文件，回到caffe目录cd ~/caffecp Makefile.config.example Makefile.configgedit Makefile.config这里仅需修改两处：i) 使用cuDNN# USE_CUDNN := 1 这里去掉#，取消注释为USE_CUDNN := 1 ii) 修改python包目录，这句话PYTHON_INCLUDE := /usr/include/python2.7 /usr/lib/python2.7/dist-packages/numpy/core/include改为PYTHON_INCLUDE := /usr/include/python2.7 /usr/local/lib/python2.7/dist-packages/numpy/core/include因为新安装的python包目录在这里： /usr/local/lib/python2.7/dist-packages/接下来就好办了，直接makemake all -j4make testmake runtestmake pycaffe这时候cd 到caffe 下的 python 目录，试试caffe 的 python wrapper安装好没有：pythonimport 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_））；　　}

文件夹里面，然后写一个main函数调用这个类就可以了，比如：复制，保存到caffe/examples/myproject/net_operator.hpp，然后同目录下写一个main.cpp，在main函数里面#include"net_operator.hpp"，就可以使用这个类了：conststringnet_prototxt="";//你的网络的prototxt文件，用绝对路径，下面同理conststringpre_trained_file="";//你训练好的.caffemodel文件conststringimg_path="";//你要测试的图片路径//创建NetOperator对象NetOperatornet_operator(net_prototxt,pre_trained_file);Blob*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>类型的，搜一下boostshared_ptr就知道跟普通指针有什么不同了好了，接下来是贴代码了：#include#include#include#include#include#include#include#include#includeusingnamespacecaffe;//NOLINT(build/namespaces)usingstd::string;classNetOperator{public:NetOperator(conststring&net_prototxt);NetOperator(conststring&net_prototxt,conststring&trained_file);~NetOperator(){}intbatch_size(){returnbatch_size_;}Blob*processImage(conststring&img_path,boolis_color=true);Blob*processImages(constvector&img_paths,boolis_color=true);private:voidcreateNet(conststring&net_prototxt);//readtheimageandstoreitintheidxpositionofimagesintheblobvoidreadImageToBlob(conststring&img_path,intidx=0,boolis_color=true);shared_ptr>net_;cv::Sizeinput_geometry_;intbatch_size_;intnum_channels_;Blob*input_blob_;TransformationParametertransform_param_;shared_ptr>data_transformer_;Blobtransformed_data_;};NetOperator::NetOperator(conststring&net_prototxt){createNet(net_prototxt);}NetOperator::NetOperator(conststring&net_prototxt,conststring&trained_file){createNet(net_prototxt);net_->CopyTrainedLayersFrom(trained_file);}voidNetOperator::createNet(conststring&net_prototxt){#ifdefCPU_ONLYCaffe::set_mode(Caffe::CPU);#elseCaffe::set_mode(Caffe::GPU);#endifnet_.reset(newNet(net_prototxt,TEST));CHECK_EQ(net_->num_inputs(),1)num_outputs(),1)*input_layer=net_->input_blobs()[0];batch_size_=input_layer->num();num_channels_=input_layer->channels();CHECK(num_channels_==3||num_channels_==1)width(),input_layer->height());//reshapetheoutputshapeoftheDataTransformervectortop_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*NetOperator::processImage(conststring&img_path,boolis_color){//reshapethenetfortheinputinput_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();returnnet_->output_blobs()[0];}Blob*NetOperator::processImages(constvector&img_paths,boolis_color){intimg_num=img_paths.size();//reshapethenetfortheinputinput_blob_=net_->input_blobs()[0];input_blob_->Reshape(img_num,num_channels_,input_geometry_.height,input_geometry_.width);net_->Reshape();for(inti=0;iForwardPrefilled();returnnet_->output_blobs()[0];}voidNetOperator::readImageToBlob(conststring&img_path,intidx,boolis_color){//readtheimageandresizetothetargetsizecv::Matimg;intcv_read_flag=(is_color?CV_LOAD_IMAGE_COLOR:CV_LOAD_IMAGE_GRAYSCALE);cv::Matcv_img_origin=cv::imread(img_path,cv_read_flag);if(!cv_img_origin.data){LOG(ERROR)0){cv::resize(cv_img_origin,img,input_geometry_);}else{img=cv_img_origin;}//transformtheimagetoablobusingDataTransformer//createaDataTransformerusingdefaultTransformationParameter(notransformation)data_transformer_.reset(newDataTransformer(transform_param_,TEST));data_transformer_->InitRand();//settheoutputofDataTransformertotheidximageoftheinputblobintoffset=input_blob_->offset(idx);this->transformed_data_.set_cpu_data(input_blob_->mutable_cpu_data()+offset);//transformtheinputimagedata_transformer_->Transform(img,&(this->transformed_data_));

　观察caffe-master的第三方程序包，这个与caffe-master本文件夹都需要加上去的。所以在属性表里，先后需要include以下这些：（路径请自行修改）　　D:caffe-masterinclude　　D:NugetPackagesoost.1.59.0.0lib ativeinclude　　D:NugetPackagesglog.0.3.3.0uild ativeinclude　　D:NugetPackagesgflags.2.1.2.1uild ativeinclude　　D:NugetPackagesprotobuf-v120.2.6.1uild ativeinclude　　C:Program FilesNVIDIA GPU Computing ToolkitCUDAv7.5include　　D:NugetPackagesOpenBLAS.0.2.14.1lib ativeinclude　　D:caffe-masterincludecaffelayers　　D:NugetPackagesOpenCV.2.4.10uild ativeinclude　　D:NugetPackagesOpenCV.2.4.10uild ativeincludeopencv　　D:NugetPackagesOpenCV.2.4.10uild ativeincludeopencv2　　最后一项是CUDA的配置路径，找一下应该就可以找到。　　那么我们的附加依赖项需要添加：　　libcaffe.lib　　libprotobuf.lib　　opencv_highgui2410.lib　　opencv_core2410.lib　　opencv_imgproc2410.lib　　libglog.lib　　gflags.lib　　libopenblas.dll.a　　hdf5.lib　　hdf5_hl.lib　　cublas.lib　　cublas_device.lib　　cuda.lib　　cudadevrt.lib　　cudnn.lib　　cudart.lib　　cufft.lib　　cudart_static.lib　　cufftw.lib　　cusparse.lib　　cusolver.lib　　curand.lib　　nppc.lib　　OpenCL.lib　　对了，最后别忘了配置环境变量哟，配置完之后重启一遍：　　D:NugetPackagesgflags.2.1.2.1uild ativex64v120dynamicLib　　D:NugetPackageshdf5-v120-complete.1.8.15.2lib ativeinx64　　D:NugetPackagesglog.0.3.3.0uild ativeinx64v120Releasedynamic　　D:NugetPackagesOpenBLAS.0.2.14.1lib ativeinx64　　D:NugetPackagesgflags.2.1.2.1uild ativex64v120dynamicLib　　D:NugetPackagesOpenCV.2.4.10uild ativeinx64v120Release　　D:caffe-masterBuildx64Release　　 　　那么在做完这些之后，我们就可以在新建工程里使用Caffe的接口了

我用caffenet ，在i5-3210m上 800张图跑了10几个小时，8000张图跑了一个星期。

具有速度快，模型定义方便等优点。学习了几天过后，发现也有一个不方便的地方，就是在我的程序中调用Caffe做图像分类没有直接的接口。

意大利咖啡世界驰名，到意大利旅游有机会一定要品尝一下意大利咖啡。好在意大利的咖啡是国民必须品，价格不贵。在一般的咖啡馆都有明码标价，不过提醒一下，站着喝比坐着喝便宜哦！还有在街头咖啡自动收货机上也有咖啡出售，质量也很好，下面翻译一下常见咖啡意大利名称和简介，大家可以根据自己的喜好选择。 Orzo espresso或者cappuccinod"orzo：orzo是意大利语里大麦的意思，该种咖啡是非常香醇的大麦浓缩咖啡或卡布奇诺，相当推荐，很多意大利人会以这个代替咖啡给小朋友或不喜欢咖啡因的人喝，由大麦谷类烘培而成，拥有跟咖啡一样的香气，可说是咖啡的替代品。该种咖啡味道略苦而且具有浓郁的芳香气味，并且具有咖啡不具备的特色：任何时间均可饮用，甚至是睡前，因为其不含刺激神经的成分，自然、健康、营养丰富。其中克洛诗丹（Crastan)是意大利最大的速溶咖啡代替品品牌。Caffe这是小小杯的浓缩咖啡，蛮建议尝试看看的，咖啡香浓，加个1-2匙糖进去，非常顺口!Caffe doppio：即double coffee,两份浓缩咖啡的超浓咖啡Caffe lungo：直译为long coffee,一份浓缩咖啡再加入很多的热开水Caffe americano:美式咖啡，是较淡的咖啡，如果你想加牛奶要另外要老板说要加LatteCaffe latte：在意大利点拿铁咖啡可不能单说Latte，否则送上来的是一杯牛奶而已，要说Caffe Latte Cappuccino或“cappuccio”：早餐最受欢迎的卡布奇诺，浓缩咖啡加打泡牛奶，饭后可别点这个，意大利人会觉得很奇怪，太多奶了Caffe macchiato：玛琪雅朵，小小杯的浓缩咖啡加入一点点牛奶，macchiato意思是脏渍，因为咖啡上有牛奶渍而得其名。Latte macchiato：它是我们平时说的“拿鉄”咖啡。和Caffemacchiato不同的在於它的牛奶比较多，咖啡只有一点，即为牛奶咖啡如果有朋友喜欢“实惠又大碗”的话，可以点点这个。Caffe corretto：浓缩咖啡加入一杯grappa或其它烈酒Caffe marocchino：米兰越来越流行的咖啡，浓缩咖啡上加可可跟鲜奶油Caffe/cappuccino decaffeinato：低咖啡因的咖啡或卡布奇诺Caffe/cappuccino Hag：Hag是意大利境内较有名的低咖啡因牌子Caffe shakerato:夏天最棒的冰摇咖啡。自十七世纪第一家咖啡馆在水城威尼斯开张至今，咖啡已经成为意大利文化中无可争议的主角之一。据意大利安莎社的统计，意大利人每人每年喝600杯咖啡，在世界上排名第六，位于美国、德国、法国、西班牙和英国之后。另外意大利的蒸馏咖啡咖啡机产量名列世界首位。

你好对于caffe中的deconvolution和upsample的区别：1. caffe的deconvolution又被叫做transposed convolution，例如在TensorFlow中。查资料的时候可以多用个关键字。2. upsampling可以通过特定kernel的deconvolution 来实现，顺便把learning rate 设成0.现在可以通过weight_filler去设。老版是在Python接口下用net surgery来做的。3、按照字面意思定义的upsampling，conv+maxpooling+upsampling必然会造成信息丢失，无法做到精确的点对点匹配。而deconvolution 则不一定希望对你有帮助

Here"s roughly the process I follow.Add a class declaration for your layer to the appropriate one of common_layers.hpp, data_layers.hpp,loss_layers.hpp, neuron_layers.hpp, or vision_layers.hpp. Include an inline implementation oftype and the *Blobs() methods to specify blob number requirements. Omit the *_gpu declarations if you"ll only be implementing CPU code.Implement your layer in layers/your_layer.cpp.SetUp for initialization: reading parameters, allocating buffers, etc.Forward_cpu for the function your layer computesBackward_cpu for its gradient(Optional) Implement the GPU versions Forward_gpu and Backward_gpu in layers/your_layer.cu.Add your layer to proto/caffe.proto, updating the next available ID. Also declare parameters, if needed, in this file.Make your layer createable by adding it to layer_factory.cpp.Write tests in test/test_your_layer.cpp. Use test/test_gradient_check_util.hpp to check that your Forward and Backward implementations are in numerical agreement.上面是一个大致的流程，我就直接翻译过来吧，因为我自己琢磨出来的步骤跟这个是一样的。在这里，我们就添加一个Wtf_Layer，然后作用跟Convolution_Layer一模一样。注意这里的命名方式，Wtf第一个字母大写，剩下的小写，算是一个命名规范吧，强迫症表示很舒服。1. 首先确定要添加的layer的类型，是common_layer 还是 data_layer 还是loss_layer, neuron_layer, vision_layer ，这里的Wtf_Layer肯定是属vision_layer了，所以打开vision_layers.hpp 然后复制convolution_layer的相关代码，把类名还有构造函数的名字改为WtfLayer，如果没有用到GPU运算，那么把里面的带GPU的函数都删掉2. 将Wtf_layer.cpp 添加到srccaffelayers文件夹中，代码内容复制convolution_layer.cpp 把对应的类名修改（可以搜一下conv关键字，然后改为Wtf）3. 假如有gpu的代码就添加响应的Wtf_layer.cu （这里不添加了）4. 修改proto/caffe.proto文件，找到LayerType，添加WTF，并更新ID（新的ID应该是34）。假如说Wtf_Layer有参数，比如Convolution肯定是有参数的，那么添加WtfParameter类5. 在layer_factory.cpp中添加响应的代码，就是一堆if ... else的那片代码6. 这个可以不做，但是为了结果还是做一个，就是写一个测试文件，检查前向后向传播的数据是否正确。gradient_check的原理可以参考UFLDL教程的对应章节之后我会更新我自己写的maxout_layer的demo，在这立一个flag以鞭策自己完成吧╮(╯▽╰)╭（二） 如何添加maxout_layer表示被bengio的maxout给搞郁闷了，自己摆出一个公式巴拉巴拉说了一堆，结果用到卷积层的maxout却给的另一种方案，吐槽无力，不过后来又想了下应该是bengio没表述清楚的问题。我的maxout的算法思路是这样的，首先要确定一个group_size变量，表示最大值是在group_size这样一个规模的集合下挑选出来的，简而言之就是给定group_size个数，取最大。确定好group_size变量，然后让卷积层的output_num变为原来的group_size倍，这样输出的featuremap的个数就变为原来的group_size倍，然后以group_size为一组划分这些featuremap，每组里面挑出响应最大的点构成一个新的featuremap，这样就得到了maxout层的输出。

1.下载好来自ImageNet的training和validation数据集合；分别存放在如下的格式：/path/to/imagenet/train/n01440764/n01440764_10026.JPEG/path/to/imagenet/val/ILSVRC2012_val_00000001.JPEG2. 进行一些预处理操作：cd $CAFFE_ROOT/data/ilsvrc12/./get_ilsvrc_aux.sh3.训练数据和测试数据分别放在train.txt和val.txt中，里面有他们的文件和相对应的标签；4. 最后作者把1000类的类名用0--999表示，他们相对应的类别名称则用synset_words.txt 来存储他们之间的映射。5.作者提到怎么去是否应该先把图像都归一化到256*256中，作者提到用Mapreduce去加快这种过程；也可以直接这么做：for name in /path/to/imagenet/val/*.JPEG; doconvert -resize 256x256! $name $nameDone6.在 create_imagenet.sh中设置训练的参数，并在里面指定训练和测试的数据库路径，如果图像没有提前归一化到相同的大小，则需要加”RESIZE=true“，设置”GLOG_logtostderr=1 “表示了可以参考更多的信息，在执行 ./create_imagenet.sh 之后会有新的数据文件生成：ilsvrc12_train_leveldb 和 ilsvrc12_val_leveldb 7. 因为模型需要我们减去图像的均值，所以我们需要计算图像均值，在工具tools/compute_image_mean.cpp 实现了这种操作，或者可以直接用：./make_imagenet_mean.sh 脚本来进行计算图像均值，并生成：data/ilsvrc12/imagenet_mean.binaryproto 文件8.定义网络的结构：imagenet_train_val.prototxt .里面有两行指定了数据库和图像的路径source: "ilvsrc12_train_leveldb"mean_file:"../../data/ilsvrc12/imagenet_mean.binaryproto"并且指定了 include { phase: TRAIN } or include { phase: TEST } .来区分训练和测试9.关于输入层的不同：训练数据中，，data项来自 ilsvrc12_train_leveldb 并且进行了随机镜像操作，测试数据中data项来自于ilsvrc12_val_leveldb 而没有进行随机镜像操作；10.输出层的不同：输出层都为 softmax_loss 层，在训练网络当中，用来计算损失函数，并且用来初始化BP过程，测试网络同样有一个第二个输出层，accuracy，它用来报告测试的精度，在训练的过程中，测试网络将实例化并且测试准确率，产成的命令行为：Test score #0: xxx and Test score #1: xxx 等。11.运行网络，其中设置每批batch为256个，运行450000次迭代，接近90次epoch；每1000次迭代，就在用测试集进行测试；设置初始的学习率为0.01，并且每100000次迭代中进行学习率下降，大概进行20次epoch；每20次epoch就显示出一些数据信息；网络训练的动量为0.9，权重衰减因子为0.0005，每10000次迭代中，就生成当前状态的快照；这些设置在 examples/imagenet/imagenet_solver.prototxt .中进行设置，并且同样我们需要指定文件的路径：net: "imagenet_train_val.prototxt"12.开始训练网络：./train_imagenet.sh13. 在K20中，每20个迭代花费36s，所以，一幅图像的一次前馈+反馈（FW+BW）大概需要7ms，前馈花费2.5ms，剩下的是反馈，可以在 examples/net_speed_benchmark.cpp 中进行时间的查看；14.因为我们有保存了快照，所以我们可以通过./resume_training.sh 来进行resume恢复，脚本caffe_imagenet_train_1000.solverstate 保留了要恢复的所有信息，15.总结，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 blobvoid 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_ONLYCaffe::set_mode(Caffe::CPU);#elseCaffe::set_mode(Caffe::GPU);#endifnet_.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 DataTransformervector<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 inputinput_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 inputinput_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 sizecv::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 blobint offset = input_blob_->offset(idx);this->transformed_data_.set_cpu_data(input_blob_->mutable_cpu_data() + offset);// transform the input imagedata_transformer_->Transform(img, &(this->transformed_data_));}

个人感觉不会有啥本质差别。如果有差别的话，那基本上就可能是：(1) 你用的底层数学库不一样，而这些底层数学库的速度不同。比如说Atlas和MKL，一般MKL完胜。(2) 你用的编译器优化能力不同。不过现代编译器其实对于caffe这样运算逻辑比较简单的代码的优化基本上已经没有啥差别了，所以更有可能是下一条。(3) 你开的优化选项不一样。比如说开-O0和-O3，或者开-mavx和不开avx，速度甩几条街是分分钟的事情。另外@王峰 提到的Cudnn的问题，传说NVIDIA在Windows上的Cudnn没有用心跑优化，也有传说NVIDIA CUDA的Windows驱动没有用心写。。。这个个人没有验证过，不过如果是真的话也不奇怪了。作者：贾扬清链接：https://www.zhihu.com/question/39729947/answer/82788278来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1 cifar10数据库60000张32*32 彩色图片 共10类50000张训练10000张测试下载cifar10数据库 这是binary格式的，所以我们要把它转换成leveldb格式。2 在../caffe-windows/examples/cifar10文件夹中有一个 convert_cifar_data.cpp将他include到MainCaller.cpp中。如下：编译....，在bin文件夹里出现convert_cifar_data.exe。然后 就可以进行格式转换。binary→leveldb可以在bin文件夹下新建一个input文件夹。将cifar10.binary文件放在input文件夹中，这样转换时就不用写路径了。cmd进入bin文件夹执行后，在output文件夹下有cifar_train_leveldb和cifar_test_leveldb两个文件夹。里面是转化好的leveldb格式数据。当然，也可以写一个bat文件处理，方便以后再次使用。3 下面要求数据图像的均值编译../../tools/comput_image_mean.cpp编译成功后。接下来求meancmd进入bin。执行后，在bin文件夹下出现一个mean.binaryproto文件，这就是所需的均值文件。4 训练cifar网络在.../examples/cifar10文件夹里已经有网络的配置文件，我们只需要将cifar_train_leveldb和cifar_test_leveldb两个文件夹还有mean.binaryproto文件拷到cifar0文件夹下。修改cifar10_quick_train.prototxt中的source: "cifar-train-leveldb" mean_file: "mean.binaryproto" 和cifar10_quick_test.prototxt中的source: "cifar-test-leveldb"mean_file: "mean.binaryproto"就可以了，后面再训练就类似于MNIST的训练。写一个train_quick.bat，内容如下：[plain] view plaincopycopy ..\..\bin\MainCaller.exe ..\..\bin\train_net.exeSET GLOG_logtostderr=1"../../bin/train_net.exe" cifar10_quick_solver.prototxtpause先编译一遍 train_net.cpp运行train_quick.bat