caffe实现自己的层

最新推荐文章于 2021-03-04 07:00:00 发布
最新推荐文章于 2021-03-04 07:00:00 发布
阅读量235 收藏 1
点赞数
分类专栏： caffe 深度学习 文章标签： caffe 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34929889/article/details/107518980
版权

caffe实现自己的层

caffe.proto

首先在message LayerParameter{}中添加层名和参数名.例如:

optional SliceParameter slice_param = 126;

然后再 message AllPassParameter { }，指定参数名称

message SliceParameter {
  optional int32 axis = 3 [default = 1];
  repeated uint32 slice_point = 2;
  optional uint32 slice_dim = 1 [default = 1];
}

.cpp

主要实现LayerSetUp(),Reshape(),Forward_cpu(),Forward_gpu(),Backward_cpu()和Backward_gpu()函数.
LayerSetUp()将层的param赋值给层的私有成员,Reshape()计算top的尺寸,Forward_cpu()和Backward_gpu()实现层的前向后向计算.

#include <algorithm>
#include <vector>

#include "caffe/layers/slice_layer.hpp"
#include "caffe/util/math_functions.hpp"

namespace caffe {

template <typename Dtype>
void SliceLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  const SliceParameter& slice_param = this->layer_param_.slice_param();
  CHECK(!(slice_param.has_axis() && slice_param.has_slice_dim()))
      << "Either axis or slice_dim should be specified; not both.";
  slice_point_.clear();
  std::copy(slice_param.slice_point().begin(),
      slice_param.slice_point().end(),
      std::back_inserter(slice_point_));
}

template <typename Dtype>
void SliceLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  const int num_axes = bottom[0]->num_axes();
  const SliceParameter& slice_param = this->layer_param_.slice_param();
  if (slice_param.has_slice_dim()) {
    slice_axis_ = static_cast<int>(slice_param.slice_dim());
    // Don't allow negative indexing for slice_dim, a uint32 -- almost
    // certainly unintended.
    CHECK_GE(slice_axis_, 0) << "casting slice_dim from uint32 to int32 "
        << "produced negative result; slice_dim must satisfy "
        << "0 <= slice_dim < " << kMaxBlobAxes;
    CHECK_LT(slice_axis_, num_axes) << "slice_dim out of range.";
  } else {
    slice_axis_ = bottom[0]->CanonicalAxisIndex(slice_param.axis());
  }
  vector<int> top_shape = bottom[0]->shape();
  const int bottom_slice_axis = bottom[0]->shape(slice_axis_);
  num_slices_ = bottom[0]->count(0, slice_axis_);
  slice_size_ = bottom[0]->count(slice_axis_ + 1);
  int count = 0;
  if (slice_point_.size() != 0) {
    CHECK_EQ(slice_point_.size(), top.size() - 1);
    CHECK_LE(top.size(), bottom_slice_axis);
    int prev = 0;
    vector<int> slices;
    for (int i = 0; i < slice_point_.size(); ++i) {
      CHECK_GT(slice_point_[i], prev);
      slices.push_back(slice_point_[i] - prev);
      prev = slice_point_[i];
    }
    slices.push_back(bottom_slice_axis - prev);
    for (int i = 0; i < top.size(); ++i) {
      top_shape[slice_axis_] = slices[i];
      top[i]->Reshape(top_shape);
      count += top[i]->count();
    }
  } else {
    CHECK_EQ(bottom_slice_axis % top.size(), 0)
        << "Number of top blobs (" << top.size() << ") should evenly "
        << "divide input slice axis (" << bottom_slice_axis << ")";
    top_shape[slice_axis_] = bottom_slice_axis / top.size();
    for (int i = 0; i < top.size(); ++i) {
      top[i]->Reshape(top_shape);
      count += top[i]->count();
    }
  }
  CHECK_EQ(count, bottom[0]->count());
  if (top.size() == 1) {
    top[0]->ShareData(*bottom[0]);
    top[0]->ShareDiff(*bottom[0]);
  }
}

template <typename Dtype>
void SliceLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  if (top.size() == 1) { return; }
  int offset_slice_axis = 0;
  const Dtype* bottom_data = bottom[0]->cpu_data();
  const int bottom_slice_axis = bottom[0]->shape(slice_axis_);
  for (int i = 0; i < top.size(); ++i) {
    Dtype* top_data = top[i]->mutable_cpu_data();
    const int top_slice_axis = top[i]->shape(slice_axis_);
    for (int n = 0; n < num_slices_; ++n) {
      const int top_offset = n * top_slice_axis * slice_size_;
      const int bottom_offset =
          (n * bottom_slice_axis + offset_slice_axis) * slice_size_;
      caffe_copy(top_slice_axis * slice_size_,
          bottom_data + bottom_offset, top_data + top_offset);
    }
    offset_slice_axis += top_slice_axis;
  }
}

