Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle into add_program_proto
fengjiayi
8 years ago
commit
5f2cd1a452
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,100 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#define EIGEN_USE_GPU
|
||||
#include "paddle/operators/activation_op.h"
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(sigmoid,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float,
|
||||
ops::SigmoidFunctor<float>>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
sigmoid_grad, ops::ActivationGradKernel<paddle::platform::GPUPlace, float,
|
||||
ops::SigmoidGradFunctor<float>>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
exp,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float, ops::ExpFunctor>);
|
||||
REGISTER_OP_GPU_KERNEL(exp_grad,
|
||||
ops::ActivationGradKernel<paddle::platform::GPUPlace,
|
||||
float, ops::ExpGradFunctor>);
|
||||
REGISTER_OP_GPU_KERNEL(relu,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float,
|
||||
ops::ReluFunctor<float>>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
relu_grad, ops::ActivationGradKernel<paddle::platform::GPUPlace, float,
|
||||
ops::ReluGradFunctor<float>>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
tanh,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float, ops::TanhFunctor>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
tanh_grad, ops::ActivationGradKernel<paddle::platform::GPUPlace, float,
|
||||
ops::TanhGradFunctor<float>>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
sqrt,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float, ops::SqrtFunctor>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
sqrt_grad, ops::ActivationGradKernel<paddle::platform::GPUPlace, float,
|
||||
ops::SqrtGradFunctor<float>>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
abs,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float, ops::AbsFunctor>);
|
||||
REGISTER_OP_GPU_KERNEL(abs_grad,
|
||||
ops::ActivationGradKernel<paddle::platform::GPUPlace,
|
||||
float, ops::AbsGradFunctor>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(reciprocal,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float,
|
||||
ops::ReciprocalFunctor<float>>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
reciprocal_grad,
|
||||
ops::ActivationGradKernel<paddle::platform::GPUPlace, float,
|
||||
ops::ReciprocalGradFunctor<float>>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
log,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float, ops::LogFunctor>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
log_grad, ops::ActivationGradKernel<paddle::platform::GPUPlace, float,
|
||||
ops::LogGradFunctor<float>>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(square,
|
||||
ops::ActivationKernel<paddle::platform::GPUPlace, float,
|
||||
ops::SquareFunctor>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
square_grad, ops::ActivationGradKernel<paddle::platform::GPUPlace, float,
|
||||
ops::SquareGradFunctor<float>>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(brelu,
|
||||
ops::BReluKernel<paddle::platform::GPUPlace, float>);
|
||||
REGISTER_OP_GPU_KERNEL(brelu_grad,
|
||||
ops::BReluGradKernel<paddle::platform::GPUPlace, float>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(soft_relu,
|
||||
ops::SoftReluKernel<paddle::platform::GPUPlace, float>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
soft_relu_grad, ops::SoftReluGradKernel<paddle::platform::GPUPlace, float>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(pow, ops::PowKernel<paddle::platform::GPUPlace, float>);
|
||||
REGISTER_OP_GPU_KERNEL(pow_grad,
|
||||
ops::PowGradKernel<paddle::platform::GPUPlace, float>);
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(stanh,
|
||||
ops::STanhKernel<paddle::platform::GPUPlace, float>);
|
||||
REGISTER_OP_GPU_KERNEL(stanh_grad,
|
||||
ops::STanhGradKernel<paddle::platform::GPUPlace, float>);
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,139 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#include "paddle/operators/crop_op.h"
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using framework::Tensor;
|
||||
using framework::LoDTensor;
|
||||
|
||||
class CropOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"),
|
||||
"Input(X) of CropOp should not be null.");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.OutputVar("Out"),
|
||||
"Output(Out) of CropOp should not be null.");
|
||||
auto x_dim = ctx.Input<LoDTensor>("X")->dims();
|
||||
auto *y = ctx.Input<LoDTensor>("Y");
|
||||
auto *out = ctx.Output<LoDTensor>("Out");
|
||||
if (y == nullptr) {
|
||||
auto shape = Attr<std::vector<int>>("shape");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
int64_t(shape.size()), x_dim.size(),
|
||||
"Shape size should be equal to dimention size of input tensor.");
|
||||
std::vector<int64_t> tensor_shape(shape.size());
|
||||
for (size_t i = 0; i < shape.size(); ++i) {
|
||||
tensor_shape[i] = static_cast<int64_t>(shape[i]);
|
||||
}
|
||||
out->Resize(framework::make_ddim(tensor_shape));
|
||||
} else {
|
||||
PADDLE_ENFORCE_EQ(framework::arity(x_dim), framework::arity(y->dims()),
|
||||
"Tensor rank of both CropOp's "
|
||||
"inputs must be same.");
|
||||
out->Resize(y->dims());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class CropOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
CropOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X",
|
||||
"The input of pad op. "
|
||||
"The input should be a k-D tensor(k > 0 and k < 7)");
|
||||
AddInput("Y",
|
||||
"The input used as reference for cropping"
|
||||
" with the same dimension as X. ");
|
||||
AddOutput("Out",
|
||||
"The output of crop op "
|
||||
"with the same dimension as X.");
|
||||
AddAttr<std::vector<int>>("offsets",
|
||||
"A list<int> describing offsets to be cropped."
|
||||
"The size of offsets list should be as same as "
|
||||
"dimension size of input X.");
|
||||
AddAttr<std::vector<int>>("shape",
|
||||
"A list<int> describing the shape of output."
|
||||
"The size of shape list should be as same as "
|
||||
"dimension size of input X.")
|
||||
.SetDefault(std::vector<int>());
|
||||
AddComment(R"DOC(
|
||||
Crop Operator.
|
||||
Crop input into output, as specified by offsets and shape.
|
||||
|
||||
There are two ways to set shape:
|
||||
1. referenc input: crop input X as shape as reference input.
|
||||
The dimension of reference input should
|
||||
be as same as input X.
|
||||
2. shape list: crop input X by shape described by a list<int>.
|
||||
The size of shape list should be as same as
|
||||
dimension size of input X.
|
||||
|
||||
The input should be a k-D tensor(k > 0 and k < 7). As an example:
|
||||
|
||||
Given:
|
||||
|
||||
X = [[0, 1, 2, 0, 0]
|
||||
[0, 3, 4, 0, 0]
|
||||
[0, 0, 0, 0, 0]]
|
||||
|
||||
and
|
||||
|
||||
offsets = [0, 1]
|
||||
|
||||
and
|
||||
|
||||
shape = [2, 2]
|
||||
|
||||
then we get
|
||||
|
||||
Out = [[1, 2],
|
||||
[3, 4]]
|
||||
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class CropOpGrad : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"), "Input(X) should not be null");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar(framework::GradVarName("Out")),
|
||||
"Input(Out@GRAD) should not be null");
|
||||
auto x_dims = ctx.Input<LoDTensor>("X")->dims();
|
||||
auto *x_grad = ctx.Output<LoDTensor>(framework::GradVarName("X"));
|
||||
if (x_grad != nullptr) {
|
||||
x_grad->Resize(x_dims);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP(crop, ops::CropOp, ops::CropOpMaker, crop_grad, ops::CropOpGrad);
|
||||
REGISTER_OP_CPU_KERNEL(crop, ops::CropKernel<float>);
|
||||
REGISTER_OP_CPU_KERNEL(crop_grad,
|
||||
ops::CropGradKernel<paddle::platform::CPUPlace, float>);
|
||||
@ -0,0 +1,104 @@
|
||||
/* Copyright (c) 2016 CropdleCropdle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "paddle/framework/eigen.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
#include "paddle/operators/strided_memcpy.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators { // Internal
|
||||
|
||||
template <typename T, size_t D, int MajorType = Eigen::RowMajor,
|
||||
typename IndexType = Eigen::DenseIndex>
|
||||
using EigenTensor = framework::EigenTensor<T, D, MajorType, IndexType>;
|
||||
using framework::Tensor;
|
||||
|
||||
template <typename T>
|
||||
class CropKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& context) const override {
|
||||
auto* x = context.Input<Tensor>("X");
|
||||
auto* out = context.Output<Tensor>("Out");
|
||||
const T* x_data = x->data<T>();
|
||||
T* out_data = out->mutable_data<T>(context.GetPlace());
|
||||
auto x_stride = framework::stride(x->dims());
|
||||
auto out_stride = framework::stride(out->dims());
|
||||
auto offsets = context.Attr<std::vector<int>>("offsets");
|
||||
PADDLE_ENFORCE_EQ(
|
||||
x->dims().size(), offsets.size(),
|
||||
"Offsets size should be equal to dimension size of input tensor.");
|
||||
int64_t offset = 0;
|
||||
for (int i = 0; i < offsets.size(); ++i) {
|
||||
offset += (x_stride[i] * offsets[i]);
|
||||
}
|
||||
StridedMemcpy<T>(context.device_context(), x_data + offset, x_stride,
|
||||
out->dims(), out_stride, out_data);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Place, typename T, size_t D>
|
||||
void CropGradFunction(const framework::ExecutionContext& context) {
|
||||
auto* d_x = context.Output<Tensor>(framework::GradVarName("X"));
|
||||
if (d_x != nullptr) {
|
||||
auto* d_out = context.Input<Tensor>(framework::GradVarName("Out"));
|
||||
d_x->mutable_data<T>(context.GetPlace());
|
||||
auto offsets = context.Attr<std::vector<int>>("offsets");
|
||||
Eigen::array<std::pair<int, int>, D> paddings;
|
||||
for (int i = 0; i < D; ++i) {
|
||||
paddings[i].first = offsets[i];
|
||||
paddings[i].second = d_x->dims()[i] - d_out->dims()[i] - offsets[i];
|
||||
}
|
||||
auto d_x_tensor = EigenTensor<T, D>::From(*d_x);
|
||||
auto d_out_tensor = EigenTensor<T, D>::From(*d_out);
|
||||
d_x_tensor.device(context.GetEigenDevice<Place>()) =
|
||||
d_out_tensor.pad(paddings, 0);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Place, typename T>
|
||||
class CropGradKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& context) const override {
|
||||
size_t rank =
|
||||
context.Input<Tensor>(framework::GradVarName("Out"))->dims().size();
|
||||
switch (rank) {
|
||||
case 1:
|
||||
CropGradFunction<Place, T, 1>(context);
|
||||
break;
|
||||
case 2:
|
||||
CropGradFunction<Place, T, 2>(context);
|
||||
break;
|
||||
case 3:
|
||||
CropGradFunction<Place, T, 3>(context);
|
||||
break;
|
||||
case 4:
|
||||
CropGradFunction<Place, T, 4>(context);
|
||||
break;
|
||||
case 5:
|
||||
CropGradFunction<Place, T, 5>(context);
|
||||
break;
|
||||
case 6:
|
||||
CropGradFunction<Place, T, 6>(context);
|
||||
break;
|
||||
default:
|
||||
PADDLE_THROW(
|
||||
"CropOp only support tensors with no more than 6 dimensions.");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,126 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#include "paddle/operators/rank_loss_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
class RankLossOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
RankLossOp(const std::string &type, const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: OperatorWithKernel(type, inputs, outputs, attrs) {}
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
// input check
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Label"),
|
||||
"Input(Label) shouldn't be null");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Left"),
|
||||
"Input(Left) shouldn't be null");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Right"),
|
||||
"Input(Right) shouldn't be null");
|
||||
auto label_dims = ctx.Input<framework::Tensor>("Label")->dims();
|
||||
auto left_dims = ctx.Input<framework::Tensor>("Left")->dims();
|
||||
auto right_dims = ctx.Input<framework::Tensor>("Right")->dims();
|
||||
PADDLE_ENFORCE((label_dims == left_dims) && (left_dims == right_dims),
|
||||
"All inputs must have the same size");
|
||||
PADDLE_ENFORCE((label_dims.size() == 2) && (label_dims[1] == 1),
|
||||
"All inputs must be row vector with size batch_size x 1.");
|
||||
ctx.Output<framework::LoDTensor>("Out")->Resize(label_dims);
|
||||
}
|
||||
};
|
||||
|
||||
class RankLossOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
RankLossOpMaker(framework::OpProto *proto,
|
||||
framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("Label",
|
||||
"The label indicating A ranked higher than B or not, row vector.");
|
||||
AddInput("Left", "The output of RankNet for doc A, vector.");
|
||||
AddInput("Right", "The output of RankNet for doc B, vetor");
|
||||
AddOutput("Out", "The output loss of RankLoss operator, vector.");
|
||||
AddComment(R"DOC(RankLoss operator
|
||||
|
||||
Rank loss operator for RankNet[1]. RankNet is a pairwise ranking model with
|
||||
one training sample consisting of a pair of doc A and B, and the label P
|
||||
indicating that A is ranked higher than B or not:
|
||||
|
||||
P = {0, 1} or {0, 0.5, 1}, where 0.5 means no information about the rank of
|
||||
the input pair.
|
||||
|
||||
The RankLoss operator contains three inputs: Left (o_i), Right (o_j) and Label
|
||||
(P_{i,j}), which represent the output of RankNet for two docs and the label
|
||||
respectively, and yields the rank loss C_{i,j} by following the expression
|
||||
|
||||
\f[
|
||||
C_{i,j} = -\tilde{P_{ij}} * o_{i,j} + log(1 + e^{o_{i,j}}) \\
|
||||
o_{i,j} = o_i - o_j \\
|
||||
\tilde{P_{i,j}} = \left \{0, 0.5, 1 \right \} \ or \ \left \{0, 1 \right \}
|
||||
\f]
|
||||
|
||||
The operator can take inputs of one sample or in batch.
|
||||
|
||||
[1]. Chris Burges, Tal Shaked, Erin Renshaw, et al. Learning to
|
||||
Rank using Gradient Descent.
|
||||
http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class RankLossGradOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
RankLossGradOp(const std::string &type,
|
||||
const framework::VariableNameMap &inputs,
|
||||
const framework::VariableNameMap &outputs,
|
||||
const framework::AttributeMap &attrs)
|
||||
: OperatorWithKernel(type, inputs, outputs, attrs) {}
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Label"),
|
||||
"Input(Label) shouldn't be null.");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Left"),
|
||||
"Input(Left) shouldn't be null.");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Right"),
|
||||
"Input(Right) shouldn't be null.");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar(framework::GradVarName("Out")),
|
||||
"Input(Out@GRAD) shouldn't be null.");
|
||||
auto dims = ctx.Input<framework::Tensor>("Left")->dims();
|
||||
auto *left_grad =
|
||||
ctx.Output<framework::LoDTensor>(framework::GradVarName("Left"));
|
||||
auto *right_grad =
|
||||
ctx.Output<framework::LoDTensor>(framework::GradVarName("Right"));
|
||||
if (left_grad) {
|
||||
left_grad->Resize(dims);
|
||||
}
|
||||
if (right_grad) {
|
||||
right_grad->Resize(dims);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
namespace ops = paddle::operators;
|
||||
|
||||
REGISTER_OP(rank_loss, ops::RankLossOp, ops::RankLossOpMaker, rank_loss_grad,
|
||||
ops::RankLossGradOp);
|
||||
REGISTER_OP_CPU_KERNEL(rank_loss,
|
||||
ops::RankLossKernel<paddle::platform::CPUPlace, float>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
rank_loss_grad, ops::RankLossGradKernel<paddle::platform::CPUPlace, float>);
|
||||
@ -0,0 +1,22 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#include "paddle/operators/rank_loss_op.h"
|
||||
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
rank_loss,
|
||||
paddle::operators::RankLossKernel<paddle::platform::GPUPlace, float>);
|
||||
REGISTER_OP_GPU_KERNEL(
|
||||
rank_loss_grad,
|
||||
paddle::operators::RankLossGradKernel<paddle::platform::GPUPlace, float>);
|
||||
@ -0,0 +1,80 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "paddle/framework/eigen.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
template <typename Place, typename T>
|
||||
class RankLossKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& ctx) const {
|
||||
auto* out_t = ctx.Output<framework::LoDTensor>("Out");
|
||||
auto* label_t = ctx.Input<framework::Tensor>("Label");
|
||||
auto* left_t = ctx.Input<framework::Tensor>("Left");
|
||||
auto* right_t = ctx.Input<framework::Tensor>("Right");
|
||||
out_t->mutable_data<T>(ctx.GetPlace());
|
||||
|
||||
auto out = framework::EigenVector<T>::Flatten(*out_t);
|
||||
auto label = framework::EigenVector<T>::Flatten(*label_t);
|
||||
auto left = framework::EigenVector<T>::Flatten(*left_t);
|
||||
auto right = framework::EigenVector<T>::Flatten(*right_t);
|
||||
|
||||
auto& dev = ctx.GetEigenDevice<Place>();
|
||||
out.device(dev) =
|
||||
(1. + (left - right).exp()).log() - label * (left - right);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Place, typename T>
|
||||
class RankLossGradKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& ctx) const {
|
||||
auto* d_left_t =
|
||||
ctx.Output<framework::LoDTensor>(framework::GradVarName("Left"));
|
||||
auto* d_right_t =
|
||||
ctx.Output<framework::LoDTensor>(framework::GradVarName("Right"));
|
||||
|
||||
auto* d_out_t = ctx.Input<framework::Tensor>(framework::GradVarName("Out"));
|
||||
auto* label_t = ctx.Input<framework::Tensor>("Label");
|
||||
auto* left_t = ctx.Input<framework::Tensor>("Left");
|
||||
auto* right_t = ctx.Input<framework::Tensor>("Right");
|
||||
|
||||
auto& dev = ctx.GetEigenDevice<Place>();
|
||||
auto d_out = framework::EigenVector<T>::Flatten(*d_out_t);
|
||||
auto label = framework::EigenVector<T>::Flatten(*label_t);
|
||||
auto left = framework::EigenVector<T>::Flatten(*left_t);
|
||||
auto right = framework::EigenVector<T>::Flatten(*right_t);
|
||||
|
||||
// compute d_left
|
||||
if (d_left_t) {
|
||||
d_left_t->mutable_data<T>(ctx.GetPlace());
|
||||
auto d_left = framework::EigenVector<T>::Flatten(*d_left_t);
|
||||
d_left.device(dev) = d_out * (1. / (1. + (right - left).exp()) - label);
|
||||
}
|
||||
// compute d_right
|
||||
if (d_right_t) {
|
||||
d_right_t->mutable_data<T>(ctx.GetPlace());
|
||||
auto d_right = framework::EigenVector<T>::Flatten(*d_right_t);
|
||||
d_right.device(dev) =
|
||||
-d_out * (1.0 / (1. + (right - left).exp()) - label);
|
||||
}
|
||||
}
|
||||
};
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -1,67 +0,0 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#include "paddle/operators/sigmoid_op.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
class SigmoidOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"),
|
||||
"Input(X) of SigmoidOp should not be null.");
|
||||
PADDLE_ENFORCE_NOT_NULL(ctx.OutputVar("Y"),
|
||||
"Output(Y) of SigmoidOp should not be null.");
|
||||
|
||||
ctx.Output<framework::LoDTensor>("Y")->Resize(
|
||||
ctx.Input<Tensor>("X")->dims());
|
||||
}
|
||||
};
|
||||
|
||||
class SigmoidOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
SigmoidOpMaker(framework::OpProto *proto,
|
||||
framework::OpAttrChecker *op_checker)
|
||||
: OpProtoAndCheckerMaker(proto, op_checker) {
|
||||
AddInput("X", "sigmoid input");
|
||||
AddOutput("Y", "sigmoid output");
|
||||
AddComment("Sigmoid function");
|
||||
}
|
||||
};
|
||||
|
||||
class SigmoidOpGrad : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(const framework::InferShapeContext &ctx) const override {
|
||||
ctx.Output<framework::LoDTensor>(framework::GradVarName("X"))
|
||||
->Resize(ctx.Input<Tensor>("Y")->dims());
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP(sigmoid, ops::SigmoidOp, ops::SigmoidOpMaker, sigmoid_grad,
|
||||
ops::SigmoidOpGrad);
|
||||
REGISTER_OP_CPU_KERNEL(sigmoid,
|
||||
ops::SigmoidKernel<paddle::platform::CPUPlace, float>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
sigmoid_grad, ops::SigmoidGradKernel<paddle::platform::CPUPlace, float>);
|
||||
@ -1,62 +0,0 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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. */
|
||||
|
||||
#pragma once
|
||||
#include "paddle/framework/eigen.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using Tensor = framework::Tensor;
|
||||
template <typename T, int MajorType = Eigen::RowMajor,
|
||||
typename IndexType = Eigen::DenseIndex>
|
||||
using EigenVector = framework::EigenVector<T, MajorType, IndexType>;
|
||||
|
||||
template <typename Place, typename T>
|
||||
class SigmoidKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& context) const override {
|
||||
auto input = context.Input<Tensor>("X");
|
||||
auto output = context.Output<Tensor>("Y");
|
||||
output->mutable_data<T>(context.GetPlace());
|
||||
|
||||
// The clipping is used in Paddle's raw implenmention
|
||||
auto X = EigenVector<T>::Flatten(*input);
|
||||
auto Y = EigenVector<T>::Flatten(*output);
|
||||
auto place = context.GetEigenDevice<Place>();
|
||||
|
||||
Y.device(place) = 1. / (1. + (-X).exp());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Place, typename T>
|
||||
class SigmoidGradKernel : public framework::OpKernel {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext& context) const override {
|
||||
auto Y_t = context.Input<Tensor>("Y");
|
||||
auto dY_t = context.Input<Tensor>(framework::GradVarName("Y"));
|
||||
auto dX_t = context.Output<Tensor>(framework::GradVarName("X"));
|
||||
|
||||
dX_t->mutable_data<T>(context.GetPlace());
|
||||
|
||||
auto dX = EigenVector<T>::Flatten(*dX_t);
|
||||
auto Y = EigenVector<T>::Flatten(*Y_t);
|
||||
auto dY = EigenVector<T>::Flatten(*dY_t);
|
||||
dX.device(context.GetEigenDevice<Place>()) = dY * Y * (1. - Y);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,223 @@
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
|
||||
|
||||
class TestExp(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "exp"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
self.outputs = {'Y': np.exp(self.inputs['X'])}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
class TestSigmoid(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "sigmoid"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
self.outputs = {'Y': 1 / (1 + np.exp(-self.inputs['X']))}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.008)
|
||||
|
||||
|
||||
class TestTanh(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "tanh"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
self.outputs = {'Y': np.tanh(self.inputs['X'])}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
class TestSqrt(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "sqrt"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
self.outputs = {'Y': np.sqrt(self.inputs['X'])}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
class TestAbs(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "abs"
|
||||
x = np.random.uniform(-1, 1, [4, 4]).astype("float32")
|
||||
# Because we set delta = 0.005 in caculating numeric gradient,
|
||||
# if x is too small, such as 0.002, x_neg will be -0.003
|
||||
# x_pos will be 0.007, so the numeric gradient is unaccurate.
|
||||
# we should avoid this
|
||||
x[np.abs(x) < 0.005] = 0.02
|
||||
self.inputs = {'X': x}
|
||||
self.outputs = {'Y': np.abs(self.inputs['X'])}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
class TestRelu(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "relu"
|
||||
x = np.random.uniform(-1, 1, [11, 17]).astype("float32")
|
||||
# The same reason with TestAbs
|
||||
x[np.abs(x) < 0.005] = 0.02
|
||||
self.inputs = {'X': x}
|
||||
self.outputs = {'Y': np.maximum(self.inputs['X'], 0)}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
class TestBRelu(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "brelu"
|
||||
x = np.random.uniform(-1, 1, [4, 4]).astype("float32")
|
||||
t_min = 1
|
||||
t_max = 4
|
||||
# The same with TestAbs
|
||||
x[np.abs(x - t_min) < 0.005] = t_min + 0.02
|
||||
x[np.abs(x - t_max) < 0.005] = t_max + 0.02
|
||||
|
||||
self.inputs = {'X': x}
|
||||
self.attrs = {'t_min': t_min, 't_max': t_max}
|
||||
t = np.copy(x)
|
||||
t[t < t_min] = t_min
|
||||
t[t > t_max] = t_max
|
||||
self.outputs = {'Y': t}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.02)
|
||||
|
||||
|
||||
class TestSoftRelu(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "soft_relu"
|
||||
x = np.random.uniform(-3, 3, [4, 4]).astype("float32")
|
||||
threshold = 2
|
||||
# The same reason with TestAbs
|
||||
x[np.abs(x - threshold) < 0.005] = threshold + 0.02
|
||||
x[np.abs(x + threshold) < 0.005] = -threshold + 0.02
|
||||
self.inputs = {'X': x}
|
||||
self.attrs = {'threshold': threshold}
|
||||
t = np.copy(x)
|
||||
t[t < -threshold] = -threshold
|
||||
t[t > threshold] = threshold
|
||||
self.outputs = {'Y': np.log((np.exp(t) + 1))}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.02)
|
||||
|
||||
|
||||
class TestReciprocal(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "reciprocal"
|
||||
self.inputs = {'X': np.random.uniform(1, 2, [11, 17]).astype("float32")}
|
||||
self.outputs = {'Y': np.reciprocal(self.inputs['X'])}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.01)
|
||||
|
||||
|
||||
class TestLog(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "log"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
self.outputs = {'Y': np.log(self.inputs['X'])}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
class TestSquare(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "square"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
self.outputs = {'Y': np.square(self.inputs['X'])}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
class TestPow(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "pow"
|
||||
self.inputs = {'X': np.random.uniform(1, 2, [11, 17]).astype("float32")}
|
||||
self.attrs = {'factor': 3}
|
||||
self.outputs = {'Y': np.power(self.inputs['X'], 3)}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.02)
|
||||
|
||||
|
||||
class TestSTanh(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "stanh"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
scale_a = 2.0 / 3.0
|
||||
scale_b = 1.7159
|
||||
self.attrs = {'scale_a': scale_a, 'scale_b': scale_b}
|
||||
self.outputs = {'Y': scale_b * np.tanh(self.inputs['X'] * scale_a)}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(['X'], 'Y', max_relative_error=0.007)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@ -0,0 +1,91 @@
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
|
||||
|
||||
def crop(data, offsets, crop_shape):
|
||||
def indexOf(shape, index):
|
||||
result = []
|
||||
for dim in reversed(shape):
|
||||
result.append(index % dim)
|
||||
index = index / dim
|
||||
return result[::-1]
|
||||
|
||||
result = []
|
||||
for i, value in enumerate(data.flatten()):
|
||||
index = indexOf(data.shape, i)
|
||||
selected = True
|
||||
if len(index) == len(offsets):
|
||||
for j, offset in enumerate(offsets):
|
||||
selected = selected and index[j] >= offset and index[
|
||||
j] < crop_shape[j] + offset
|
||||
if selected:
|
||||
result.append(value)
|
||||
return np.array(result).reshape(crop_shape)
|
||||
|
||||
|
||||
class TestCropOp(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "crop"
|
||||
self.crop_by_input = False
|
||||
self.attrs = {}
|
||||
self.initTestCase()
|
||||
self.attrs['offsets'] = self.offsets
|
||||
if self.crop_by_input:
|
||||
self.inputs = {
|
||||
'X': np.random.random(self.x_shape).astype("float32"),
|
||||
'Y': np.random.random(self.crop_shape).astype("float32")
|
||||
}
|
||||
else:
|
||||
self.attrs['shape'] = self.crop_shape
|
||||
self.inputs = {
|
||||
'X': np.random.random(self.x_shape).astype("float32"),
|
||||
}
|
||||
self.outputs = {
|
||||
'Out': crop(self.inputs['X'], self.offsets, self.crop_shape)
|
||||
}
|
||||
|
||||
def initTestCase(self):
|
||||
self.x_shape = (8, 8)
|
||||
self.crop_shape = (2, 2)
|
||||
self.offsets = [1, 2]
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad_normal(self):
|
||||
self.check_grad(['X'], 'Out', max_relative_error=0.006)
|
||||
|
||||
|
||||
class TestCase1(TestCropOp):
|
||||
def initTestCase(self):
|
||||
self.x_shape = (16, 8, 32)
|
||||
self.crop_shape = [2, 2, 3]
|
||||
self.offsets = [1, 5, 3]
|
||||
|
||||
|
||||
class TestCase2(TestCropOp):
|
||||
def initTestCase(self):
|
||||
self.x_shape = (4, 8)
|
||||
self.crop_shape = [4, 8]
|
||||
self.offsets = [0, 0]
|
||||
|
||||
|
||||
class TestCase3(TestCropOp):
|
||||
def initTestCase(self):
|
||||
self.x_shape = (4, 8, 16)
|
||||
self.crop_shape = [2, 2, 3]
|
||||
self.offsets = [1, 5, 3]
|
||||
self.crop_by_input = True
|
||||
|
||||
|
||||
class TestCase4(TestCropOp):
|
||||
def initTestCase(self):
|
||||
self.x_shape = (4, 4)
|
||||
self.crop_shape = [4, 4]
|
||||
self.offsets = [0, 0]
|
||||
self.crop_by_input = True
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -0,0 +1,32 @@
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
|
||||
|
||||
class TestRankLossOp(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "rank_loss"
|
||||
batch_size = 5
|
||||
# labels_{i} = {0, 1.0} or {0, 0.5, 1.0}
|
||||
label = np.random.randint(0, 2, size=(batch_size, 1)).astype("float32")
|
||||
left = np.random.random((batch_size, 1)).astype("float32")
|
||||
right = np.random.random((batch_size, 1)).astype("float32")
|
||||
loss = np.log(1.0 + np.exp(left - right)) - label * (left - right)
|
||||
self.inputs = {'Label': label, 'Left': left, 'Right': right}
|
||||
self.outputs = {'Out': loss}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(["Left", "Right"], "Out")
|
||||
|
||||
def test_check_grad_ignore_left(self):
|
||||
self.check_grad(["Right"], "Out", no_grad_set=set('Left'))
|
||||
|
||||
def test_check_grad_ignore_right(self):
|
||||
self.check_grad(["Left"], "Out", no_grad_set=set('Right'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,22 +0,0 @@
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
|
||||
|
||||
class TestSigmoidOp(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "sigmoid"
|
||||
self.inputs = {
|
||||
'X': np.random.uniform(0.1, 1, [11, 17]).astype("float32")
|
||||
}
|
||||
self.outputs = {'Y': 1 / (1 + np.exp(-self.inputs['X']))}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_check_grad(self):
|
||||
self.check_grad(["X"], "Y", max_relative_error=0.007)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Loading…
Reference in new issue