reid from https://github.com/michuanhaohao/reid-strong-baseline
554325746@qq.com
2020-03-24 495ffcdad0027be02d5fc82825e08f36b6a53b90
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#ifndef CAFFE2_OPERATOR_GLU_OP_H_
#define CAFFE2_OPERATOR_GLU_OP_H_
 
#include "caffe2/core/context.h"
#include "caffe2/core/operator.h"
 
namespace caffe2 {
template <typename T, class Context>
class GluOp final : public Operator<Context> {
 public:
  template <class... Args>
  explicit GluOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...),
        dim_(this->template GetSingleArgument<int>("dim", -1)) {}
 
  USE_OPERATOR_CONTEXT_FUNCTIONS;
 
  bool RunOnDevice() {
    auto& X = Input(0);
 
    vector<int64_t> Yshape;
    Yshape.insert(Yshape.end(), X.sizes().begin(), X.sizes().end());
    const int split_index = dim_ == -1 ? Yshape.size() - 1 : dim_;
    CAFFE_ENFORCE(
        Yshape[split_index] % 2 == 0,
        "Split dimension ",
        Yshape[split_index],
        " should be divided by two");
    const int split_dim_size = Yshape[split_index] / 2;
    const int M = X.size_to_dim(split_index);
    const int N = X.size_from_dim(split_index + 1);
    Yshape[split_index] = split_dim_size;
    auto* Y = Output(0, Yshape, at::dtype<T>());
    ComputeGlu(
        M,
        split_dim_size,
        N,
        X.template data<T>(),
        Y->template mutable_data<T>());
    return true;
  }
 
 protected:
  void ComputeGlu(
      const int M,
      const int split_dim_size,
      const int N,
      const T* X,
      T* output);
 
 private:
  const int dim_;
};
} // namespace caffe2
 
#endif // CAFFE2_OPERATOR_GLU_OP_H_