template <typename Dtype>
void SliceLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  if (!propagate_down[0] || top.size() == 1) { return; }
  int offset_slice_axis = 0;
  Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();
  const int bottom_slice_axis = bottom[0]->shape(slice_axis_);
  for (int i = 0; i < top.size(); ++i) {
    const Dtype* top_diff = top[i]->cpu_diff();
    const int top_slice_axis = top[i]->shape(slice_axis_);
    for (int n = 0; n < num_slices_; ++n) {
      const int top_offset = n * top_slice_axis * slice_size_;
      const int bottom_offset =
          (n * bottom_slice_axis + offset_slice_axis) * slice_size_;
      caffe_copy(top_slice_axis * slice_size_,
          top_diff + top_offset, bottom_diff + bottom_offset);
    }
    offset_slice_axis += top_slice_axis;
  }
}

#ifdef CPU_ONLY
STUB_GPU(SliceLayer);
#endif

INSTANTIATE_CLASS(SliceLayer);
REGISTER_LAYER_CLASS(Slice);

}  // namespace caffe

.h

#ifndef CAFFE_SLICE_LAYER_HPP_
#define CAFFE_SLICE_LAYER_HPP_

#include <vector>

#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"

namespace caffe {

/**
 * @brief Takes a Blob and slices it along either the num or channel dimension,
 *        outputting multiple sliced Blob results.
 *
 * TODO(dox): thorough documentation for Forward, Backward, and proto params.
 */
template <typename Dtype>
class SliceLayer : public Layer<Dtype> {
 public:
  explicit SliceLayer(const LayerParameter& param)
      : Layer<Dtype>(param) {}
  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  virtual inline const char* type() const { return "Slice"; }
  virtual inline int ExactNumBottomBlobs() const { return 1; }
  virtual inline int MinTopBlobs() const { return 1; }

 protected:
  virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
  virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);

  int count_;
  int num_slices_;
  int slice_size_;
  int slice_axis_;
  vector<int> slice_point_;
};

}  // namespace caffe

#endif  // CAFFE_SLICE_LAYER_HPP_

.cu

#include <vector>

#include "caffe/layers/slice_layer.hpp"
#include "caffe/util/math_functions.hpp"

namespace caffe {

template <typename Dtype>
__global__ void Slice(const int nthreads, const Dtype* in_data,
    const bool forward, const int num_slices, const int slice_size,
    const int bottom_slice_axis, const int top_slice_axis,
    const int offset_slice_axis, Dtype* out_data) {
  CUDA_KERNEL_LOOP(index, nthreads) {
    const int total_slice_size = slice_size * top_slice_axis;
    const int slice_num = index / total_slice_size;
    const int slice_index = index % total_slice_size;
    const int bottom_index = slice_index +
        (slice_num * bottom_slice_axis + offset_slice_axis) * slice_size;
    if (forward) {
      out_data[index] = in_data[bottom_index];
    } else {
      out_data[bottom_index] = in_data[index];
    }
  }
}

template <typename Dtype>
void SliceLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  if (top.size() == 1) { return; }
  int offset_slice_axis = 0;
  const Dtype* bottom_data = bottom[0]->gpu_data();
  const int bottom_slice_axis = bottom[0]->shape(slice_axis_);
  const bool kForward = true;
  for (int i = 0; i < top.size(); ++i) {
    Dtype* top_data = top[i]->mutable_gpu_data();
    const int top_slice_axis = top[i]->shape(slice_axis_);
    const int top_slice_size = top_slice_axis * slice_size_;
    const int nthreads = top_slice_size * num_slices_;
    Slice<Dtype>  // NOLINT_NEXT_LINE(whitespace/operators)
        <<<CAFFE_GET_BLOCKS(nthreads), CAFFE_CUDA_NUM_THREADS>>>(
        nthreads, bottom_data, kForward, num_slices_, slice_size_,
        bottom_slice_axis, top_slice_axis, offset_slice_axis, top_data);
    offset_slice_axis += top_slice_axis;
  }
}

template <typename Dtype>
void SliceLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  if (!propagate_down[0] || top.size() == 1) { return; }
  int offset_slice_axis = 0;
  Dtype* bottom_diff = bottom[0]->mutable_gpu_diff();
  const int bottom_slice_axis = bottom[0]->shape(slice_axis_);
  const bool kForward = false;
  for (int i = 0; i < top.size(); ++i) {
    const Dtype* top_diff = top[i]->gpu_diff();
    const int top_slice_axis = top[i]->shape(slice_axis_);
    const int top_slice_size = top_slice_axis * slice_size_;
    const int nthreads = top_slice_size * num_slices_;
    Slice<Dtype>  // NOLINT_NEXT_LINE(whitespace/operators)
        <<<CAFFE_GET_BLOCKS(nthreads), CAFFE_CUDA_NUM_THREADS>>>(
        nthreads, top_diff, kForward, num_slices_, slice_size_,
        bottom_slice_axis, top_slice_axis, offset_slice_axis, bottom_diff);
    offset_slice_axis += top_slice_axis;
  }
}

