-
Notifications
You must be signed in to change notification settings - Fork 5.6k
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Add nce op #5480
Add nce op #5480
Changes from 5 commits
3d27627
c2dd75b
09d32b0
668dc53
e60eb1e
ea7359c
d0246e2
ab9d59c
76a65a8
29262ab
File filter
Filter by extension
Conversations
Jump to
Diff view
Diff view
There are no files selected for viewing
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,159 @@ | ||
/* 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/nce_op.h" | ||
|
||
namespace paddle { | ||
namespace operators { | ||
|
||
using framework::Tensor; | ||
|
||
class NCEOp : public framework::OperatorWithKernel { | ||
public: | ||
using framework::OperatorWithKernel::OperatorWithKernel; | ||
|
||
void InferShape(framework::InferShapeContext* ctx) const override { | ||
PADDLE_ENFORCE(ctx->HasInput("Input")); | ||
PADDLE_ENFORCE(ctx->HasInput("Label")); | ||
PADDLE_ENFORCE(ctx->HasInput("Weight")); | ||
PADDLE_ENFORCE(ctx->HasOutput("Cost")); | ||
PADDLE_ENFORCE(ctx->HasOutput("SampleLogits")); | ||
PADDLE_ENFORCE(ctx->HasOutput("SampleLabels")); | ||
|
||
auto x_dims = ctx->GetInputDim("Input"); | ||
auto label_dims = ctx->GetInputDim("Label"); | ||
PADDLE_ENFORCE_EQ(x_dims[0], label_dims[0]); | ||
int num_true_classes = label_dims.size() == 2 ? label_dims[1] : 1; | ||
if (ctx->HasInput("Bias")) { | ||
PADDLE_ENFORCE_EQ(ctx->GetInputDim("Weight")[0], | ||
ctx->GetInputDim("Bias")[0]); | ||
} | ||
auto num_sampled_classes = ctx->Attrs().Get<int>("num_sampled_classes"); | ||
auto num_classes = ctx->Attrs().Get<int>("num_classes"); | ||
std::vector<int> sampled_labels = | ||
ctx->Attrs().Get<std::vector<int>>("sampled_labels"); | ||
PADDLE_ENFORCE_EQ(num_classes, ctx->GetInputDim("Weight")[0]); | ||
PADDLE_ENFORCE_LT(num_sampled_classes, num_classes); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. If There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more.
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. 我还是先去掉这个checking吧 |
||
if (sampled_labels.size() > 0) { | ||
PADDLE_ENFORCE_EQ(sampled_labels.size(), | ||
static_cast<size_t>(num_sampled_classes)); | ||
} | ||
// set dims of output(Out) | ||
std::vector<int64_t> out_dims; | ||
out_dims.push_back(x_dims[0]); | ||
ctx->SetOutputDim("Cost", framework::make_ddim(out_dims)); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. The output shape is [batch_size, 1] in smooth_l1, cos_sim, sequared_l2_distance, softmax_with_cross_entropy, and this can be discussed and unified later. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
|
||
// set dims of output(SampleOut) | ||
std::vector<int64_t> sample_out_dims; | ||
sample_out_dims.push_back(x_dims[0]); | ||
sample_out_dims.push_back(num_sampled_classes + num_true_classes); | ||
ctx->SetOutputDim("SampleLogits", framework::make_ddim(sample_out_dims)); | ||
ctx->SetOutputDim("SampleLabels", framework::make_ddim(sample_out_dims)); | ||
} | ||
|
||
protected: | ||
framework::OpKernelType GetKernelType( | ||
const framework::ExecutionContext& ctx) const override { | ||
return framework::OpKernelType( | ||
framework::ToDataType(ctx.Input<Tensor>("Input")->type()), | ||
ctx.device_context()); | ||
} | ||
}; | ||
|
||
class NCEOpMaker : public framework::OpProtoAndCheckerMaker { | ||
public: | ||
NCEOpMaker(framework::OpProto* proto, framework::OpAttrChecker* op_checker) | ||
: OpProtoAndCheckerMaker(proto, op_checker) { | ||
AddInput("Input", "(Tensor) A tensor of shape [batch_size, dim]."); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. I have a question here. From the current implementation, this operator only supports uniform distribution which is hardcoded. How can we extend the codes to support more distribution? Should we make distribution method an attribute, or leave the sampling process outside this operator? What is your suggestion? There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Yes. You are right. More distribution sampler is necessary. The terms in NLP application always meet heavy-tailed distribution. So we need a long uniform distribution sampler. And the distribution`s PDF is 1/(x+1)lnR in which R is the range of sampling. I will implement the log uniform sampler and other common distribution samplers as independent math function in another pr. |
||
AddInput("Label", | ||
"(Tensor) A tensor of shape [batch_size, num_true_class]. " | ||
"'num_true_class' is the number of target class in each sample."); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Is this used for multi-label and must all samples have the same label number. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. It would be useful to allow a variable number of target classes per example. For now, if you have a variable number of target classes, you can pad them out to a constant number by either repeating them or by padding with an otherwise unused class. |
||
AddInput("Weight", | ||
"(Tensor) A tensor of shape [num_class, dim]. 'num_class' is the " | ||
"total number of class."); | ||
AddInput("Bias", | ||
"(Tensor) A tensor of shape [num_class]. 'num_class' is the total " | ||
"number of class. It is a dispensable input.") | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. I remember we have discussed before and decide to use the 2-dimensional tensor to represent a vector to distinguish it is a row vector or a column vector explicitly. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
.AsDispensable(); | ||
AddInput("SampleWeight", | ||
"(Tensor) A tensor of shape [batch_size] storing a weight for " | ||
"each sample. And it is a dispensable input. The default value of " | ||
"sample is 1.") | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. The same problem as There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
.AsDispensable(); | ||
AddOutput("Cost", | ||
"(Tensor) A tensor of shape [batch_size]. Cost of samples."); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. The same problem as Input(Bias) about tensor's shape. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
AddOutput("SampleLogits", "An intermediate tensor.").AsIntermediate(); | ||
AddOutput("SampleLabels", "An intermediate tensor.").AsIntermediate(); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Comments on There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed by adding more comments. |
||
AddAttr<int>("num_classes", "Total number of classes."); | ||
AddAttr<int>("num_sampled_classes", "The number of negative classes.") | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Might There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Agree with @guoshengCS . But maybe can use There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Renamed |
||
.SetDefault(10); | ||
AddAttr<std::vector<int>>("sampled_labels", ""); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. This attribute lacks comments. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
AddComment(R"DOC( | ||
Computes and returns the noise-contrastive estimation training loss. | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Compute and return There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
See [Noise-contrastive estimation: A new estimation principle for unnormalized statistical models](http://www.jmlr.org/proceedings/papers/v9/gutmann10a/gutmann10a.pdf). | ||
By default this uses a uniform distribution for sampling. | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. this --> this operator. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
The number of target classes per example should be same. If you have a variable number of target classes, you can pad them out to a constant number by either repeating them or by padding with an otherwise unused class. | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more.
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more.
|
||
)DOC"); | ||
} | ||
}; | ||
|
||
class NCEOpGrad : public framework::OperatorWithKernel { | ||
public: | ||
using framework::OperatorWithKernel::OperatorWithKernel; | ||
|
||
void InferShape(framework::InferShapeContext* ctx) const override { | ||
PADDLE_ENFORCE(ctx->HasInput("Input")); | ||
PADDLE_ENFORCE(ctx->HasInput("Weight")); | ||
PADDLE_ENFORCE(ctx->HasInput("Cost")); | ||
PADDLE_ENFORCE(ctx->HasInput("SampleLogits")); | ||
PADDLE_ENFORCE(ctx->HasInput("SampleLabels")); | ||
PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Cost")), | ||
"The input(Out@GRAD) should not be null"); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. If the comment is a complete sentence, please add a period at the end of the sentence. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
|
||
auto x_dims = ctx->GetInputDim("Input"); | ||
auto x_grad_name = framework::GradVarName("Input"); | ||
if (ctx->HasOutput(x_grad_name)) { | ||
ctx->SetOutputDim(x_grad_name, x_dims); | ||
} | ||
|
||
auto w_dims = ctx->GetInputDim("Weight"); | ||
auto w_grad_name = framework::GradVarName("Weight"); | ||
if (ctx->HasOutput(w_grad_name)) { | ||
ctx->SetOutputDim(w_grad_name, w_dims); | ||
} | ||
|
||
auto bias_grad_name = framework::GradVarName("Bias"); | ||
if (ctx->HasOutput(bias_grad_name)) { | ||
auto bias_dims = ctx->GetInputDim("Bias"); | ||
ctx->SetOutputDim(bias_grad_name, bias_dims); | ||
} | ||
} | ||
|
||
protected: | ||
framework::OpKernelType GetKernelType( | ||
const framework::ExecutionContext& ctx) const override { | ||
return framework::OpKernelType( | ||
framework::ToDataType(ctx.Input<Tensor>("Input")->type()), | ||
ctx.device_context()); | ||
} | ||
}; | ||
|
||
} // namespace operators | ||
} // namespace paddle | ||
|
||
namespace ops = paddle::operators; | ||
REGISTER_OP(nce, ops::NCEOp, ops::NCEOpMaker, nce_grad, ops::NCEOpGrad); | ||
REGISTER_OP_CPU_KERNEL(nce, ops::NCEKernel<paddle::platform::CPUPlace, float>); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Here also register a kernel for type double. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
REGISTER_OP_CPU_KERNEL(nce_grad, | ||
ops::NCEGradKernel<paddle::platform::CPUPlace, float>); |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,209 @@ | ||
/* 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. */ | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. The indentation should like that in nce_op.cc |
||
|
||
#pragma once | ||
|
||
#include <math.h> | ||
#include <random> | ||
#include "paddle/framework/eigen.h" | ||
#include "paddle/framework/op_registry.h" | ||
#include "unsupported/Eigen/CXX11/Tensor" | ||
namespace paddle { | ||
namespace operators { | ||
|
||
using Tensor = framework::Tensor; | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. using framework::Tensor; There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
|
||
template <typename T, int MajorType = Eigen::RowMajor, | ||
typename IndexType = Eigen::DenseIndex> | ||
using EigenMatrix = framework::EigenMatrix<T, MajorType, IndexType>; | ||
|
||
template <typename Place, typename T> | ||
void PrepareSamples(const framework::ExecutionContext& context) { | ||
auto label = context.Input<Tensor>("Label"); | ||
const int64_t* label_data = label->data<int64_t>(); | ||
auto label_dims = label->dims(); | ||
int num_classes = context.Attr<int>("num_classes"); | ||
// for unitest | ||
std::vector<int> sampled_labels = | ||
context.Attr<std::vector<int>>("sampled_labels"); | ||
// random machine | ||
std::random_device rd; | ||
std::mt19937 rng(rd()); | ||
std::uniform_int_distribution<int> rand(0, num_classes - 1); | ||
|
||
auto sample_labels = context.Output<Tensor>("SampleLabels"); | ||
auto sample_labels_dims = sample_labels->dims(); | ||
int64_t* sample_labels_data = | ||
sample_labels->mutable_data<int64_t>(context.GetPlace()); | ||
|
||
int num_label = label_dims.size() == 2 ? label_dims[1] : 1; | ||
int index = 0; | ||
for (size_t i = 0; i < label_dims[0]; ++i) { | ||
int j = 0; | ||
for (; j < num_label; ++j) { | ||
sample_labels_data[index++] = label_data[i * num_label + j]; | ||
} | ||
if (sampled_labels.size() > 0) { | ||
for (auto label : sampled_labels) { | ||
sample_labels_data[index++] = label; | ||
} | ||
} else { | ||
for (; j < sample_labels_dims[1]; ++j) { | ||
sample_labels_data[index++] = rand(rng); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. It seems that uniform distribution is the only supported temporarily. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Done. |
||
} | ||
} | ||
} | ||
} | ||
|
||
template <typename Place, typename T> | ||
class NCEKernel : public framework::OpKernel<T> { | ||
public: | ||
void Compute(const framework::ExecutionContext& context) const override { | ||
PrepareSamples<Place, T>(context); | ||
auto sample_labels = context.Output<Tensor>("SampleLabels"); | ||
const int64_t* sample_labels_data = sample_labels->data<int64_t>(); | ||
auto sample_out = context.Output<Tensor>("SampleLogits"); | ||
T* sample_out_data = sample_out->mutable_data<T>(context.GetPlace()); | ||
auto label = context.Input<Tensor>("Label"); | ||
auto sample_weight = context.Input<Tensor>("SampleWeight"); | ||
const T* sample_weight_data = nullptr; | ||
if (sample_weight != nullptr) { | ||
sample_weight_data = sample_weight->data<T>(); | ||
} | ||
auto out = context.Output<Tensor>("Cost"); | ||
T* out_data = out->mutable_data<T>(context.GetPlace()); | ||
int num_smalped_classes = context.Attr<int>("num_sampled_classes"); | ||
int num_classes = context.Attr<int>("num_classes"); | ||
int num_true_class = 1; | ||
if (label != nullptr) { | ||
num_true_class = label->dims()[1]; | ||
} | ||
T b = 1. / num_classes * num_smalped_classes; | ||
// forward bias | ||
auto bias = context.Input<Tensor>("Bias"); | ||
if (bias != nullptr) { | ||
const T* bias_data = bias->data<T>(); | ||
for (size_t i = 0; i < sample_labels->numel(); ++i) { | ||
sample_out_data[i] = bias_data[sample_labels_data[i]]; | ||
} | ||
} else { | ||
for (size_t i = 0; i < sample_labels->numel(); ++i) { | ||
sample_out_data[i] = 0; | ||
} | ||
} | ||
// forward mul | ||
auto input_mat = EigenMatrix<T>::From(*(context.Input<Tensor>("Input"))); | ||
auto weight_mat = EigenMatrix<T>::From(*(context.Input<Tensor>("Weight"))); | ||
for (size_t i = 0; i < sample_labels->numel(); ++i) { | ||
Eigen::Tensor<float, 0, Eigen::RowMajor, Eigen::DenseIndex> result = | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Can There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more.
|
||
(input_mat.chip((int)(i / sample_labels->dims()[1]), 0) * | ||
weight_mat.chip(sample_labels_data[i], 0)) | ||
.sum(); | ||
sample_out_data[i] += result(0); | ||
// activation_->forward | ||
sample_out_data[i] = (1. / (1. + exp(-sample_out_data[i]))); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Maybe only output values of positive samples are needed to compute, and some computation can be reduced in future. |
||
} | ||
// forward cost | ||
for (size_t i = 0; i < sample_labels->dims()[0]; ++i) { | ||
size_t j = 0; | ||
out_data[i] = 0; | ||
T w = sample_weight == nullptr ? 1. : sample_weight_data[i]; | ||
// for true classes | ||
for (; j < num_true_class; ++j) { | ||
T o = sample_out_data[i * sample_out->dims()[1] + j]; | ||
T cost = -log(o / (o + b)); | ||
out_data[i] += w * cost; | ||
} | ||
// for sampled neg classes | ||
for (; j < sample_labels->dims()[1]; ++j) { | ||
T o = sample_out_data[i * sample_out->dims()[1] + j]; | ||
T cost = -log(b / (o + b)); | ||
out_data[i] += w * cost; | ||
} | ||
} | ||
} | ||
}; | ||
|
||
template <typename Place, typename T> | ||
class NCEGradKernel : public framework::OpKernel<T> { | ||
public: | ||
void Compute(const framework::ExecutionContext& context) const override { | ||
auto d_out = context.Input<Tensor>(framework::GradVarName("Cost")); | ||
const T* d_out_data = d_out->data<T>(); | ||
auto label = context.Input<Tensor>("Label"); | ||
auto sample_out = context.Input<Tensor>("SampleLogits"); | ||
const T* sample_out_data = sample_out->data<T>(); | ||
auto sample_labels = context.Input<Tensor>("SampleLabels"); | ||
const int64_t* sample_labels_data = sample_labels->data<int64_t>(); | ||
auto sample_weight = context.Input<Tensor>("SampleWeight"); | ||
const T* sample_weight_data = nullptr; | ||
if (sample_weight != nullptr) { | ||
sample_weight_data = sample_weight->data<T>(); | ||
} | ||
int num_smalped_classes = context.Attr<int>("num_sampled_classes"); | ||
int num_classes = context.Attr<int>("num_classes"); | ||
int num_true_class = 1; | ||
if (label != nullptr) { | ||
num_true_class = label->dims()[1]; | ||
} | ||
T b = 1. / num_classes * num_smalped_classes; | ||
Tensor sample_grad; // tmp tensor | ||
T* sample_grad_data = | ||
sample_grad.mutable_data<T>(sample_labels->dims(), context.GetPlace()); | ||
// backward cost | ||
for (size_t i = 0; i < sample_labels->numel(); ++i) { | ||
T o = sample_out_data[i]; | ||
T w = sample_weight == nullptr | ||
? 1 | ||
: sample_weight_data[i / sample_labels->dims()[1]]; | ||
sample_grad_data[i] = (i % sample_labels->dims()[1]) < num_true_class | ||
? w * (b / (o + b)) * (o - 1) | ||
: w * (o * (1 - o) / (o + b)); | ||
sample_grad_data[i] *= d_out_data[i / sample_labels->dims()[1]]; | ||
} | ||
// get d_bias | ||
auto d_bias = context.Output<Tensor>(framework::GradVarName("Bias")); | ||
if (d_bias != nullptr) { | ||
T* d_bias_data = d_bias->mutable_data<T>(context.GetPlace()); | ||
for (size_t i = 0; i < sample_labels->numel(); ++i) { | ||
d_bias_data[sample_labels_data[i]] += sample_grad_data[i]; | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. I am not sure if the grad_data should be clear to zero first. There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Fixed. |
||
} | ||
} | ||
// get d_w | ||
auto d_w = context.Output<Tensor>(framework::GradVarName("Weight")); | ||
if (d_w != nullptr) { | ||
d_w->mutable_data<T>(context.GetPlace()); | ||
auto d_w_matrix = EigenMatrix<T>::From(*d_w); | ||
auto x_matrix = EigenMatrix<T>::From(*(context.Input<Tensor>("Input"))); | ||
for (size_t i = 0; i < sample_labels->numel(); ++i) { | ||
d_w_matrix.chip(sample_labels_data[i], 0) += | ||
x_matrix.chip((int)(i / sample_labels->dims()[1]), 0) * | ||
sample_grad_data[i]; | ||
} | ||
} | ||
// get d_x | ||
auto d_x = context.Output<Tensor>(framework::GradVarName("Input")); | ||
if (d_x != nullptr) { | ||
d_x->mutable_data<T>(context.GetPlace()); | ||
auto d_x_matrix = EigenMatrix<T>::From(*d_x); | ||
auto w_matrix = EigenMatrix<T>::From(*(context.Input<Tensor>("Weight"))); | ||
for (size_t i = 0; i < sample_labels->numel(); ++i) { | ||
d_x_matrix.chip((int)(i / sample_labels->dims()[1]), 0) += | ||
w_matrix.chip(sample_labels_data[i], 0) * sample_grad_data[i]; | ||
} | ||
} | ||
} | ||
}; | ||
} // namespace operators | ||
} // namespace paddle |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Please make the indention of license follows that in
accuracy_op.h
.There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Fixed.