uniform_random_op.cc 5.7 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
Y
Yu Yang 已提交
2

L
Luo Tao 已提交
3 4 5 6 7 8 9 10 11 12 13
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */
Y
Yi Wang 已提交
14 15
#include "paddle/fluid/framework/op_registry.h"
#include "paddle/fluid/framework/operator.h"
Y
Yu Yang 已提交
16 17 18

namespace paddle {
namespace operators {
Y
Yu Yang 已提交
19

Q
qijun 已提交
20 21 22 23
// It seems that Eigen::Tensor::random in GPU will SEGFAULT.
// Use std::random and thrust::random(thrust is a std library in CUDA) to
// implement uniform random.
template <typename T>
Y
Yu Yang 已提交
24
class CPUUniformRandomKernel : public framework::OpKernel<T> {
Q
qijun 已提交
25
 public:
Q
Qiao Longfei 已提交
26
  void Compute(const framework::ExecutionContext& ctx) const override {
Y
Yancey1989 已提交
27
    framework::Tensor* tensor = nullptr;
Y
Yancey1989 已提交
28 29 30 31 32 33 34 35
    auto out_var = ctx.OutputVar("Out");
    if (out_var->IsType<framework::LoDTensor>()) {
      tensor = out_var->GetMutable<framework::LoDTensor>();
    } else if (out_var->IsType<framework::SelectedRows>()) {
      auto shape = ctx.Attr<std::vector<int>>("shape");
      tensor = out_var->GetMutable<framework::SelectedRows>()->mutable_value();
      tensor->Resize(framework::make_ddim(shape));
    } else {
Y
Yancey1989 已提交
36 37 38
      PADDLE_THROW(
          "uniform_random_op's output only"
          "supports SelectedRows and Tensor");
Y
Yancey1989 已提交
39
    }
Q
Qiao Longfei 已提交
40 41
    T* data = tensor->mutable_data<T>(ctx.GetPlace());
    unsigned int seed = static_cast<unsigned int>(ctx.Attr<int>("seed"));
Q
qijun 已提交
42 43 44 45 46 47
    std::minstd_rand engine;
    if (seed == 0) {
      seed = std::random_device()();
    }
    engine.seed(seed);
    std::uniform_real_distribution<T> dist(
Q
Qiao Longfei 已提交
48 49
        static_cast<T>(ctx.Attr<float>("min")),
        static_cast<T>(ctx.Attr<float>("max")));
50
    int64_t size = tensor->numel();
Q
qijun 已提交
51
    for (int64_t i = 0; i < size; ++i) {
Q
qijun 已提交
52 53 54 55 56
      data[i] = dist(engine);
    }
  }
};

Y
Yu Yang 已提交
57
class UniformRandomOp : public framework::OperatorWithKernel {
Y
Yu Yang 已提交
58 59 60
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;

61
  void InferShape(framework::InferShapeContext* ctx) const override {
Q
Qiao Longfei 已提交
62 63
    PADDLE_ENFORCE(ctx->HasOutput("Out"),
                   "Output(Out) of UniformRandomOp should not be null.");
64

Q
Qiao Longfei 已提交
65 66 67
    PADDLE_ENFORCE(
        ctx->Attrs().Get<float>("min") < ctx->Attrs().Get<float>("max"),
        "uniform_random's min must less then max");
Q
QI JUN 已提交
68
    auto& shape = ctx->Attrs().Get<std::vector<int>>("shape");
Q
qijun 已提交
69
    std::vector<int64_t> temp;
Q
QI JUN 已提交
70 71
    temp.reserve(shape.size());
    for (auto dim : shape) {
Q
qijun 已提交
72 73
      temp.push_back(static_cast<int64_t>(dim));
    }
Q
Qiao Longfei 已提交
74
    ctx->SetOutputDim("Out", framework::make_ddim(temp));
Y
Yu Yang 已提交
75
  }
Y
Yu Yang 已提交
76

77
 protected:
78
  framework::OpKernelType GetExpectedKernelType(
Y
Yu Yang 已提交
79
      const framework::ExecutionContext& ctx) const override {
Y
Yu Yang 已提交
80
    return framework::OpKernelType(
81
        static_cast<framework::proto::VarType::Type>(ctx.Attr<int>("dtype")),
Q
QI JUN 已提交
82
        ctx.GetPlace());
Y
Yu Yang 已提交
83
  }
Y
Yu Yang 已提交
84 85
};

Y
Yu Yang 已提交
86
class UniformRandomOpMaker : public framework::OpProtoAndCheckerMaker {
Y
Yu Yang 已提交
87
 public:
88
  UniformRandomOpMaker(OpProto* proto, OpAttrChecker* op_checker)
Y
Yu Yang 已提交
89
      : framework::OpProtoAndCheckerMaker(proto, op_checker) {
90 91 92 93
    AddOutput("Out", "(Tensor) The output tensor of uniform random op");
    AddComment(R"DOC(
Uniform random operator.

94
This operator initializes a tensor with random values sampled from a
95 96
uniform distribution.

Y
Yu Yang 已提交
97
)DOC");
98 99 100 101 102 103 104 105 106 107
    AddAttr<std::vector<int>>("shape",
                              "(vector<int>) The shape of the output tensor");
    AddAttr<float>("min",
                   "(float, default -1.0) "
                   "Minimum value of uniform random")
        .SetDefault(-1.0f);
    AddAttr<float>("max",
                   "(float, default 1.0) "
                   "Maximun value of uniform random")
        .SetDefault(1.0f);
Q
qijun 已提交
108
    AddAttr<int>("seed",
109 110
                 "(int, default 0) "
                 "Random seed used for generating samples. "
111 112 113
                 "0 means use a seed generated by the system."
                 "Note that if seed is not 0, this operator will always "
                 "generate the same random numbers every time.")
Q
qijun 已提交
114
        .SetDefault(0);
F
fengjiayi 已提交
115
    AddAttr<int>("dtype", "(int, default 5(FP32)) Output tensor data type")
116
        .SetDefault(framework::proto::VarType::FP32);
Y
Yu Yang 已提交
117 118
  }
};
Y
Yancey1989 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135

class UniformRandomOpVarTypeInference : public framework::VarTypeInference {
 public:
  void operator()(const framework::OpDesc& op_desc,
                  framework::BlockDesc* block) const override {
    auto out_var_name = op_desc.Output("Out").front();
    if (block->FindRecursiveOrCreateVar(out_var_name).GetType() ==
        framework::proto::VarType::SELECTED_ROWS) {
      block->FindRecursiveOrCreateVar(out_var_name)
          .SetType(framework::proto::VarType::SELECTED_ROWS);
    } else {
      block->FindRecursiveOrCreateVar(out_var_name)
          .SetType(framework::proto::VarType::LOD_TENSOR);
    }
  }
};

Y
Yu Yang 已提交
136 137 138
}  // namespace operators
}  // namespace paddle

Y
Yancey1989 已提交
139 140 141 142 143
REGISTER_OPERATOR(uniform_random, paddle::operators::UniformRandomOp,
                  paddle::operators::UniformRandomOpMaker,
                  paddle::framework::EmptyGradOpMaker,
                  paddle::operators::UniformRandomOpVarTypeInference);

Q
qijun 已提交
144
REGISTER_OP_CPU_KERNEL(uniform_random,
145 146
                       paddle::operators::CPUUniformRandomKernel<float>,
                       paddle::operators::CPUUniformRandomKernel<double>);
147 148 149
REGISTER_OP_CPU_KERNEL(uniform_random_batch_size_like,
                       paddle::operators::CPUUniformRandomKernel<float>,
                       paddle::operators::CPUUniformRandomKernel<double>);