INSTANTIATE_LAYER_GPU_FUNCS(SliceLayer);

}  // namespace caffe
小涵涵
关注
专栏目录
矩阵乘法算子caffe实现
m0_43553709的博客
06-05 443
caffe矩阵乘法算子的实现
caffe添加新层教程
热门推荐
shuzfan的专栏
05-05 3万+
时间节点2016.04，即caffe重大更新后（每一种层都对应一个同名cpp和hpp文件）。 描述一下本次要实现层的功能： 正向直接copy传播，反向时将梯度放缩指定倍。 这个层对一些特定的网络结构有很重要的辅助作用，比如有时我们的网络存在分支，但我们不希望某一分支影响之前层的更新，那么我们就将梯度放缩0倍。 （1）创建HPP头文件diff_cutoff_layer.hpp 不同...
caffe中新增自己的激活函数层_C++实现
AP1005834的博客
04-13 1383
一、前言     本篇主要转载自一个视频教程，主要实现在caffe中新增自己的层。 二、具体做法      自定义一个计算层，实现y=x^power+bur的功能，事实上这个新层为激活函数层 三、实现的方法思路             (1)任何一个层都可以被继承，然后进行重写函数     (2)尽量确保要实现的功能是否必须要自己写，不然尽量用已有的层，每一个层在caffe/incl...
caffe自定义层（c++实现）
xuyunyunaixuexi的博客
10-24 596
最近复现论文，感觉在caffe的源码结构理解上有了点进阶。 https://blog.csdn.net/ddreaming/article/details/53333349 https://blog.csdn.net/ap1005834/article/details/79251066  https://blog.csdn.net/seven_first/article/details/47...
Caffe实战系列：实现自己Caffe网络层
一亩半分地
09-13 8029
本文通过自己实现一个简单的caffe的层来阐述如何实现自己的网络层，同时介绍caffe的运行机理。为深度学习打下坚实的基础。
基于Caffe格式部署YOLOV5模型
3D视觉工坊
03-04 7046
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达【导语】本文为大家介绍了一个caffe部署yolov5 模型的教程，并开源了全部代码。主要是教你如何搭建caffe推理环境，对yolo...
caffe实现Mish层的
zhaokai5的博客
08-28 679
利用caffe实现Mish激活层Mish激活函数介绍 Mish激活函数介绍 Mish函数的表达式如下所示： Mish(x)=x∗tanh(soft(x))Mish(x)=x*tanh(soft(x))Mish(x)=x∗tanh(soft(x))tanh(x)=ex−e−xex+e−xtanh(x)=\frac{e^{x}-e^{-x}} {e^{x}+e^{-x}}tanh(x)=ex+e−xex−e−x​soft(x)=ln(1+ex)soft(x)=ln(1+e^x)soft(x)=ln(1+ex)
caffe的leaky层源码实现
10-11
在caffe下实现yolo需要添加一些特殊的层，其中yolo使用的激活函数为leaky，即需要在caffe特定目录下添加该层的源码实现。 （1）leaky_layer.hpp放在caffe/include/caffe/layers下； （2）leaky_layer.cpp放在caffe/...
标准caffe中实现darknet相关层。caffe和darknet模型的相互转换和加速（分类、检测、分割）
03-21
caffe实现darknet中的相关层，主要是yolo层和upsample层等； 实现yolo网络的训练和测试（分类、检测和分割）； 提供darknet模型转caffe模型； 实现bn层合并和yolo模型的加速。 示例：yolov3的darknet模型转caffe，并...
caffe实现的性别年龄表情预测分类
06-30
在本文中，我们将深入探讨如何使用Caffe框架实现性别、年龄和表情的预测分类任务。Caffe是一个流行的深度学习框架，以其高效、易用和广泛支持的模型库而闻名。在这个项目中，我们重点关注如何利用Caffe进行多类别的...
Caffe添加自定义的层
热爱生活，忠于自己
12-21 1万+
介绍在使用Caffe时，可能已有的层不满足需求，需要实现自己的层，最好的方式是修改caffe.proto文件，增加对应cpp、h、cu的声明和实现，编译caffe库即可。
在caffe中添加自定义层
并行时代
12-22 4494
Caffe中添加自定义层[6,7] 1）头文件 路径：py-faster-rcnn/caffe-fast-rcnn/include/caffe/layers 2）CPP或者CU文件 fasterrcnn_huawei/py-faster-rcnn/caffe-fast-rcnn/src/caffe/layers 3）caffe.proto定义该层的参数 py-faste
从yolov5谈 Backbone neck和head
qq_34929889的博客
01-27 9552
从yolov5谈 Backbone neck和headyolov5 流程图resnet+fpn yolov5 流程图 PANet实现 class YoloBody(nn.Module): def __init__(self, num_anchors, num_classes): super(YoloBody, self).__init__() # backbone self.backbone = darknet53(None) s
论文 | Free-Form Image Inpainting with Gated Convolution
qq_34929889的博客
04-14 1671
论文|Free-Form Image Inpainting with Gated Convolution 目录论文|Free-Form Image Inpainting with Gated ConvolutionAbstractIntroductionRelated WorkApproachGated ConvolutionSpectral-Normalized Markovian Discri...
论文总结 | Inpainting
qq_34929889的博客
04-15 1151
论文总结|Inpainting 这里写目录标题论文总结|InpaintingICCV2019 ICCV2019 Coherent Semantic Attention for Image Inpainting[paper][code] solution: the discontinuity of the local pixels。即以往的图像修复，往往没有考虑像素之间的连续性，映射到语义上来说就...
深度学习中的一些基本概念--帮助自己更好的理解和更改网络
qq_34929889的博客
12-04 657
1 卷积层的尺寸计算 feature map有四个维度，分别是N×H×W×C,而卷积核的输入通道数由feature map的C决定，输出通道数有它本身决定 输出矩阵的feature map FoutF_{out}Fout​的Hout和WoutH_{out}和W_{out}Hout​和Wout​由卷积核大小决定，计算如下： 2感受野的计算 举一个例子，原始图像为 55 ，卷积核（Kernel...
pytorch
qq_34929889的博客
12-11 637
1pytorch 学习 在学习深度学习框架之前，个人认为了解各个框架的输入才是一切的开始。因此，今天讨论下pytorch的数据输入。 1PIL 好多pytorch的测试代码都是用PIL读取图片而本人则比较喜欢opencv读取，那么先讨论PIL，cv2和torchvision.transforms的区别。 from PIL import Image import numpy as np image ...
Caffe 实现LSTM
最新发布
03-31
Caffe是一个深度学习框架，它主要用于卷积神经网络。然而，由于LSTM网络也是深度学习的一种形式，因此Caffe也可以用于实现LSTM网络。 在Caffe中，实现LSTM网络的步骤与实现卷积神经网络的步骤类似。主要的区别在于LSTM网络中的神经元类型和连接方式。 以下是一个简单的LSTM网络的示例代码： ```python # 定义LSTM网络结构 net = caffe.NetSpec() net.data = caffe.layers.Input(shape=dict(dim=[1, 1, 10, 1])) # 定义LSTM层 net.lstm1 = caffe.layers.LSTM(num_output=10, weight_filler=dict(type='xavier')) net.lstm2 = caffe.layers.LSTM(num_output=10, weight_filler=dict(type='xavier')) # 定义全连接层 net.fc = caffe.layers.InnerProduct(num_output=1, weight_filler=dict(type='xavier')) # 定义网络结构 net.lstm1_top, net.lstm1_memory = net.lstm1(net.data, None) net.lstm2_top, net.lstm2_memory = net.lstm2(net.lstm1_top, net.lstm1_memory) net.fc_top = net.fc(net.lstm2_top) # 生成网络 with open('lstm.prototxt', 'w') as f: f.write(str(net.to_proto())) ``` 在这个示例中，我们定义了一个包含两个LSTM层和一个全连接层的网络。我们使用`LSTM`层来定义LSTM神经元，并使用`InnerProduct`层定义全连接层。我们还使用`Input`层来定义输入数据的形状。 在定义完网络结构之后，我们可以使用`to_proto()`方法将网络结构以字符串的形式写入文件中。这个文件可以被Caffe加载并用于训练和测试LSTM网络。 需要注意的是，与卷积神经网络不同，LSTM网络需要定义内部记忆状态。在这个示例中，我们使用`net.lstm1_memory`和`net.lstm2_memory`来存储LSTM层的内部状态，以便在下一次前向传递中使用。 此外，还需要注意LSTM网络的训练过程中需要使用BPTT（Back-Propagation Through Time）算法。这个算法是用于处理时间序列数据的反向传播算法。在Caffe中，我们可以使用`LSTMUnitLayer`层来实现BPTT算法。 总之，Caffe可以用于实现LSTM网络，只需要将LSTM层和全连接层添加到网络中，并定义好内部状态和BPTT算法即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小涵涵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值