Cómo portar CRFAsRNN a caffe-windows
(1) Archivos auxiliares de trasplante
Copie coords.hpp y modificado_permutohedral.hpp en include/caffe/util/ al directorio correspondiente a caffe-windows y src/caffe/ Copiar util /modified_permutohedral.cpp al directorio correspondiente
(2) Transplantar las características en Layer
Agregar el siguiente código en include/caffe/layer.hpp: #include " caffe/util/ coords.hpp"
y el siguiente código:
virtual DiagonalAffineMaplt; Dtypegt; coord_map() {
NOT_IMPLEMENTED; // suprimir advertencias return
DiagonalAffineMaplt;Dtypegt;(vectorlt;pairlt;Dtype, Dtypegt;
gt;() }El archivo modificado es el siguiente: #ifndef CAFFE_LAYER_H_#define CAFFE_LAYER_H_
#include lt;algorithmgt;#include lt;stringgt;#include lt;vectorgt;
#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"
/**
Declarar impulso hacia adelante::thread en lugar de incluir boost/thread.hpp para
evitar un impulso /Problemas NVCC (#1009, #1010) en OSX */namespace boost {
class mutex }
namespace caffe {
/* * * @brief Una interfaz para las
unidades de cálculo que se pueden componer en una * Net. * *
Las capas deben implementar una función Forward, en la que toman sus
. p>ingrese * (abajo) Blobs (si los hay) y calcule sus Blobs de salida (si
los hay * También pueden implementar una función hacia atrás, en la que <).
/p>
calcula los gradientes de error * con respecto a sus Blobs de entrada, dados
los gradientes de error con * sus Blobs de salida */template lt;typename
Dtypegt; class Layer { public: /** * No debes implementar tu
constructor propio. Cualquier código de configuración debe ir * a SetUp(), donde se encuentran las
dimensiones de los blobs inferiores. se proporcionan a la * capa */
explicit Layer(const LayerParameteramp; param):
layer_param_(param), is_shared_(false) { // Establecer fase y copiar
p>
layer_param_(param), is_shared_(false) { // Establece la fase y copia
blobs (si los hay). p>(layer_param_.blobs_size() gt; 0) {
blobs_.resize (layer_param_.blobs_size()); for (int i = 0; i lt;
layer_param_. blobs_size(); i) { blobs_[i].reset(new
Bloblt ;Dtypegt; ());
blobs_[i]-gt;FromProto(layer_param_.blobs( i)); } } }
virtual ~Layer() {}
/** * @brief Implementa la funcionalidad de configuración de capa común
. param bottom los blobs de entrada preformados *
@param top * los blobs de salida asignados pero sin forma, a los que se les dará forma
mediante Reshape * * Comprueba que el número de blobs inferiores y superiores sea
correct. * Llama a LayerSetUp para realizar una configuración de capa especial para
tipos de capas individuales, * seguido de Reshape para configurar los tamaños de los blobs superiores y
búferes internos. * Configura el
Blobs multiplicadores de peso de pérdida para cualquier
peso de pérdida distinto de cero. * Este método no se puede anular */ void
SetUp(const vectorlt;Bloblt;Dtypegt;*gt;amp. ; abajo, const
Bloblt; Dtypegt; *gt; arriba) { InitMutex();
Reshape(bottom, top); SetLossWeights(top); }
/** * @brief
Tiene una configuración específica de la capa: su capa debe implementarse esta función *
así como Reshape. * * @param bottom * los blobs de entrada
preformados, cuyos campos de datos almacenan los datos de entrada para * este
Layer * @param top * los blobs de salida asignados pero sin forma *
* Este método debe realizar una configuración única de capa. Esto incluye
leer * y procesar los parámetros relevantes del <. /p>
lt;codegt;layer_param_lt;/codegt;. * La configuración de las formas de los
blobs superiores y los buffers internos se debe realizar en *
lt;codegt; Reshapelt;/codegt;, que se llamará antes del
paso hacia adelante para * ajustar los tamaños de los blobs superiores */ virtual void
LayerSetUp(const vectorlt;Bloblt;Dtypegt;* gt; abajo,
const vectorlt; Dtypegt; *gt; arriba) {}
/** * @brief
una capa debe ser compartida por varias redes durante el paralelismo de datos *
De forma predeterminada, todas las capas.
excepto que las capas de datos *
no deben compartirse. las capas de datos deben compartirse para garantizar que cada trabajador
* solucionador acceda a los datos de forma secuencial durante el paralelismo de datos */
/**
@brief Devuelve si esta capa es realmente compartida por otras redes. > Si ShareInParallel() es verdadero y usa más de una GPU y
* net tiene fase TRAIN, entonces se espera que esta función devuelva
true */ inline bool IsShared(). const { return is_shared_ }
/**
@brief Establece si esta capa es realmente compartida por otras redes *
Si ShareInParallel() es verdadero y usando más de una GPU y la *
red tiene fase TRAIN, entonces is_shared debe configurarse como verdadero */
inline void SetShared(bool is_shared) { CHECK(ShareInParallel() | |
!is_shared) lt; type() lt; "La capa no admite
compartir."; /** * @brief Ajusta las
formas de los blobs superiores y los buffers internos para acomodar * las
formas de los blobs inferiores * * @param debajo de los blobs de entrada, con <. /p>
las formas de entrada solicitadas * @param top las manchas superiores, que deben remodelarse
según sea necesario * * Este método debe remodelar las manchas superiores según
necesario según th
e formas * de las manchas inferiores (de entrada), así como también
como remodelar cualquier buffer interno * y hacer cualquier otro ajuste necesario
para que la capa pueda * acomodar las manchas inferiores. */
virtual void Reshape(const vectorlt; Bloblt; Dtypegt; *gt; amp;
abajo, const vectorlt; Bloblt; Dtypegt; *gt; amp; top) = 0 ;
/** * @brief Dados los blobs inferiores, calcule los blobs superiores y la
pérdida * * @param bottom * los blobs de entrada, cuyos campos de datos
almacena los datos de entrada para esta capa * @param top * los blobs de salida preformados
, cuyos campos de datos almacenarán las * salidas de estas capas
* /return El total pérdida de la capa * * El contenedor Forward
llama a la función contenedora del dispositivo relevante * (Forward_cpu o
Forward_gpu) para calcular los valores de los blobs superiores dados los * blobs inferiores.
p>Si la capa tiene pérdidas_weights distintas de cero, el contenedor * luego
calcula y devuelve la pérdida * * Su capa debe implementar
Forward_cpu. y (opcionalmente) Forward_gpu */ inline Dtype
Forward(const vectorlt; Bloblt; Dtypegt; *gt; amp; bottom, const
vectorlt; Bloblt; Dtypegt; *gt; amplificador; arriba);