將include/caffe/util/下的coords.hpp和modified_permutohedral.hpp復制到caffe-windows對應的目錄將src/caffe/util/modified_permutohedral.cpp復制到對應的目錄中去
（2）移植Layer中的特性
在include/caffe/layer.hpp中添加如下代碼：#include "caffe/util/coords.hpp"
和以下代碼：
virtual DiagonalAffineMap<Dtype> coord_map() {
NOT_IMPLEMENTED; // suppress warnings return
DiagonalAffineMap<Dtype>(vector<pair<Dtype, Dtype>
>()); }修改後的文件如下：#ifndef CAFFE_LAYER_H_#define CAFFE_LAYER_H_
#include <algorithm>#include <string>#include <vector>
#include
"caffe/blob.hpp"#include "caffe/common.hpp"#include
"caffe/layer_factory.hpp"#include "caffe/proto/caffe.pb.h"#include
"caffe/util/coords.hpp"#include "caffe/util/math_functions.hpp"
/**
Forward declare boost::thread instead of including boost/thread.hpp to
avoid a boost/NVCC issues (#1009, #1010) on OSX. */namespace boost {
class mutex; }
namespace caffe {
/** * @brief An interface for the
units of computation which can be composed into a * Net. * *
Layer%s must implement a Forward function, in which they take their
input * (bottom) Blob%s (if any) and compute their output Blob%s (if
any). * They may also implement a Backward function, in which they
compute the error * gradients with respect to their input Blob%s, given
the error gradients with * their output Blob%s. */template <typename
Dtype>class Layer { public: /** * You should not implement your
own constructor. Any set up code should go * to SetUp(), where the
dimensions of the bottom blobs are provided to the * layer. */
explicit Layer(const LayerParameter& param) :
layer_param_(param), is_shared_(false) { // Set phase and copy
blobs (if there are any). phase_ = param.phase(); if
(layer_param_.blobs_size() > 0) {
blobs_.resize(layer_param_.blobs_size()); for (int i = 0; i <
layer_param_.blobs_size(); ++i) { blobs_[i].reset(new
Blob<Dtype>());
blobs_[i]->FromProto(layer_param_.blobs(i)); } } }
virtual ~Layer() {}
/** * @brief Implements common layer setup
functionality. * * @param bottom the preshaped input blobs *
@param top * the allocated but unshaped output blobs, to be shaped
by Reshape * * Checks that the number of bottom and top blobs is
correct. * Calls LayerSetUp to do special layer setup for individual
layer types, * followed by Reshape to set up sizes of top blobs and
internal buffers. * Sets up the loss weight multiplier blobs for any
non-zero loss weights. * This method may not be overridden. */ void
SetUp(const vector<Blob<Dtype>*>& bottom, const
vector<Blob<Dtype>*>& top) { InitMutex();
CheckBlobCounts(bottom, top); LayerSetUp(bottom, top);
Reshape(bottom, top); SetLossWeights(top); }
/** * @brief
Does layer-specific setup: your layer should implement this function *
as well as Reshape. * * @param bottom * the preshaped
input blobs, whose data fields store the input data for * this
layer * @param top * the allocated but unshaped output blobs *
* This method should do one-time layer specific setup. This includes
reading * and processing relevent parameters from the
<code>layer_param_</code>. * Setting up the shapes of top
blobs and internal buffers should be done in *
<code>Reshape</code>, which will be called before the
forward pass to * adjust the top blob sizes. */ virtual void
LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {}
/** * @brief
Whether a layer should be shared by multiple nets during data *
parallelism. By default, all layers except for data layers should *
not be shared. data layers should be shared to ensure each worker
* solver access data sequentially during data parallelism. */
virtual inline bool ShareInParallel() const { return false; }
/**
@brief Return whether this layer is actually shared by other nets. *
If ShareInParallel() is true and using more than one GPU and the
* net has TRAIN phase, then this function is expected return
true. */ inline bool IsShared() const { return is_shared_; }
/**
@brief Set whether this layer is actually shared by other nets *
If ShareInParallel() is true and using more than one GPU and the *
net has TRAIN phase, then is_shared should be set true. */
inline void SetShared(bool is_shared) { CHECK(ShareInParallel() ||
!is_shared) << type() << "Layer does not support
sharing."; is_shared_ = is_shared; }
/** * @brief Adjust the
shapes of top blobs and internal buffers to accommodate * the
shapes of the bottom blobs. * * @param bottom the input blobs, with
the requested input shapes * @param top the top blobs, which should be
reshaped as needed * * This method should reshape top blobs as
needed according to the shapes * of the bottom (input) blobs, as well
as reshaping any internal buffers * and making any other necessary
adjustments so that the layer can * accommodate the bottom blobs. */
virtual void Reshape(const vector<Blob<Dtype>*>&
bottom, const vector<Blob<Dtype>*>& top) = 0;
/** * @brief Given the bottom blobs, compute the top blobs and the
loss. * * @param bottom * the input blobs, whose data fields
store the input data for this layer * @param top * the preshaped
output blobs, whose data fields will store this layers' * outputs
* /return The total loss from the layer. * * The Forward wrapper
calls the relevant device wrapper function * (Forward_cpu or
Forward_gpu) to compute the top blob values given the * bottom blobs.
If the layer has any non-zero loss_weights, the wrapper * then
computes and returns the loss. * * Your layer should implement
Forward_cpu and (optionally) Forward_gpu. */ inline Dtype
Forward(const vector<Blob<Dtype>*>& bottom, const
vector<Blob<Dtype>*>& top);