From ca9be82f6c45691b6661a4be54a05a369f579295 Mon Sep 17 00:00:00 2001 From: qijun Date: Wed, 30 Aug 2017 13:05:33 +0800 Subject: [PATCH 01/62] add how to use eigen cn doc --- doc/howto/dev/new_op_cn.md | 7 +- doc/howto/dev/use_eigen_cn.md | 140 ++++++++++++++++++++++++++++++++++ 2 files changed, 146 insertions(+), 1 deletion(-) create mode 100644 doc/howto/dev/use_eigen_cn.md diff --git a/doc/howto/dev/new_op_cn.md b/doc/howto/dev/new_op_cn.md index ebd2cf3ff0..55c99fa7af 100644 --- a/doc/howto/dev/new_op_cn.md +++ b/doc/howto/dev/new_op_cn.md @@ -169,6 +169,8 @@ class MulKernel : public framework::OpKernel { `MulKernel`需要重写`Compute`接口，该接口参数为`const framework::ExecutionContext& context`, `ExecutionContext`相比`InferShapeContext`增加了设备类型，同样可获取到输入输出和属性参数，`Compute`函数里写具体实现时。 注意，不同设备(CPU、GPU)共享一个Op定义，是否则共享同一个`OpKernel`，取决于`Compute`调用的函数是否支持不同设备。`MulOp`的CPU、GPU实现共享同一个`Kernel`，`OpKernel`不共享的例子可以参考[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 + +为了使得`OpKernel`的计算过程书写较为简单，CPU、GPU的代码可以复用，我们通常借助Eigen unsupported Tensor模块来实现。关于在paddle中如何使用Eigen库，请参考对应的使用[文档](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/howto/dev/use_eigen_cn.md) 到此前向Op实现完成，需要在`.cc`文件中注册该op和kernel。反向Op类的定义和Kernel定义与前向Op类似，这里不再重复。但注意，反向Op没有`ProtoMaker`。 @@ -188,9 +190,12 @@ REGISTER_OP_CPU_KERNEL(mul_grad, - `REGISTER_OP_WITHOUT_GRADIENT` ： 用于注册没有反向的Op。 - `REGISTER_OP_CPU_KERNEL` ：注册`ops::MulKernel`类，并特化模板参数为`paddle::platform::CPUPlace`和`float`类型，同理，注册`ops::MulKernel`类。 -在 `.cu`文件中注册GPU Kernel。 +在 `.cu`文件中注册GPU Kernel。请注意，如果GPU Kernel的实现是基于Eigen unsupported模块，那么在 `.cu`的最前面请加上宏定义 `#define EIGEN_USE_GPU` ```c++ +// if use Eigen unsupported module before include head files +#define EIGEN_USE_GPU + namespace ops = paddle::operators; REGISTER_OP_GPU_KERNEL(mul, ops::MulKernel); REGISTER_OP_GPU_KERNEL(mul_grad, diff --git a/doc/howto/dev/use_eigen_cn.md b/doc/howto/dev/use_eigen_cn.md new file mode 100644 index 0000000000..d22ff4799c --- /dev/null +++ b/doc/howto/dev/use_eigen_cn.md @@ -0,0 +1,140 @@ +## 在Paddle中如何使用Eigen + +神经网络本质上是一个计算图，计算需要的数据存放在`Tensor`中，而计算过程是由`Operartor`来描述的。在执行时，`Operator`调用对应`OpKernel`中的`Compute`接口，实现对`Tensor`的操作。 + + +### Eigen Tensor模块 + +Eigen Tensor模块对element-wise计算提供了强大的支持，并且书写一份代码，可以同时在CPU、GPU执行。但Eigen Tensor是一个正在开发中的模块，因此可能测试不够完备，文档较少。 + +关于Eigen Tensor模块的详细介绍请参考[文档](https://github.com/RLovelett/eigen/blob/master/unsupported/Eigen/CXX11/src/Tensor/README.md) + + +### paddle::framework::Tensor + +Paddle Tensor定义在framework目录下，其主要接口如下： + +``` +class Tensor { + public: + /*! Return a pointer to mutable memory block. */ + template + inline T* data(); + + /** + * @brief Return a pointer to mutable memory block. + * @note If not exist, then allocation. + */ + template + inline T* mutable_data(platform::Place place); + + /** + * @brief Return a pointer to mutable memory block. + * + * @param[in] dims The dimensions of the memory block. + * @param[in] place The place of the memory block. + * + * @note If not exist, then allocation. + */ + template + inline T* mutable_data(DDim dims, platform::Place place); + + /*! Resize the dimensions of the memory block. */ + inline Tensor& Resize(const DDim& dims); + + /*! Return the dimensions of the memory block. */ + inline const DDim& dims() const; + + private: + /*! holds the memory block if allocated. */ + std::shared_ptr holder_; + + /*! points to dimensions of memory block. */ + DDim dim_; +}; +``` + +`Placeholder`的作用的延迟分配内存，即我们可以先定义一个Tensor，然后使用Resize接口设置Tensor的大小，最后再调用mutable_data接口分配实际的内存。 + +``` +paddle::framework::Tensor t; +paddle::platform::CPUPlace place; +// set size first +t.Resize({2, 3}); +// allocate memory on CPU later +t.mutable_data(place); +``` + +下面以AddOp为例说明Tensor的使用过程： + +- InferShape + +在运行神经网络计算图时，我们先调用每个`Operator`的`InferShape`接口，根据输入Tensor的大小来设置输出Tensor的大小，`Resize`接口会被调用。 + +``` +void InferShape(const framework::InferShapeContext &ctx) const override { + PADDLE_ENFORCE_EQ(ctx.Input("X")->dims(), + ctx.Input("Y")->dims(), + "Two input of Add Op's dimension must be same."); + ctx.Output("Out")->Resize(ctx.Input("X")->dims()); +} +``` + + +- Run + +`Operator`的`Run`接口最终会调用对应`OpKernel`的`Compute`接口，在这时真正的分配内存，`mutable_data`接口会被调用。 + +``` +void Compute(const framework::ExecutionContext& context) const override { + auto* input0 = context.Input("X"); + auto* input1 = context.Input("Y"); + auto* output = context.Output("Out"); + + output->mutable_data(context.GetPlace()); + + auto X = EigenVector::Flatten(*input0); + auto Y = EigenVector::Flatten(*input1); + auto Z = EigenVector::Flatten(*output); + + auto place = context.GetEigenDevice(); + + Z.device(place) = X + Y; +} +``` + + +### paddle::framework::Tensor到EigenTensor的转换 + +如上一小节所示，在具体的计算中，我们需要先把输入Tensor和输出Tensor转换为Eigen支持的格式。我们在[eigen.h](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/eigen.h)中提供了一些全局函数用来实现paddle::framework::Tensor到EigenTensor/EigenMatrix/EigenVector/EigenScalar的转换。 + +以EigenTensor为例，做一个介绍 + +``` +Tensor t; +float* p = t.mutable_data(make_ddim({1, 2, 3}), platform::CPUPlace()); +for (int i = 0; i < 1 * 2 * 3; i++) { + p[i] = static_cast(i); +} + +EigenTensor::Type et = EigenTensor::From(t); +``` + +From是EigenTensor模板struct提供的一个接口，可以实现从paddle::framework::Tensor到对EigenTensor的转换。由于Tensor的rank是模板参数，因此在转换时需要显示的指定。 + +需要额外注意的是，EigenVector::From方法是把paddle中的一维Tensor转为Eigen的一维Tensor，在这里用EigenVector来表示；而EigenVector::Flatten方法是把paddle中的一个Tensor进行reshape操作，压扁成为Eigen的一维Tensor，类型仍然为EigenVector。 + +更多的转换方法请参考eigen_test.cc中的[单元测试](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/eigen_test.cc)。 + + + +### 实现计算 + +当需要完成计算时，我们需要等式左边的EigenTensor调用device接口： + +``` +auto place = context.GetEigenDevice(); +Z.device(place) = X + Y; +``` + +由于Eigen Tensor模块的文档较少，我们可以参考TensorFlow的[kernels](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/core/kernels)模块下的相关`OpKernel`的计算代码。 From 1dfc5d87ff4b4f40272e387d598a1bec5477d127 Mon Sep 17 00:00:00 2001 From: qijun Date: Wed, 30 Aug 2017 17:06:16 +0800 Subject: [PATCH 02/62] add more details --- doc/howto/dev/use_eigen_cn.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/doc/howto/dev/use_eigen_cn.md b/doc/howto/dev/use_eigen_cn.md index d22ff4799c..49a726959a 100644 --- a/doc/howto/dev/use_eigen_cn.md +++ b/doc/howto/dev/use_eigen_cn.md @@ -120,7 +120,7 @@ for (int i = 0; i < 1 * 2 * 3; i++) { EigenTensor::Type et = EigenTensor::From(t); ``` -From是EigenTensor模板struct提供的一个接口，可以实现从paddle::framework::Tensor到对EigenTensor的转换。由于Tensor的rank是模板参数，因此在转换时需要显示的指定。 +From是EigenTensor模板提供的一个接口，可以实现从paddle::framework::Tensor到对EigenTensor的转换。由于Tensor的rank是模板参数，因此在转换时需要显示的指定。 需要额外注意的是，EigenVector::From方法是把paddle中的一维Tensor转为Eigen的一维Tensor，在这里用EigenVector来表示；而EigenVector::Flatten方法是把paddle中的一个Tensor进行reshape操作，压扁成为Eigen的一维Tensor，类型仍然为EigenVector。 @@ -130,11 +130,16 @@ From是EigenTensor模板struct提供的一个接口，可以实现从paddle::fra ### 实现计算 -当需要完成计算时，我们需要等式左边的EigenTensor调用device接口： +当需要完成计算时，我们需要等式左边的EigenTensor调用device接口。在这里需要注意的是，这里的EigenTensor之间的运算只是改变了原有Tensor中的数据，而不会改变原有Tensor的shape信息。 ``` +auto X = EigenVector::Flatten(*input0); +auto Y = EigenVector::Flatten(*input1); +auto Z = EigenVector::Flatten(*output); auto place = context.GetEigenDevice(); Z.device(place) = X + Y; ``` +在这段代码中，input0/input1/output可以是任意维度的Tensor。我们调用了EigenVector的Flatten接口，把任意维度的Tensor转为了一维的EigenVector。而在计算结束之后，input0/input1/output的原有shape信息不变。如果想改变原有Tensor的shape信息，可以调用Resize接口进行改变。 + 由于Eigen Tensor模块的文档较少，我们可以参考TensorFlow的[kernels](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/core/kernels)模块下的相关`OpKernel`的计算代码。 From a4df3f5bd8917b2cb510b23dc63bc97a20108f23 Mon Sep 17 00:00:00 2001 From: yangyaming Date: Wed, 30 Aug 2017 22:21:53 +0800 Subject: [PATCH 03/62] Finish framework of squared_l2_distance_op. --- paddle/operators/CMakeLists.txt | 2 + paddle/operators/squared_l2_distance_op.cc | 82 ++++++++++++++++++ paddle/operators/squared_l2_distance_op.cu | 25 ++++++ paddle/operators/squared_l2_distance_op.h | 84 +++++++++++++++++++ paddle/pybind/CMakeLists.txt | 3 +- paddle/pybind/pybind.cc | 1 + .../paddle/v2/framework/tests/CMakeLists.txt | 1 + .../paddle/v2/framework/tests/op_test_util.py | 10 +-- .../tests/test_squared_l2_distance_op.py | 25 ++++++ 9 files changed, 227 insertions(+), 6 deletions(-) create mode 100644 paddle/operators/squared_l2_distance_op.cc create mode 100644 paddle/operators/squared_l2_distance_op.cu create mode 100644 paddle/operators/squared_l2_distance_op.h create mode 100644 python/paddle/v2/framework/tests/test_squared_l2_distance_op.py diff --git a/paddle/operators/CMakeLists.txt b/paddle/operators/CMakeLists.txt index f0fd12f1b5..1c32d1df4a 100644 --- a/paddle/operators/CMakeLists.txt +++ b/paddle/operators/CMakeLists.txt @@ -73,3 +73,5 @@ op_library(uniform_random_op SRCS uniform_random_op.cc uniform_random_op.cu) op_library(lookup_table_op SRCS lookup_table_op.cc lookup_table_op.cu) op_library(scale_op SRCS scale_op.cc scale_op.cu DEPS net_op) op_library(minus_op SRCS minus_op.cc minus_op.cu DEPS scale_op) + +op_library(squared_l2_distance_op SRCS squared_l2_distance_op.cc squared_l2_distance_op.cu) diff --git a/paddle/operators/squared_l2_distance_op.cc b/paddle/operators/squared_l2_distance_op.cc new file mode 100644 index 0000000000..9fc498d5a5 --- /dev/null +++ b/paddle/operators/squared_l2_distance_op.cc @@ -0,0 +1,82 @@ +/* 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/squared_l2_distance_op.h" + +namespace paddle { +namespace operators { + +class SquaredL2DistanceOp : 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 of SquaredL2DistanceOp " + "must be initialized."); + PADDLE_ENFORCE_EQ(ctx.Input("X")->dims(), + ctx.Input("Y")->dims(), + "Dimensions of SquaredL2DistanceOp's two inputs " + "must be same.") + framework::DDim dims = ctx.Input("X")->dims(); + ctx.Output("sub_result")->Resize(dims); + ctx.Output("Out")->Resize(framework::make_ddim({dims[0], 1})); + } +}; + +class SquaredL2DistanceOpMaker : public framework::OpProtoAndCheckerMaker { + public: + SquaredL2DistanceOpMaker(framework::OpProto *proto, + framework::OpAttrChecker *op_checker) + : OpProtoAndCheckerMaker(proto, op_checker) { + AddInput("X", "Input value."); + AddInput("Y", "Target value."); + AddOutput("sub_result", + "Buffering substraction result which " + "will be reused in backward.") + .AsIntermediate(); + AddOutput("Out", "Squared l2 distance between input and target."); + AddComment(R"DOC( + SquaredL2DistanceOp will cacluate the squared L2 distances for + input and target. Number of distance value equals to the + first dimension of input. + )DOC"); + } +}; + +class SquaredL2DistanceGradOp : public framework::OperatorWithKernel { + public: + using framework::OperatorWithKernel::OperatorWithKernel; + + protected: + void InferShape(const framework::InferShapeContext &ctx) const override { + ctx.Output(framework::GradVarName("X")) + ->Resize(ctx.Input("X")->dims()); + } +}; + +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; +REGISTER_OP(squared_l2_distance, ops::SquaredL2DistanceOp, + ops::SquaredL2DistanceOpMaker, squared_l2_distance_grad, + ops::SquaredL2DistanceGradOp); +REGISTER_OP_CPU_KERNEL( + squared_l2_distance, + ops::SquaredL2DistanceKernel); +REGISTER_OP_CPU_KERNEL( + squared_l2_distance_grad, + ops::SquaredL2DistanceGradKernel); diff --git a/paddle/operators/squared_l2_distance_op.cu b/paddle/operators/squared_l2_distance_op.cu new file mode 100644 index 0000000000..3fe62f1a9c --- /dev/null +++ b/paddle/operators/squared_l2_distance_op.cu @@ -0,0 +1,25 @@ +/* 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/squared_l2_distance_op.h" + +namespace ops = paddle::operators; +REGISTER_OP_GPU_KERNEL( + squared_l2_distance, + ops::SquaredL2DistanceKernel); +REGISTER_OP_GPU_KERNEL( + squared_l2_distance_grad, + ops::SquaredL2DistanceGradKernel); diff --git a/paddle/operators/squared_l2_distance_op.h b/paddle/operators/squared_l2_distance_op.h new file mode 100644 index 0000000000..b350fd0117 --- /dev/null +++ b/paddle/operators/squared_l2_distance_op.h @@ -0,0 +1,84 @@ +/* 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 +using EigenMatrix = framework::EigenMatrix; +template +using EigenVector = framework::EigenVector; + +template +class SquaredL2DistanceKernel : public framework::OpKernel { + public: + void Compute(const framework::ExecutionContext& context) const override { + auto* input0 = context.Input("X"); + auto* input1 = context.Input("Y"); + auto* output0 = context.Output("sub_result"); + auto* output1 = context.Output("Out"); + + output0->mutable_data(context.GetPlace()); + output1->mutable_data(context.GetPlace()); + + auto X = EigenMatrix::From(*input0); + auto Y = EigenMatrix::From(*input1); + auto subResult = EigenMatrix::From(*output0); + auto Z = EigenMatrix::From(*output1); + + auto place = context.GetEigenDevice(); + // buffer the substraction result + subResult.device(place) = X - Y; + const auto& inDims = X.dimensions(); + const auto& subResMat = subResult.reshape(Eigen::array( + {static_cast(inDims[0]), static_cast(X.size() / inDims[0])})); + Z.device(place) = subResMat.pow(2).sum(Eigen::array({1})); + } +}; + +template +class SquaredL2DistanceGradKernel : public framework::OpKernel { + public: + void Compute(const framework::ExecutionContext& context) const override { + auto* input0 = context.Input("sub_result"); + auto* OG = context.Input(framework::GradVarName("Out")); + auto* IG = context.Output(framework::GradVarName("X")); + + IG->mutable_data(context.GetPlace()); + + auto subResult = EigenMatrix::From(*input0); + auto outGrad = EigenMatrix::From(*OG); + auto inGrad = EigenMatrix::From(*IG); + + const auto& subResDims = subResult.dimensions(); + int firstDim = static_cast(subResDims[0]); + int cols = subResult.size() / firstDim; + const auto subResMat = + subResult.reshape(Eigen::array({firstDim, cols})); + // create a matrix view for input gradient tensor + auto inGradMat = inGrad.reshape(Eigen::array({firstDim, cols})); + inGradMat.device(context.GetEigenDevice()) = + 2 * (outGrad.broadcast(Eigen::array({1, cols}))) * subResMat; + } +}; + +} // namespace operators +} // namespace paddle diff --git a/paddle/pybind/CMakeLists.txt b/paddle/pybind/CMakeLists.txt index 37e186a408..df8c2b37cf 100644 --- a/paddle/pybind/CMakeLists.txt +++ b/paddle/pybind/CMakeLists.txt @@ -18,5 +18,6 @@ cc_library(paddle_pybind SHARED fill_zeros_like_op lookup_table_op scale_op - minus_op) + minus_op + squared_l2_distance_op) endif(WITH_PYTHON) diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc index 3bc150ccb7..69a5f98a43 100644 --- a/paddle/pybind/pybind.cc +++ b/paddle/pybind/pybind.cc @@ -48,6 +48,7 @@ USE_OP_ITSELF(identity); USE_OP(minus); USE_CPU_ONLY_OP(gather); USE_CPU_ONLY_OP(scatter); +USE_OP(squared_l2_distance); namespace paddle { namespace framework { diff --git a/python/paddle/v2/framework/tests/CMakeLists.txt b/python/paddle/v2/framework/tests/CMakeLists.txt index 661ebd8964..06ff1f4a0c 100644 --- a/python/paddle/v2/framework/tests/CMakeLists.txt +++ b/python/paddle/v2/framework/tests/CMakeLists.txt @@ -32,3 +32,4 @@ py_test(test_gradient_checker SRCS test_gradient_checker.py) py_test(test_lookup_table SRCS test_lookup_table.py) py_test(test_scale_and_identity_op SRCS test_scale_and_identity_op.py) py_test(mnist SRCS mnist.py) +py_test(test_squared_l2_distance_op SRCS test_squared_l2_distance_op.py) diff --git a/python/paddle/v2/framework/tests/op_test_util.py b/python/paddle/v2/framework/tests/op_test_util.py index 3bc05a0fec..370f27eaf6 100644 --- a/python/paddle/v2/framework/tests/op_test_util.py +++ b/python/paddle/v2/framework/tests/op_test_util.py @@ -6,13 +6,13 @@ from paddle.v2.framework.op import Operator class OpTestMeta(type): """ Operator Test ClassMeta. - - It injects `test_all` method into user's OperatorTest class, to make Python + + It injects `test_all` method into user's OperatorTest class, to make Python unittest module run that method. - + The `test_all` read what value is stored in `self`. It use self's values to create and run a operator, and check whether that op is OK or not. - + See `test_add_two_op` for example usage. """ @@ -66,7 +66,7 @@ class OpTestMeta(type): self.assertTrue( numpy.allclose( actual, expect, atol=1e-05), - "output name: " + out_name + "has diff") + "output name: " + out_name + " has diff") obj.test_all = test_all return obj diff --git a/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py b/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py new file mode 100644 index 0000000000..eeddb5a3bf --- /dev/null +++ b/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py @@ -0,0 +1,25 @@ +import unittest +from op_test_util import OpTestMeta +from gradient_checker import GradientChecker, create_op +import numpy as np + + +class TestSquaredL2DistanceOp(unittest.TestCase): + __metaclass__ = OpTestMeta + + def setUp(self): + self.type = 'squared_l2_distance' + self.inputs = { + 'X': np.random.uniform(0.1, 1., (2, 3)).astype('float32'), + 'Y': np.random.uniform(0.1, 1., (2, 3)).astype('float32') + } + subRes = self.inputs['X'] - self.inputs['Y'] + output = subRes * subRes + self.outputs = { + 'sub_result': subRes, + 'Out': np.expand_dims(output.sum(1), 1) + } + + +if __name__ == '__main__': + unittest.main() From c20a01d67d928442a0b8fb187277906ddd54ea04 Mon Sep 17 00:00:00 2001 From: dangqingqing Date: Thu, 31 Aug 2017 11:26:59 +0800 Subject: [PATCH 04/62] Add cuDNN Wrapper. --- paddle/platform/CMakeLists.txt | 1 + paddle/platform/cudnn_helper.cc | 15 +++ paddle/platform/cudnn_helper.h | 215 ++++++++++++++++++++++++++++++++ paddle/platform/macros.h | 23 ++++ 4 files changed, 254 insertions(+) create mode 100644 paddle/platform/cudnn_helper.cc create mode 100644 paddle/platform/cudnn_helper.h create mode 100644 paddle/platform/macros.h diff --git a/paddle/platform/CMakeLists.txt b/paddle/platform/CMakeLists.txt index 120eb1e4af..ef722e984c 100644 --- a/paddle/platform/CMakeLists.txt +++ b/paddle/platform/CMakeLists.txt @@ -22,3 +22,4 @@ ENDIF() cc_library(device_context SRCS device_context.cc DEPS memory buddy_allocator system_allocator memory_block meta_data meta_cache place eigen3 ${GPU_CTX_DEPS}) nv_test(device_context_test SRCS device_context_test.cc DEPS device_context gpu_info) +nv_test(cudnn_helper SRCS cudnn_helper.cc) diff --git a/paddle/platform/cudnn_helper.cc b/paddle/platform/cudnn_helper.cc new file mode 100644 index 0000000000..764285e2ba --- /dev/null +++ b/paddle/platform/cudnn_helper.cc @@ -0,0 +1,15 @@ +/* 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/platform/cudnn_helper.h" diff --git a/paddle/platform/cudnn_helper.h b/paddle/platform/cudnn_helper.h new file mode 100644 index 0000000000..91047236a2 --- /dev/null +++ b/paddle/platform/cudnn_helper.h @@ -0,0 +1,215 @@ +/* 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 +#include "paddle/platform/dynload/cudnn.h" +#include "paddle/platform/enforce.h" +#include "paddle/platform/macros.h" + +namespace paddle { +namespace platform { + +enum class DataLayout { + kNHWC, + kNCHW, + kNCHW_VECT_C, +}; + +enum class PoolingMode { + kMaximum, + kAverage, +}; + +template +class CudnnDataType; + +template <> +class CudnnDataType { + public: + static const cudnnDataType_t type = CUDNN_DATA_FLOAT; + typedef const float ScalingParamType; + static ScalingParamType* kOne() { + static ScalingParamType v = 1.0; + return &v; + } + static const ScalingParamType* kZero() { + static ScalingParamType v = 0.0; + return &v; + } +}; + +template <> +class CudnnDataType { + public: + static const cudnnDataType_t type = CUDNN_DATA_DOUBLE; + typedef const double ScalingParamType; + static ScalingParamType* kOne() { + static ScalingParamType v = 1.0; + return &v; + } + static ScalingParamType* kZero() { + static ScalingParamType v = 0.0; + return &v; + } +}; + +inline cudnnTensorFormat_t GetCudnnTensorFormat(const DataLayout& order) { + switch (order) { + case DataLayout::kNHWC: + return CUDNN_TENSOR_NHWC; + case DataLayout::kNCHW: + return CUDNN_TENSOR_NCHW; + default: + PADDLE_THROW("Unknown cudnn equivalent for order"); + } + return CUDNN_TENSOR_NCHW; +} + +class ScopedTensorDescriptor { + public: + ScopedTensorDescriptor() { + PADDLE_ENFORCE(dynload::cudnnCreateTensorDescriptor(&desc_)); + } + ~ScopedTensorDescriptor() { + PADDLE_ENFORCE(dynload::cudnnDestroyTensorDescriptor(desc_)); + } + + inline cudnnTensorDescriptor_t descriptor(const cudnnTensorFormat_t format, + const cudnnDataType_t type, + const std::vector& dims) { + // the format is not used now, but it maybe useful feature + std::vector strides(dims.size()); + strides[dims.size() - 1] = 1; + for (int i = dims.size() - 1; i >= 0; i++) { + strides[i] = dims[i + 1] * strides[i]; + } + PADDLE_ENFORCE(cudnnSetTensorNdDescriptor(desc_, type, dims.size(), + dims.data(), strides.data())); + return desc_; + } + + template + inline cudnnTensorDescriptor_t descriptor(const DataLayout& order, + const std::vector& dims) { + return descriptor(GetCudnnTensorFormat(order), CudnnDataType::type, + dims); + } + + private: + cudnnTensorDescriptor_t desc_; + DISABLE_COPY_AND_ASSIGN(ScopedTensorDescriptor); +}; + +class ScopedFilterDescriptor { + public: + ScopedFilterDescriptor() { + PADDLE_ENFORCE(dynload::cudnnCreateFilterDescriptor(&desc_)); + } + ~ScopedFilterDescriptor() { + PADDLE_ENFORCE(dynload::cudnnDestroyFilterDescriptor(desc_)); + } + + inline cudnnFilterDescriptor_t descriptor(const cudnnTensorFormat_t format, + const cudnnDataType_t type, + const std::vector& kernel) { + // filter layout: output input spatial_dim_y spatial_dim_x + PADDLE_ENFORCE(cudnnSetFilterNdDescriptor(desc_, type, format, + kernel.size(), kernel.data())); + return desc_; + } + + template + inline cudnnFilterDescriptor_t descriptor(const DataLayout& order, + const std::vector& kernel) { + return descriptor(GetCudnnTensorFormat(order), CudnnDataType::type, + kernel); + } + + private: + cudnnFilterDescriptor_t desc_; + DISABLE_COPY_AND_ASSIGN(ScopedFilterDescriptor); +}; + +class ScopedConvolutionDescriptor { + public: + ScopedConvolutionDescriptor() { + PADDLE_ENFORCE(dynload::cudnnCreateConvolutionDescriptor(&desc_)); + } + ~ScopedConvolutionDescriptor() { + PADDLE_ENFORCE(dynload::cudnnDestroyConvolutionDescriptor(desc_)); + } + + inline cudnnConvolutionDescriptor_t descriptor( + cudnnDataType_t type, const std::vector& pads, + const std::vector& strides, const std::vector& dilations) { + PADDLE_ENFORCE_EQ(pads.size(), strides.size()); + PADDLE_ENFORCE_EQ(pads.size(), dilations.size()); + PADDLE_ENFORCE(cudnnSetConvolutionNdDescriptor( + desc_, pads.size(), pads.data(), strides.data(), dilations.data(), + CUDNN_CROSS_CORRELATION, type)); + } + + template + inline cudnnConvolutionDescriptor_t descriptor( + const std::vector& pads, const std::vector& strides, + const std::vector& dilations) { + return descriptor(CudnnDataType::type, pads, strides, dilations); + } + + private: + cudnnConvolutionDescriptor_t desc_; + DISABLE_COPY_AND_ASSIGN(ScopedConvolutionDescriptor); +}; + +class ScopedPoolingDescriptor { + public: + ScopedPoolingDescriptor() { + PADDLE_ENFORCE(dynload::cudnnCreatePoolingDescriptor(&desc_)); + } + ~ScopedPoolingDescriptor() { + PADDLE_ENFORCE(dynload::cudnnDestroyPoolingDescriptor(desc_)); + } + + inline cudnnPoolingDescriptor_t descriptor(const PoolingMode& mode, + cudnnDataType_t type, + const std::vector& kernel, + const std::vector& pads, + const std::vector& strides) { + PADDLE_ENFORCE_EQ(kernel.size(), pads.size()); + PADDLE_ENFORCE_EQ(kernel.size(), strides.size()); + PADDLE_ENFORCE(cudnnSetPoolingNdDescriptor( + desc_, (mode == PoolingMode::kMaximum + ? CUDNN_POOLING_MAX + : CUDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING), + CUDNN_PROPAGATE_NAN, // Always propagate nans. + kernel.size(), kernel.data(), pads.data(), strides.data())); + } + + template + inline cudnnPoolingDescriptor_t descriptor(const PoolingMode& mode, + const std::vector& kernel, + const std::vector& pads, + const std::vector& strides) { + return descriptor(mode, CudnnDataType::type, kernel, pads, strides); + } + + private: + cudnnPoolingDescriptor_t desc_; + DISABLE_COPY_AND_ASSIGN(ScopedPoolingDescriptor); +}; + +} // namespace platform +} // namespace paddle diff --git a/paddle/platform/macros.h b/paddle/platform/macros.h new file mode 100644 index 0000000000..4a04a38c0c --- /dev/null +++ b/paddle/platform/macros.h @@ -0,0 +1,23 @@ +/* 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 + +// Disable the copy and assignment operator for a class. +#ifndef DISABLE_COPY_AND_ASSIGN +#define DISABLE_COPY_AND_ASSIGN(classname) \ + private: \ + classname(const classname&) = delete; \ + classname& operator=(const classname&) = delete +#endif From f8b885f27f19474124d46002d6572c239910eefd Mon Sep 17 00:00:00 2001 From: yangyaming Date: Thu, 31 Aug 2017 20:15:48 +0800 Subject: [PATCH 05/62] Using EigenTensor to reshape tensor. --- paddle/operators/squared_l2_distance_op.cc | 64 ++++++++--- paddle/operators/squared_l2_distance_op.h | 128 ++++++++++++++++++--- 2 files changed, 157 insertions(+), 35 deletions(-) diff --git a/paddle/operators/squared_l2_distance_op.cc b/paddle/operators/squared_l2_distance_op.cc index 9fc498d5a5..3049f0f8ba 100644 --- a/paddle/operators/squared_l2_distance_op.cc +++ b/paddle/operators/squared_l2_distance_op.cc @@ -22,36 +22,52 @@ class SquaredL2DistanceOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; protected: - void InferShape(const framework::InferShapeContext &ctx) const override { + void InferShape(const framework::InferShapeContext& ctx) const override { PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"), "Input of SquaredL2DistanceOp " "must be initialized."); - PADDLE_ENFORCE_EQ(ctx.Input("X")->dims(), - ctx.Input("Y")->dims(), - "Dimensions of SquaredL2DistanceOp's two inputs " - "must be same.") - framework::DDim dims = ctx.Input("X")->dims(); - ctx.Output("sub_result")->Resize(dims); - ctx.Output("Out")->Resize(framework::make_ddim({dims[0], 1})); + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Y"), + "Target of SquaredL2DistanceOp " + "must be initialized."); + + auto* X = ctx.Input("X"); + auto xDims = X->dims(); + auto* Y = ctx.Input("Y"); + auto yDims = Y->dims(); + + PADDLE_ENFORCE_EQ(framework::arity(xDims), framework::arity(yDims), + "Tensor rank of both SquaredL2DistanceOp's " + "inputs must be same."); + int rank = framework::arity(xDims); + PADDLE_ENFORCE(rank >= 2 || rank <= 6, "Tensor rank should be in [2, 6]."); + PADDLE_ENFORCE(yDims[0] == 1 || yDims[0] == xDims[0], + "First dimension of target must be equal to input " + "or to 1."); + + ctx.Output("sub_result")->Resize(xDims); + ctx.Output("Out")->Resize({xDims[0], 1}); } }; class SquaredL2DistanceOpMaker : public framework::OpProtoAndCheckerMaker { public: - SquaredL2DistanceOpMaker(framework::OpProto *proto, - framework::OpAttrChecker *op_checker) + SquaredL2DistanceOpMaker(framework::OpProto* proto, + framework::OpAttrChecker* op_checker) : OpProtoAndCheckerMaker(proto, op_checker) { - AddInput("X", "Input value."); - AddInput("Y", "Target value."); + AddInput("X", "Input of SquaredL2DistanceOp."); + AddInput("Y", "Target of SquaredL2DistanceOp."); AddOutput("sub_result", "Buffering substraction result which " "will be reused in backward.") .AsIntermediate(); AddOutput("Out", "Squared l2 distance between input and target."); AddComment(R"DOC( - SquaredL2DistanceOp will cacluate the squared L2 distances for + SquaredL2DistanceOp will cacluate the squared L2 distance for input and target. Number of distance value equals to the - first dimension of input. + first dimension of input. First dimension of target could be equal to + input or to 1. If the first dimension of target is 1, SquaredL2DistanceOp + will broadcast the first dimension to the first dimension of input. + You can decide whether calculate the gradient of target. )DOC"); } }; @@ -61,9 +77,23 @@ class SquaredL2DistanceGradOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; protected: - void InferShape(const framework::InferShapeContext &ctx) const override { - ctx.Output(framework::GradVarName("X")) - ->Resize(ctx.Input("X")->dims()); + void InferShape(const framework::InferShapeContext& ctx) const override { + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar(framework::GradVarName("Out")), + "Gradient of Out should not be null"); + // check out grad dimensions + auto outDims = ctx.Input(framework::GradVarName("Out"))->dims(); + auto xDims = ctx.Input("X")->dims(); + auto yDims = ctx.Input("Y")->dims(); + PADDLE_ENFORCE_EQ(outDims[0], xDims[0], + "First dimension of output gradient and " + "input value must be equal."); + PADDLE_ENFORCE_EQ(outDims[1], 1, + "Second dimension of output gradient " + "must be 1."); + auto* xGrad = ctx.Output(framework::GradVarName("X")); + auto* yGrad = ctx.Output(framework::GradVarName("Y")); + if (xGrad != nullptr) xGrad->Resize(xDims); + if (yGrad != nullptr) yGrad->Resize(yDims); } }; diff --git a/paddle/operators/squared_l2_distance_op.h b/paddle/operators/squared_l2_distance_op.h index b350fd0117..e95364c706 100644 --- a/paddle/operators/squared_l2_distance_op.h +++ b/paddle/operators/squared_l2_distance_op.h @@ -20,17 +20,44 @@ namespace paddle { namespace operators { using Tensor = framework::Tensor; -template -using EigenMatrix = framework::EigenMatrix; +using EigenTensor = framework::EigenTensor; template -using EigenVector = framework::EigenVector; +using EigenMatrix = framework::EigenMatrix; template class SquaredL2DistanceKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { + auto* input0 = context.Input("X"); + const int rank = framework::arity(input0->dims()); + switch (rank) { + case 2: + Operate<2>(context); + break; + case 3: + Operate<3>(context); + break; + case 4: + Operate<4>(context); + break; + case 5: + Operate<5>(context); + break; + case 6: + Operate<6>(context); + break; + default: + // already asserted in SquaredL2DistanceOpMaker + break; + } + } + + private: + template + void Operate(const framework::ExecutionContext& context) const { auto* input0 = context.Input("X"); auto* input1 = context.Input("Y"); auto* output0 = context.Output("sub_result"); @@ -39,17 +66,28 @@ class SquaredL2DistanceKernel : public framework::OpKernel { output0->mutable_data(context.GetPlace()); output1->mutable_data(context.GetPlace()); - auto X = EigenMatrix::From(*input0); - auto Y = EigenMatrix::From(*input1); - auto subResult = EigenMatrix::From(*output0); + auto X = EigenTensor::From(*input0); + auto Y = EigenTensor::From(*input1); + auto subResult = EigenTensor::From(*output0); auto Z = EigenMatrix::From(*output1); + auto xDims = X.dimensions(); + auto yDims = Y.dimensions(); + auto place = context.GetEigenDevice(); + // buffer the substraction result - subResult.device(place) = X - Y; - const auto& inDims = X.dimensions(); + if (yDims[0] == 1 && xDims[0] != yDims[0]) { + auto yBroadcastDims = yDims; + yBroadcastDims[0] = xDims[0]; + subResult.device(place) = X - Y.broadcast(yBroadcastDims); + } else { + subResult.device(place) = X - Y; + } + + // create matrix view for substraction result const auto& subResMat = subResult.reshape(Eigen::array( - {static_cast(inDims[0]), static_cast(X.size() / inDims[0])})); + {static_cast(xDims[0]), static_cast(X.size() / xDims[0])})); Z.device(place) = subResMat.pow(2).sum(Eigen::array({1})); } }; @@ -59,24 +97,78 @@ class SquaredL2DistanceGradKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { auto* input0 = context.Input("sub_result"); - auto* OG = context.Input(framework::GradVarName("Out")); - auto* IG = context.Output(framework::GradVarName("X")); + const int rank = framework::arity(input0->dims()); + switch (rank) { + case 2: + Operate<2>(context); + break; + case 3: + Operate<3>(context); + break; + case 4: + Operate<4>(context); + break; + case 5: + Operate<5>(context); + break; + case 6: + Operate<6>(context); + break; + default: + // already asserted in SquaredL2DistanceOpMaker + break; + } + } - IG->mutable_data(context.GetPlace()); + private: + template + void Operate(const framework::ExecutionContext& context) const { + auto* input0 = context.Input("sub_result"); + auto* OG = context.Input(framework::GradVarName("Out")); + auto* XG = context.Output(framework::GradVarName("X")); + auto* YG = context.Output(framework::GradVarName("Y")); - auto subResult = EigenMatrix::From(*input0); + auto subResult = EigenTensor::From(*input0); auto outGrad = EigenMatrix::From(*OG); - auto inGrad = EigenMatrix::From(*IG); - const auto& subResDims = subResult.dimensions(); + auto subResDims = subResult.dimensions(); int firstDim = static_cast(subResDims[0]); int cols = subResult.size() / firstDim; const auto subResMat = subResult.reshape(Eigen::array({firstDim, cols})); - // create a matrix view for input gradient tensor - auto inGradMat = inGrad.reshape(Eigen::array({firstDim, cols})); - inGradMat.device(context.GetEigenDevice()) = + + // calculate gradient + auto gradMat = 2 * (outGrad.broadcast(Eigen::array({1, cols}))) * subResMat; + + // propagate back to input + auto eigenPlace = context.GetEigenDevice(); + if (XG != nullptr) { + XG->mutable_data(context.GetPlace()); + auto xGrad = EigenTensor::From(*XG); + // dimensions are same with subResult + auto xGradMat = xGrad.reshape(Eigen::array({firstDim, cols})); + xGradMat.device(eigenPlace) = gradMat; + } + if (YG != nullptr) { + YG->mutable_data(context.GetPlace()); + auto yGrad = EigenTensor::From(*YG); + auto dimsYGrad = yGrad.dimensions(); + auto yGradMat = yGrad.reshape(Eigen::array( + {static_cast(dimsYGrad[0]), + static_cast(yGrad.size() / dimsYGrad[0])})); + + PADDLE_ENFORCE(dimsYGrad[0] <= firstDim, + "First dimension of gradient must be greater or " + "equal than first dimension of target"); + + if (dimsYGrad[0] == firstDim) { + yGradMat.device(eigenPlace) = -1 * gradMat; + } else { + yGradMat.device(eigenPlace) = + -1 * (gradMat.sum(Eigen::array({0}))); + } + } } }; From 207132226c39c864a0808428cb8593bafafc4407 Mon Sep 17 00:00:00 2001 From: dangqingqing Date: Thu, 31 Aug 2017 20:49:33 +0800 Subject: [PATCH 06/62] Add unit testing for cuDNN wrapper. --- paddle/platform/CMakeLists.txt | 4 +- paddle/platform/cudnn_helper.h | 41 +++++---- paddle/platform/cudnn_helper_test.cc | 121 +++++++++++++++++++++++++ paddle/platform/dynload/CMakeLists.txt | 2 +- paddle/platform/dynload/cudnn.h | 8 ++ 5 files changed, 157 insertions(+), 19 deletions(-) create mode 100644 paddle/platform/cudnn_helper_test.cc diff --git a/paddle/platform/CMakeLists.txt b/paddle/platform/CMakeLists.txt index ef722e984c..9a3ad8eb64 100644 --- a/paddle/platform/CMakeLists.txt +++ b/paddle/platform/CMakeLists.txt @@ -22,4 +22,6 @@ ENDIF() cc_library(device_context SRCS device_context.cc DEPS memory buddy_allocator system_allocator memory_block meta_data meta_cache place eigen3 ${GPU_CTX_DEPS}) nv_test(device_context_test SRCS device_context_test.cc DEPS device_context gpu_info) -nv_test(cudnn_helper SRCS cudnn_helper.cc) + +nv_library(cudnn_helper SRCS cudnn_helper.cc DEPS dynload_cuda) +nv_test(cudnn_helper_test SRCS cudnn_helper_test.cc DEPS dynload_cuda) diff --git a/paddle/platform/cudnn_helper.h b/paddle/platform/cudnn_helper.h index 91047236a2..6a43f49cfc 100644 --- a/paddle/platform/cudnn_helper.h +++ b/paddle/platform/cudnn_helper.h @@ -14,7 +14,9 @@ limitations under the License. */ #pragma once +#ifndef PADDLE_ONLY_CPU #include +#include "glog/logging.h" #include "paddle/platform/dynload/cudnn.h" #include "paddle/platform/enforce.h" #include "paddle/platform/macros.h" @@ -93,11 +95,11 @@ class ScopedTensorDescriptor { // the format is not used now, but it maybe useful feature std::vector strides(dims.size()); strides[dims.size() - 1] = 1; - for (int i = dims.size() - 1; i >= 0; i++) { - strides[i] = dims[i + 1] * strides[i]; + for (int i = dims.size() - 2; i >= 0; i--) { + strides[i] = dims[i + 1] * strides[i + 1]; } - PADDLE_ENFORCE(cudnnSetTensorNdDescriptor(desc_, type, dims.size(), - dims.data(), strides.data())); + PADDLE_ENFORCE(dynload::cudnnSetTensorNdDescriptor( + desc_, type, dims.size(), dims.data(), strides.data())); return desc_; } @@ -126,8 +128,8 @@ class ScopedFilterDescriptor { const cudnnDataType_t type, const std::vector& kernel) { // filter layout: output input spatial_dim_y spatial_dim_x - PADDLE_ENFORCE(cudnnSetFilterNdDescriptor(desc_, type, format, - kernel.size(), kernel.data())); + PADDLE_ENFORCE(dynload::cudnnSetFilterNdDescriptor( + desc_, type, format, kernel.size(), kernel.data())); return desc_; } @@ -157,9 +159,21 @@ class ScopedConvolutionDescriptor { const std::vector& strides, const std::vector& dilations) { PADDLE_ENFORCE_EQ(pads.size(), strides.size()); PADDLE_ENFORCE_EQ(pads.size(), dilations.size()); - PADDLE_ENFORCE(cudnnSetConvolutionNdDescriptor( + +#if CUDNN_VERSION < 6000 + // cudnn v5 does not support dilation conv, the argument is called upscale + // instead of dilations and it is must be one. + for (size_t i = 0; i < dilations.size(); ++i) { + PADDLE_ENFORCE_EQ( + dilations[i], 1, + "Dilations conv is not supported in this cuDNN version"); + } +#endif + + PADDLE_ENFORCE(dynload::cudnnSetConvolutionNdDescriptor( desc_, pads.size(), pads.data(), strides.data(), dilations.data(), CUDNN_CROSS_CORRELATION, type)); + return desc_; } template @@ -184,26 +198,18 @@ class ScopedPoolingDescriptor { } inline cudnnPoolingDescriptor_t descriptor(const PoolingMode& mode, - cudnnDataType_t type, const std::vector& kernel, const std::vector& pads, const std::vector& strides) { PADDLE_ENFORCE_EQ(kernel.size(), pads.size()); PADDLE_ENFORCE_EQ(kernel.size(), strides.size()); - PADDLE_ENFORCE(cudnnSetPoolingNdDescriptor( + PADDLE_ENFORCE(dynload::cudnnSetPoolingNdDescriptor( desc_, (mode == PoolingMode::kMaximum ? CUDNN_POOLING_MAX : CUDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING), CUDNN_PROPAGATE_NAN, // Always propagate nans. kernel.size(), kernel.data(), pads.data(), strides.data())); - } - - template - inline cudnnPoolingDescriptor_t descriptor(const PoolingMode& mode, - const std::vector& kernel, - const std::vector& pads, - const std::vector& strides) { - return descriptor(mode, CudnnDataType::type, kernel, pads, strides); + return desc_; } private: @@ -213,3 +219,4 @@ class ScopedPoolingDescriptor { } // namespace platform } // namespace paddle +#endif diff --git a/paddle/platform/cudnn_helper_test.cc b/paddle/platform/cudnn_helper_test.cc new file mode 100644 index 0000000000..729f2f8a10 --- /dev/null +++ b/paddle/platform/cudnn_helper_test.cc @@ -0,0 +1,121 @@ +/* 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/platform/cudnn_helper.h" +#include "glog/logging.h" +#include "gtest/gtest.h" + +TEST(CudnnHelper, ScopedTensorDescriptor) { + using paddle::platform::ScopedTensorDescriptor; + using paddle::platform::DataLayout; + + ScopedTensorDescriptor tensor_desc; + std::vector shape = {2, 4, 6, 6}; + auto desc = tensor_desc.descriptor(DataLayout::kNCHW, shape); + + cudnnDataType_t type; + int nd; + std::vector dims(4); + std::vector strides(4); + paddle::platform::dynload::cudnnGetTensorNdDescriptor( + desc, 4, &type, &nd, dims.data(), strides.data()); + + EXPECT_EQ(nd, 4); + for (size_t i = 0; i < dims.size(); ++i) { + EXPECT_EQ(dims[i], shape[i]); + } + EXPECT_EQ(strides[3], 1); + EXPECT_EQ(strides[2], 6); + EXPECT_EQ(strides[1], 36); + EXPECT_EQ(strides[0], 144); +} + +TEST(CudnnHelper, ScopedFilterDescriptor) { + using paddle::platform::ScopedFilterDescriptor; + using paddle::platform::DataLayout; + + ScopedFilterDescriptor filter_desc; + std::vector shape = {2, 3, 3}; + auto desc = filter_desc.descriptor(DataLayout::kNCHW, shape); + + cudnnDataType_t type; + int nd; + cudnnTensorFormat_t format; + std::vector kernel(3); + paddle::platform::dynload::cudnnGetFilterNdDescriptor(desc, 3, &type, &format, + &nd, kernel.data()); + + EXPECT_EQ(GetCudnnTensorFormat(DataLayout::kNCHW), format); + EXPECT_EQ(nd, 3); + for (size_t i = 0; i < shape.size(); ++i) { + EXPECT_EQ(kernel[i], shape[i]); + } +} + +TEST(CudnnHelper, ScopedConvolutionDescriptor) { + using paddle::platform::ScopedConvolutionDescriptor; + + ScopedConvolutionDescriptor conv_desc; + std::vector src_pads = {2, 2, 2}; + std::vector src_strides = {1, 1, 1}; + std::vector src_dilations = {1, 1, 1}; + auto desc = conv_desc.descriptor(src_pads, src_strides, src_dilations); + + cudnnDataType_t type; + cudnnConvolutionMode_t mode; + int nd; + std::vector pads(3); + std::vector strides(3); + std::vector dilations(3); + paddle::platform::dynload::cudnnGetConvolutionNdDescriptor( + desc, 3, &nd, pads.data(), strides.data(), dilations.data(), &mode, + &type); + + EXPECT_EQ(nd, 3); + for (size_t i = 0; i < src_pads.size(); ++i) { + EXPECT_EQ(pads[i], src_pads[i]); + EXPECT_EQ(strides[i], src_strides[i]); + EXPECT_EQ(dilations[i], src_dilations[i]); + } + EXPECT_EQ(mode, CUDNN_CROSS_CORRELATION); +} + +TEST(CudnnHelper, ScopedPoolingDescriptor) { + using paddle::platform::ScopedPoolingDescriptor; + using paddle::platform::PoolingMode; + + ScopedPoolingDescriptor pool_desc; + std::vector src_kernel = {2, 2, 5}; + std::vector src_pads = {1, 1, 2}; + std::vector src_strides = {2, 2, 3}; + auto desc = pool_desc.descriptor(PoolingMode::kMaximum, src_kernel, src_pads, + src_strides); + + cudnnPoolingMode_t mode; + cudnnNanPropagation_t nan_t = CUDNN_PROPAGATE_NAN; + int nd; + std::vector kernel(3); + std::vector pads(3); + std::vector strides(3); + paddle::platform::dynload::cudnnGetPoolingNdDescriptor( + desc, 3, &mode, &nan_t, &nd, kernel.data(), pads.data(), strides.data()); + + EXPECT_EQ(nd, 3); + for (size_t i = 0; i < src_pads.size(); ++i) { + EXPECT_EQ(kernel[i], src_kernel[i]); + EXPECT_EQ(pads[i], src_pads[i]); + EXPECT_EQ(strides[i], src_strides[i]); + } + EXPECT_EQ(mode, CUDNN_POOLING_MAX); +} diff --git a/paddle/platform/dynload/CMakeLists.txt b/paddle/platform/dynload/CMakeLists.txt index d205ead845..ceb66f84b6 100644 --- a/paddle/platform/dynload/CMakeLists.txt +++ b/paddle/platform/dynload/CMakeLists.txt @@ -1,2 +1,2 @@ cc_library(dynamic_loader SRCS dynamic_loader.cc DEPS glog gflags) -nv_library(dynload_cuda SRCS cublas.cc cudnn.cc curand.cc) +nv_library(dynload_cuda SRCS cublas.cc cudnn.cc curand.cc DEPS dynamic_loader) diff --git a/paddle/platform/dynload/cudnn.h b/paddle/platform/dynload/cudnn.h index ef0dd85b08..0120625b7c 100644 --- a/paddle/platform/dynload/cudnn.h +++ b/paddle/platform/dynload/cudnn.h @@ -62,19 +62,27 @@ extern void* cudnn_dso_handle; #define CUDNN_DNN_ROUTINE_EACH(__macro) \ __macro(cudnnSetTensor4dDescriptor); \ __macro(cudnnSetTensor4dDescriptorEx); \ + __macro(cudnnSetTensorNdDescriptor); \ + __macro(cudnnGetTensorNdDescriptor); \ __macro(cudnnGetConvolutionNdForwardOutputDim); \ __macro(cudnnGetConvolutionForwardAlgorithm); \ __macro(cudnnCreateTensorDescriptor); \ __macro(cudnnDestroyTensorDescriptor); \ __macro(cudnnCreateFilterDescriptor); \ __macro(cudnnSetFilter4dDescriptor); \ + __macro(cudnnSetFilterNdDescriptor); \ + __macro(cudnnGetFilterNdDescriptor); \ __macro(cudnnSetPooling2dDescriptor); \ + __macro(cudnnSetPoolingNdDescriptor); \ + __macro(cudnnGetPoolingNdDescriptor); \ __macro(cudnnDestroyFilterDescriptor); \ __macro(cudnnCreateConvolutionDescriptor); \ __macro(cudnnCreatePoolingDescriptor); \ __macro(cudnnDestroyPoolingDescriptor); \ __macro(cudnnSetConvolution2dDescriptor); \ __macro(cudnnDestroyConvolutionDescriptor); \ + __macro(cudnnSetConvolutionNdDescriptor); \ + __macro(cudnnGetConvolutionNdDescriptor); \ __macro(cudnnCreate); \ __macro(cudnnDestroy); \ __macro(cudnnSetStream); \ From 6bef079660f689a1b9c061e31c8273de353f98da Mon Sep 17 00:00:00 2001 From: yangyaming Date: Thu, 31 Aug 2017 22:31:34 +0800 Subject: [PATCH 07/62] Follow coding style and move reshaping operation to paddle tensor. --- paddle/operators/squared_l2_distance_op.cc | 47 ++--- paddle/operators/squared_l2_distance_op.h | 170 ++++++------------ .../tests/test_squared_l2_distance_op.py | 10 ++ 3 files changed, 92 insertions(+), 135 deletions(-) diff --git a/paddle/operators/squared_l2_distance_op.cc b/paddle/operators/squared_l2_distance_op.cc index 3049f0f8ba..b19c274dcc 100644 --- a/paddle/operators/squared_l2_distance_op.cc +++ b/paddle/operators/squared_l2_distance_op.cc @@ -30,22 +30,27 @@ class SquaredL2DistanceOp : public framework::OperatorWithKernel { "Target of SquaredL2DistanceOp " "must be initialized."); - auto* X = ctx.Input("X"); - auto xDims = X->dims(); - auto* Y = ctx.Input("Y"); - auto yDims = Y->dims(); + auto* x = ctx.Input("X"); + auto x_dims = x->dims(); + auto* y = ctx.Input("Y"); + auto y_dims = y->dims(); - PADDLE_ENFORCE_EQ(framework::arity(xDims), framework::arity(yDims), + PADDLE_ENFORCE_EQ(framework::arity(x_dims), framework::arity(y_dims), "Tensor rank of both SquaredL2DistanceOp's " "inputs must be same."); - int rank = framework::arity(xDims); - PADDLE_ENFORCE(rank >= 2 || rank <= 6, "Tensor rank should be in [2, 6]."); - PADDLE_ENFORCE(yDims[0] == 1 || yDims[0] == xDims[0], + + int rank = framework::arity(x_dims); + PADDLE_ENFORCE(rank >= 2, "Tensor rank should be at least equal to 2."); + PADDLE_ENFORCE_EQ(framework::product(x_dims) / x_dims[0], + framework::product(y_dims) / y_dims[0], + "Product of dimensions expcet the first dimension of " + "input and target must be equal."); + PADDLE_ENFORCE(y_dims[0] == 1 || y_dims[0] == x_dims[0], "First dimension of target must be equal to input " "or to 1."); - ctx.Output("sub_result")->Resize(xDims); - ctx.Output("Out")->Resize({xDims[0], 1}); + ctx.Output("sub_result")->Resize(x_dims); + ctx.Output("Out")->Resize({x_dims[0], 1}); } }; @@ -66,8 +71,8 @@ class SquaredL2DistanceOpMaker : public framework::OpProtoAndCheckerMaker { input and target. Number of distance value equals to the first dimension of input. First dimension of target could be equal to input or to 1. If the first dimension of target is 1, SquaredL2DistanceOp - will broadcast the first dimension to the first dimension of input. - You can decide whether calculate the gradient of target. + will broadcast target's first dimension to input's first dimension. + You can decide whether calculate the gradient of input and target. )DOC"); } }; @@ -81,19 +86,19 @@ class SquaredL2DistanceGradOp : public framework::OperatorWithKernel { PADDLE_ENFORCE_NOT_NULL(ctx.InputVar(framework::GradVarName("Out")), "Gradient of Out should not be null"); // check out grad dimensions - auto outDims = ctx.Input(framework::GradVarName("Out"))->dims(); - auto xDims = ctx.Input("X")->dims(); - auto yDims = ctx.Input("Y")->dims(); - PADDLE_ENFORCE_EQ(outDims[0], xDims[0], + auto out_dims = ctx.Input(framework::GradVarName("Out"))->dims(); + auto x_dims = ctx.Input("X")->dims(); + auto y_dims = ctx.Input("Y")->dims(); + PADDLE_ENFORCE_EQ(out_dims[0], x_dims[0], "First dimension of output gradient and " "input value must be equal."); - PADDLE_ENFORCE_EQ(outDims[1], 1, + PADDLE_ENFORCE_EQ(out_dims[1], 1, "Second dimension of output gradient " "must be 1."); - auto* xGrad = ctx.Output(framework::GradVarName("X")); - auto* yGrad = ctx.Output(framework::GradVarName("Y")); - if (xGrad != nullptr) xGrad->Resize(xDims); - if (yGrad != nullptr) yGrad->Resize(yDims); + auto* x_grad = ctx.Output(framework::GradVarName("X")); + auto* y_grad = ctx.Output(framework::GradVarName("Y")); + if (x_grad != nullptr) x_grad->Resize(x_dims); + if (y_grad != nullptr) y_grad->Resize(y_dims); } }; diff --git a/paddle/operators/squared_l2_distance_op.h b/paddle/operators/squared_l2_distance_op.h index e95364c706..ec8c34ddf8 100644 --- a/paddle/operators/squared_l2_distance_op.h +++ b/paddle/operators/squared_l2_distance_op.h @@ -20,9 +20,6 @@ namespace paddle { namespace operators { using Tensor = framework::Tensor; -template -using EigenTensor = framework::EigenTensor; template using EigenMatrix = framework::EigenMatrix; @@ -31,64 +28,39 @@ template class SquaredL2DistanceKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - auto* input0 = context.Input("X"); - const int rank = framework::arity(input0->dims()); - switch (rank) { - case 2: - Operate<2>(context); - break; - case 3: - Operate<3>(context); - break; - case 4: - Operate<4>(context); - break; - case 5: - Operate<5>(context); - break; - case 6: - Operate<6>(context); - break; - default: - // already asserted in SquaredL2DistanceOpMaker - break; - } - } - - private: - template - void Operate(const framework::ExecutionContext& context) const { - auto* input0 = context.Input("X"); - auto* input1 = context.Input("Y"); - auto* output0 = context.Output("sub_result"); - auto* output1 = context.Output("Out"); - - output0->mutable_data(context.GetPlace()); - output1->mutable_data(context.GetPlace()); - - auto X = EigenTensor::From(*input0); - auto Y = EigenTensor::From(*input1); - auto subResult = EigenTensor::From(*output0); - auto Z = EigenMatrix::From(*output1); - - auto xDims = X.dimensions(); - auto yDims = Y.dimensions(); + auto* in0 = context.Input("X"); + auto* in1 = context.Input("Y"); + auto* out0 = context.Output("sub_result"); + auto* out1 = context.Output("Out"); + + auto in0_dims = in0->dims(); + auto in1_dims = in1->dims(); + + int cols = framework::product(in0_dims) / in0_dims[0]; + // reduce dimensions except the first + auto x = + EigenMatrix::From(*in0, framework::make_ddim({in0_dims[0], cols})); + auto y = + EigenMatrix::From(*in1, framework::make_ddim({in1_dims[0], cols})); + + out0->mutable_data(context.GetPlace()); + out1->mutable_data(context.GetPlace()); + auto sub_result = EigenMatrix::From(*out0); + auto z = EigenMatrix::From(*out1); auto place = context.GetEigenDevice(); - + auto x_dims = x.dimensions(); + auto y_dims = y.dimensions(); // buffer the substraction result - if (yDims[0] == 1 && xDims[0] != yDims[0]) { - auto yBroadcastDims = yDims; - yBroadcastDims[0] = xDims[0]; - subResult.device(place) = X - Y.broadcast(yBroadcastDims); + if (y_dims[0] == 1 && x_dims[0] > y_dims[0]) { + auto y_broadcast_dims = y_dims; + y_broadcast_dims[0] = x_dims[0]; + sub_result.device(place) = x - y.broadcast(y_broadcast_dims); } else { - subResult.device(place) = X - Y; + sub_result.device(place) = x - y; } - // create matrix view for substraction result - const auto& subResMat = subResult.reshape(Eigen::array( - {static_cast(xDims[0]), static_cast(X.size() / xDims[0])})); - Z.device(place) = subResMat.pow(2).sum(Eigen::array({1})); + z.device(place) = sub_result.pow(2).sum(Eigen::array({1})); } }; @@ -96,77 +68,47 @@ template class SquaredL2DistanceGradKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - auto* input0 = context.Input("sub_result"); - const int rank = framework::arity(input0->dims()); - switch (rank) { - case 2: - Operate<2>(context); - break; - case 3: - Operate<3>(context); - break; - case 4: - Operate<4>(context); - break; - case 5: - Operate<5>(context); - break; - case 6: - Operate<6>(context); - break; - default: - // already asserted in SquaredL2DistanceOpMaker - break; - } - } + auto* in0 = context.Input("sub_result"); + auto* in1 = context.Input(framework::GradVarName("Out")); + auto* x_g = context.Output(framework::GradVarName("X")); + auto* y_g = context.Output(framework::GradVarName("Y")); - private: - template - void Operate(const framework::ExecutionContext& context) const { - auto* input0 = context.Input("sub_result"); - auto* OG = context.Input(framework::GradVarName("Out")); - auto* XG = context.Output(framework::GradVarName("X")); - auto* YG = context.Output(framework::GradVarName("Y")); + auto sub_result = EigenMatrix::From(*in0); + auto out_grad = EigenMatrix::From(*in1); - auto subResult = EigenTensor::From(*input0); - auto outGrad = EigenMatrix::From(*OG); - - auto subResDims = subResult.dimensions(); - int firstDim = static_cast(subResDims[0]); - int cols = subResult.size() / firstDim; - const auto subResMat = - subResult.reshape(Eigen::array({firstDim, cols})); + auto x_dims = x_g->dims(); + auto y_dims = y_g->dims(); + int cols = framework::product(x_dims) / x_dims[0]; // calculate gradient - auto gradMat = - 2 * (outGrad.broadcast(Eigen::array({1, cols}))) * subResMat; + auto grad_mat = + 2 * (out_grad.broadcast(Eigen::array({1, cols}))) * sub_result; // propagate back to input - auto eigenPlace = context.GetEigenDevice(); - if (XG != nullptr) { - XG->mutable_data(context.GetPlace()); - auto xGrad = EigenTensor::From(*XG); + auto eigen_place = context.GetEigenDevice(); + if (x_g != nullptr) { + x_g->mutable_data(context.GetPlace()); + // eigen matrix + auto x_grad = + EigenMatrix::From(*x_g, framework::make_ddim({x_dims[0], cols})); // dimensions are same with subResult - auto xGradMat = xGrad.reshape(Eigen::array({firstDim, cols})); - xGradMat.device(eigenPlace) = gradMat; + x_grad.device(eigen_place) = grad_mat; } - if (YG != nullptr) { - YG->mutable_data(context.GetPlace()); - auto yGrad = EigenTensor::From(*YG); - auto dimsYGrad = yGrad.dimensions(); - auto yGradMat = yGrad.reshape(Eigen::array( - {static_cast(dimsYGrad[0]), - static_cast(yGrad.size() / dimsYGrad[0])})); - - PADDLE_ENFORCE(dimsYGrad[0] <= firstDim, + + if (y_g != nullptr) { + y_g->mutable_data(context.GetPlace()); + auto y_grad = + EigenMatrix::From(*y_g, framework::make_ddim({y_dims[0], cols})); + + PADDLE_ENFORCE(sub_result.dimensions()[0] >= y_dims[0], "First dimension of gradient must be greater or " "equal than first dimension of target"); - if (dimsYGrad[0] == firstDim) { - yGradMat.device(eigenPlace) = -1 * gradMat; + if (sub_result.dimensions()[0] == y_dims[0]) { + y_grad.device(eigen_place) = -1 * grad_mat; } else { - yGradMat.device(eigenPlace) = - -1 * (gradMat.sum(Eigen::array({0}))); + y_grad.device(eigen_place) = + -1 * (grad_mat.sum(Eigen::array({0}))); } } } diff --git a/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py b/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py index eeddb5a3bf..51c95b286a 100644 --- a/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py +++ b/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py @@ -21,5 +21,15 @@ class TestSquaredL2DistanceOp(unittest.TestCase): } +class TestSquaredL2DistanceGradOp(GradientChecker): + def test_squared_l2_distance(self): + op = create_op("squared_l2_distance") + inputs = { + 'X': np.random.uniform(0.1, 1., (2, 3)).astype('float32'), + 'Y': np.random.uniform(0.1, 1., (2, 3)).astype('float32') + } + self.check_grad(op, inputs, set(["X", "Y"]), "Out") + + if __name__ == '__main__': unittest.main() From ed72af48cecb1462b14c2105e9451052fa583cde Mon Sep 17 00:00:00 2001 From: Xinghai Sun Date: Fri, 1 Sep 2017 19:01:12 +0800 Subject: [PATCH 08/62] Add cos_sim op. --- paddle/operators/CMakeLists.txt | 2 +- paddle/operators/cos_sim_op.cc | 91 ++++++++++++++++++ paddle/operators/cos_sim_op.cu | 22 +++++ paddle/operators/cos_sim_op.h | 93 +++++++++++++++++++ paddle/pybind/pybind.cc | 1 + .../paddle/v2/framework/tests/CMakeLists.txt | 1 + .../v2/framework/tests/gradient_checker.py | 21 +++-- .../paddle/v2/framework/tests/op_test_util.py | 8 +- .../v2/framework/tests/test_cos_sim_op.py | 40 ++++++++ 9 files changed, 267 insertions(+), 12 deletions(-) create mode 100644 paddle/operators/cos_sim_op.cc create mode 100644 paddle/operators/cos_sim_op.cu create mode 100644 paddle/operators/cos_sim_op.h create mode 100644 python/paddle/v2/framework/tests/test_cos_sim_op.py diff --git a/paddle/operators/CMakeLists.txt b/paddle/operators/CMakeLists.txt index e5efcccb0e..25dbd236e6 100644 --- a/paddle/operators/CMakeLists.txt +++ b/paddle/operators/CMakeLists.txt @@ -56,7 +56,7 @@ list(REMOVE_ITEM GENERAL_OPS op_library(net_op SRCS net_op.cc) op_library(minus_op SRCS minus_op.cc minus_op.cu DEPS scale_op) op_library(mul_op SRCS mul_op.cc mul_op.cu DEPS math_function) -op_library(recurrent_op SRCS recurrent_op.cc rnn/recurrent_op_utils.cc +op_library(recurrent_op SRCS recurrent_op.cc rnn/recurrent_op_utils.cc DEPS framework_proto tensor operator net_op) op_library(scale_op SRCS scale_op.cc scale_op.cu DEPS net_op) diff --git a/paddle/operators/cos_sim_op.cc b/paddle/operators/cos_sim_op.cc new file mode 100644 index 0000000000..21a616522b --- /dev/null +++ b/paddle/operators/cos_sim_op.cc @@ -0,0 +1,91 @@ +/* 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/cos_sim_op.h" + +namespace paddle { +namespace operators { + +using framework::Tensor; + +class CosSimOp : 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("Y"), "Input(Y) should not be null."); + PADDLE_ENFORCE_EQ(ctx.Input("X")->dims(), + ctx.Input("Y")->dims(), + "Dimensions of Input(X) and Input(Y) must be the same."); + + auto dims = ctx.Input("X")->dims(); + ctx.Output("Out")->Resize({dims[0], 1}); + } +}; + +class CosSimOpMaker : public framework::OpProtoAndCheckerMaker { + public: + CosSimOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker) + : OpProtoAndCheckerMaker(proto, op_checker) { + AddInput("X", "The first input of cos_sim op."); + AddInput("Y", "The second input of cos_sim op."); + AddOutput("Out", "The output of cos_sim op."); + AddComment(R"DOC( +Cosine Similarity Operator. + +The equation is: Out = X^T * Y / (sqrt(X^T * X) * sqrt(Y^T * Y)) +)DOC"); + } +}; + +class CosSimOpGrad : 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("Y"), "Input(Y) 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("X")->dims(); + auto y_dims = ctx.Input("Y")->dims(); + auto out_dims = ctx.Input(framework::GradVarName("Out"))->dims(); + PADDLE_ENFORCE_EQ(x_dims, y_dims, + "Dimensions of Input(X) and Input(Y) must be the same."); + PADDLE_ENFORCE_EQ(out_dims[0], x_dims[0], + "1st dimension of Out@GRAD must equal to Input(X)"); + PADDLE_ENFORCE_EQ(out_dims[1], 1, + "1st dimension of Out@GRAD must equal to Input(X)"); + + auto *x_grad = ctx.Output(framework::GradVarName("X")); + auto *y_grad = ctx.Output(framework::GradVarName("Y")); + x_grad->Resize(x_dims); + y_grad->Resize(y_dims); + } +}; + +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; +REGISTER_OP(cos_sim, ops::CosSimOp, ops::CosSimOpMaker, cos_sim_grad, + ops::CosSimOpGrad); +REGISTER_OP_CPU_KERNEL(cos_sim, + ops::CosSimKernel); +REGISTER_OP_CPU_KERNEL( + cos_sim_grad, ops::CosSimGradKernel); diff --git a/paddle/operators/cos_sim_op.cu b/paddle/operators/cos_sim_op.cu new file mode 100644 index 0000000000..0cb8fd26de --- /dev/null +++ b/paddle/operators/cos_sim_op.cu @@ -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. */ + +#define EIGEN_USE_GPU +#include "paddle/operators/cos_sim_op.h" + +namespace ops = paddle::operators; +REGISTER_OP_GPU_KERNEL(cos_sim, + ops::CosSimKernel); +REGISTER_OP_GPU_KERNEL( + cos_sim_grad, ops::CosSimGradKernel); diff --git a/paddle/operators/cos_sim_op.h b/paddle/operators/cos_sim_op.h new file mode 100644 index 0000000000..5247087cc1 --- /dev/null +++ b/paddle/operators/cos_sim_op.h @@ -0,0 +1,93 @@ +/* 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 +using EigenMatrix = framework::EigenMatrix; + +template +class CosSimKernel : public framework::OpKernel { + public: + void Compute(const framework::ExecutionContext& context) const override { + auto* x = context.Input("X"); + auto* y = context.Input("Y"); + auto* z = context.Output("Out"); + + z->mutable_data(context.GetPlace()); + + auto dims = x->dims(); + int size = static_cast(framework::product(dims)); + auto new_dims = framework::make_ddim({dims[0], size / dims[0]}); + auto X = EigenMatrix::From(*x, new_dims); + auto Y = EigenMatrix::From(*y, new_dims); + auto Z = EigenMatrix::From(*z, new_dims); + + auto XY = (X * Y).sum(Eigen::array({1})); + auto XX = (X * X).sum(Eigen::array({1})); + auto YY = (Y * Y).sum(Eigen::array({1})); + auto place = context.GetEigenDevice(); + Z.device(place) = XY / XX.sqrt() / YY.sqrt(); + } +}; + +template +class CosSimGradKernel : public framework::OpKernel { + public: + void Compute(const framework::ExecutionContext& context) const override { + auto* x = context.Input("X"); + auto* y = context.Input("Y"); + auto* z = context.Input("Out"); + auto* grad_x = context.Output(framework::GradVarName("X")); + auto* grad_y = context.Output(framework::GradVarName("Y")); + auto* grad_z = context.Input(framework::GradVarName("Out")); + + grad_x->mutable_data(context.GetPlace()); + grad_y->mutable_data(context.GetPlace()); + + auto dims = x->dims(); + int size = static_cast(framework::product(dims)); + auto new_dims = framework::make_ddim({dims[0], size / dims[0]}); + auto X = EigenMatrix::From(*x, new_dims); + auto Y = EigenMatrix::From(*y, new_dims); + auto Z = EigenMatrix::From(*z); + auto dX = EigenMatrix::From(*grad_x, new_dims); + auto dY = EigenMatrix::From(*grad_y, new_dims); + auto dZ = EigenMatrix::From(*grad_z); + + auto XX = (X * X).sum(Eigen::array({1})); + auto YY = (Y * Y).sum(Eigen::array({1})); + Eigen::DSizes bcast(1, dims[1]); + auto denominator_bcast = (XX.sqrt() * YY.sqrt()).broadcast(bcast); + auto Z_bcast = Z.broadcast(bcast); + auto dZ_bcast = dZ.broadcast(bcast); + auto place = context.GetEigenDevice(); + dX.device(place) = + dZ_bcast * (Y / denominator_bcast - Z_bcast * X / XX.broadcast(bcast)); + dY.device(place) = + dZ_bcast * (X / denominator_bcast - Z_bcast * Y / YY.broadcast(bcast)); + // dX.device(place) = X; + // Y.device(place) = Y; + } +}; + +} // namespace operators +} // namespace paddle diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc index 3bc150ccb7..a8ec35dfad 100644 --- a/paddle/pybind/pybind.cc +++ b/paddle/pybind/pybind.cc @@ -46,6 +46,7 @@ USE_OP(lookup_table); USE_OP(scale); USE_OP_ITSELF(identity); USE_OP(minus); +USE_OP(cos_sim); USE_CPU_ONLY_OP(gather); USE_CPU_ONLY_OP(scatter); diff --git a/python/paddle/v2/framework/tests/CMakeLists.txt b/python/paddle/v2/framework/tests/CMakeLists.txt index 661ebd8964..e0f77d7973 100644 --- a/python/paddle/v2/framework/tests/CMakeLists.txt +++ b/python/paddle/v2/framework/tests/CMakeLists.txt @@ -4,6 +4,7 @@ py_test(test_scope SRCS test_scope.py) py_test(test_tensor SRCS test_tensor.py) py_test(test_mul_op SRCS test_mul_op.py) +py_test(test_cos_sim_op SRCS test_cos_sim_op.py) py_test(test_mean_op SRCS test_mean_op.py) diff --git a/python/paddle/v2/framework/tests/gradient_checker.py b/python/paddle/v2/framework/tests/gradient_checker.py index 518f828bac..bf01ea4876 100644 --- a/python/paddle/v2/framework/tests/gradient_checker.py +++ b/python/paddle/v2/framework/tests/gradient_checker.py @@ -36,13 +36,13 @@ def get_numeric_gradient(op, in_place=False): """ Get Numeric Gradient for an operator's input. - - :param op: C++ operator instance, could be an network - :param input_values: The input variables. Should be an dictionary, key is + + :param op: C++ operator instance, could be an network + :param input_values: The input variables. Should be an dictionary, key is variable name. Value is numpy array. - :param output_name: The final output variable name. + :param output_name: The final output variable name. :param input_to_check: The input variable need to get gradient. - :param delta: The perturbation value for numeric gradient method. The + :param delta: The perturbation value for numeric gradient method. The smaller delta is, the more accurate result will get. But if that delta is too small, it could occur numerical stability problem. :param local_scope: The local scope used for get_numeric_gradient. @@ -229,9 +229,9 @@ class GradientChecker(unittest.TestCase): """Use relative error for the comparison. :param numeric_grads: the numerical graidents. - :type numeric_grads: a list of numpy.array + :type numeric_grads: a list of numpy.array :param analytic_grads: the analytical graidents. - :type analytic_grads: a list of numpy.array + :type analytic_grads: a list of numpy.array :param name: the names of gradients, used to print for debug. :type names: a list of string :param msg_prefix: string info, used to print for debug. @@ -304,6 +304,13 @@ class GradientChecker(unittest.TestCase): # get analytical gradients according to different device analytic_grads = self.__get_gradient(forward_op, backward_op, input_vars, check_names, place) + #print(numeric_grads[0], numeric_grads[0].shape) + print("dim0: ", numeric_grads[0], numeric_grads[0].shape) + print("dim0: ", analytic_grads[0], analytic_grads[0].shape) + print("---------------------") + print("dim1: ", numeric_grads[1], numeric_grads[1].shape) + print("dim1: ", analytic_grads[1], analytic_grads[1].shape) + assert False self.__assert_is_close(numeric_grads, analytic_grads, check_names, max_relative_error, "Gradient Check On %s" % str(place)) diff --git a/python/paddle/v2/framework/tests/op_test_util.py b/python/paddle/v2/framework/tests/op_test_util.py index 3bc05a0fec..a4899355b5 100644 --- a/python/paddle/v2/framework/tests/op_test_util.py +++ b/python/paddle/v2/framework/tests/op_test_util.py @@ -6,13 +6,13 @@ from paddle.v2.framework.op import Operator class OpTestMeta(type): """ Operator Test ClassMeta. - - It injects `test_all` method into user's OperatorTest class, to make Python + + It injects `test_all` method into user's OperatorTest class, to make Python unittest module run that method. - + The `test_all` read what value is stored in `self`. It use self's values to create and run a operator, and check whether that op is OK or not. - + See `test_add_two_op` for example usage. """ diff --git a/python/paddle/v2/framework/tests/test_cos_sim_op.py b/python/paddle/v2/framework/tests/test_cos_sim_op.py new file mode 100644 index 0000000000..f3b04d25f2 --- /dev/null +++ b/python/paddle/v2/framework/tests/test_cos_sim_op.py @@ -0,0 +1,40 @@ +import unittest +import numpy as np +from gradient_checker import GradientChecker, create_op +from op_test_util import OpTestMeta + + +class TestCosSimOp(unittest.TestCase): + __metaclass__ = OpTestMeta + + def setUp(self): + self.type = "cos_sim" + self.inputs = { + 'X': np.random.random((32, 84)).astype("float32"), + 'Y': np.random.random((32, 84)).astype("float32") + } + expect = (self.inputs['X'] * self.inputs['Y']).sum(axis=1) / \ + np.linalg.norm(self.inputs['X'], axis=1) / \ + np.linalg.norm(self.inputs['Y'], axis=1) + expect = np.expand_dims(expect, 1) + self.outputs = {'Out': expect} + + +class CosSimGradOpTest(GradientChecker): + def test_cos_sim(self): + op = create_op("cos_sim") + #inputs = { + #'X': np.random.random((2, 2)).astype("float32"), + #'Y': np.random.random((2, 2)).astype("float32") + #} + inputs = { + 'X': np.array([[0.9, 0.6], [1.9, 1.6]]).astype("float32"), + 'Y': np.array([[0.7, 0.8], [1.7, 1.8]]).astype("float32") + } + print(inputs) + self.check_grad( + op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.5) + + +if __name__ == '__main__': + unittest.main() From 9d2909be2abcb9b8728f7c4de7437c07a1254b8b Mon Sep 17 00:00:00 2001 From: Luo Tao Date: Fri, 1 Sep 2017 19:27:52 +0800 Subject: [PATCH 09/62] rename add_op to add_two_op --- paddle/framework/CMakeLists.txt | 2 +- paddle/operators/{add_op.cc => add_two_op.cc} | 2 +- paddle/operators/{add_op.cu => add_two_op.cu} | 2 +- paddle/operators/{add_op.h => add_two_op.h} | 0 4 files changed, 3 insertions(+), 3 deletions(-) rename paddle/operators/{add_op.cc => add_two_op.cc} (98%) rename paddle/operators/{add_op.cu => add_two_op.cu} (95%) rename paddle/operators/{add_op.h => add_two_op.h} (100%) diff --git a/paddle/framework/CMakeLists.txt b/paddle/framework/CMakeLists.txt index c0838d9b75..e138517b6b 100644 --- a/paddle/framework/CMakeLists.txt +++ b/paddle/framework/CMakeLists.txt @@ -25,7 +25,7 @@ cc_test(operator_test SRCS operator_test.cc DEPS operator op_registry) cc_library(grad_op_builder SRCS grad_op_builder.cc DEPS operator) cc_library(op_registry SRCS op_registry.cc DEPS grad_op_builder) cc_test(op_registry_test SRCS op_registry_test.cc DEPS op_registry) -cc_test(grad_op_builder_test SRCS grad_op_builder_test.cc DEPS grad_op_builder op_registry add_op) +cc_test(grad_op_builder_test SRCS grad_op_builder_test.cc DEPS grad_op_builder op_registry add_two_op) py_proto_compile(framework_py_proto SRCS framework.proto) # Generate an empty __init__.py to make framework_py_proto as a valid python module. diff --git a/paddle/operators/add_op.cc b/paddle/operators/add_two_op.cc similarity index 98% rename from paddle/operators/add_op.cc rename to paddle/operators/add_two_op.cc index 8ab748ed71..bc99e306e0 100644 --- a/paddle/operators/add_op.cc +++ b/paddle/operators/add_two_op.cc @@ -12,7 +12,7 @@ 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/add_op.h" +#include "paddle/operators/add_two_op.h" namespace paddle { namespace operators { diff --git a/paddle/operators/add_op.cu b/paddle/operators/add_two_op.cu similarity index 95% rename from paddle/operators/add_op.cu rename to paddle/operators/add_two_op.cu index cec5f558cb..acc03b2c8b 100644 --- a/paddle/operators/add_op.cu +++ b/paddle/operators/add_two_op.cu @@ -14,7 +14,7 @@ #define EIGEN_USE_GPU #include "paddle/framework/op_registry.h" -#include "paddle/operators/add_op.h" +#include "paddle/operators/add_two_op.h" namespace ops = paddle::operators; REGISTER_OP_GPU_KERNEL(add_two, diff --git a/paddle/operators/add_op.h b/paddle/operators/add_two_op.h similarity index 100% rename from paddle/operators/add_op.h rename to paddle/operators/add_two_op.h From c33ddc74c1062af7585b6d923acbbcc6299335a5 Mon Sep 17 00:00:00 2001 From: yangyaming Date: Fri, 1 Sep 2017 23:00:15 +0800 Subject: [PATCH 10/62] Fix some bugs, add more unittests. --- paddle/operators/squared_l2_distance_op.cc | 8 ++- paddle/operators/squared_l2_distance_op.h | 19 ++--- .../tests/test_squared_l2_distance_op.py | 72 ++++++++++++++++--- 3 files changed, 79 insertions(+), 20 deletions(-) diff --git a/paddle/operators/squared_l2_distance_op.cc b/paddle/operators/squared_l2_distance_op.cc index b19c274dcc..694b00e493 100644 --- a/paddle/operators/squared_l2_distance_op.cc +++ b/paddle/operators/squared_l2_distance_op.cc @@ -49,7 +49,9 @@ class SquaredL2DistanceOp : public framework::OperatorWithKernel { "First dimension of target must be equal to input " "or to 1."); - ctx.Output("sub_result")->Resize(x_dims); + ctx.Output("sub_result") + ->Resize({static_cast(x_dims[0]), + static_cast(framework::product(x_dims) / x_dims[0])}); ctx.Output("Out")->Resize({x_dims[0], 1}); } }; @@ -97,8 +99,8 @@ class SquaredL2DistanceGradOp : public framework::OperatorWithKernel { "must be 1."); auto* x_grad = ctx.Output(framework::GradVarName("X")); auto* y_grad = ctx.Output(framework::GradVarName("Y")); - if (x_grad != nullptr) x_grad->Resize(x_dims); - if (y_grad != nullptr) y_grad->Resize(y_dims); + if (x_grad) x_grad->Resize(x_dims); + if (y_grad) y_grad->Resize(y_dims); } }; diff --git a/paddle/operators/squared_l2_distance_op.h b/paddle/operators/squared_l2_distance_op.h index ec8c34ddf8..97907768f7 100644 --- a/paddle/operators/squared_l2_distance_op.h +++ b/paddle/operators/squared_l2_distance_op.h @@ -53,14 +53,16 @@ class SquaredL2DistanceKernel : public framework::OpKernel { auto y_dims = y.dimensions(); // buffer the substraction result if (y_dims[0] == 1 && x_dims[0] > y_dims[0]) { - auto y_broadcast_dims = y_dims; - y_broadcast_dims[0] = x_dims[0]; - sub_result.device(place) = x - y.broadcast(y_broadcast_dims); + sub_result.device(place) = + x - + y.broadcast(Eigen::array({static_cast(x_dims[0]), 1})); } else { sub_result.device(place) = x - y; } - - z.device(place) = sub_result.pow(2).sum(Eigen::array({1})); + auto sub_res_pow2 = sub_result * sub_result; + z.device(place) = + sub_res_pow2.sum(Eigen::array({1})) + .reshape(Eigen::array({static_cast(x_dims[0]), 1})); } }; @@ -86,7 +88,7 @@ class SquaredL2DistanceGradKernel : public framework::OpKernel { // propagate back to input auto eigen_place = context.GetEigenDevice(); - if (x_g != nullptr) { + if (x_g) { x_g->mutable_data(context.GetPlace()); // eigen matrix auto x_grad = @@ -95,7 +97,7 @@ class SquaredL2DistanceGradKernel : public framework::OpKernel { x_grad.device(eigen_place) = grad_mat; } - if (y_g != nullptr) { + if (y_g) { y_g->mutable_data(context.GetPlace()); auto y_grad = EigenMatrix::From(*y_g, framework::make_ddim({y_dims[0], cols})); @@ -107,8 +109,9 @@ class SquaredL2DistanceGradKernel : public framework::OpKernel { if (sub_result.dimensions()[0] == y_dims[0]) { y_grad.device(eigen_place) = -1 * grad_mat; } else { + auto col_sum_res = -1 * (grad_mat.sum(Eigen::array({0}))); y_grad.device(eigen_place) = - -1 * (grad_mat.sum(Eigen::array({0}))); + col_sum_res.reshape(Eigen::array({1, cols})); } } } diff --git a/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py b/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py index 51c95b286a..2bcdf37df4 100644 --- a/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py +++ b/python/paddle/v2/framework/tests/test_squared_l2_distance_op.py @@ -4,30 +4,84 @@ from gradient_checker import GradientChecker, create_op import numpy as np -class TestSquaredL2DistanceOp(unittest.TestCase): +class TestSquaredL2DistanceOp_f0(unittest.TestCase): __metaclass__ = OpTestMeta def setUp(self): self.type = 'squared_l2_distance' self.inputs = { - 'X': np.random.uniform(0.1, 1., (2, 3)).astype('float32'), - 'Y': np.random.uniform(0.1, 1., (2, 3)).astype('float32') + 'X': np.random.uniform(0.1, 1., (32, 64)).astype('float32'), + 'Y': np.random.uniform(0.1, 1., (32, 64)).astype('float32') } - subRes = self.inputs['X'] - self.inputs['Y'] - output = subRes * subRes + sub_res = self.inputs['X'] - self.inputs['Y'] + output = sub_res * sub_res self.outputs = { - 'sub_result': subRes, + 'sub_result': sub_res, + 'Out': np.expand_dims(output.sum(1), 1) + } + + +class TestSquaredL2DistanceOp_f1(unittest.TestCase): + __metaclass__ = OpTestMeta + + def setUp(self): + self.type = 'squared_l2_distance' + self.inputs = { + 'X': np.random.uniform(0.1, 1., (32, 64)).astype('float32'), + 'Y': np.random.uniform(0.1, 1., (1, 64)).astype('float32') + } + sub_res = self.inputs['X'] - self.inputs['Y'] + output = sub_res * sub_res + self.outputs = { + 'sub_result': sub_res, + 'Out': np.expand_dims(output.sum(1), 1) + } + + +class TestSquaredL2DistanceOp_f2(unittest.TestCase): + __metaclass__ = OpTestMeta + + def setUp(self): + self.type = 'squared_l2_distance' + self.inputs = { + 'X': np.random.uniform(0.1, 1., (32, 64, 128)).astype('float32'), + 'Y': np.random.uniform(0.1, 1., (1, 64, 128)).astype('float32') + } + sub_res = self.inputs['X'] - self.inputs['Y'] + sub_res = sub_res.reshape((32, 64 * 128)) + output = sub_res * sub_res + self.outputs = { + 'sub_result': sub_res, 'Out': np.expand_dims(output.sum(1), 1) } class TestSquaredL2DistanceGradOp(GradientChecker): - def test_squared_l2_distance(self): + def test_squared_l2_distance_b0(self): + op = create_op("squared_l2_distance") + inputs = { + 'X': np.random.uniform(0.1, .6, (2, 3)).astype('float32'), + 'Y': np.random.uniform(0.1, .6, (2, 3)).astype('float32') + } + self.compare_grad(op, inputs) + self.check_grad(op, inputs, set(["X", "Y"]), "Out") + + def test_squared_l2_distance_b1(self): + op = create_op("squared_l2_distance") + inputs = { + 'X': np.random.uniform(0.1, .6, (2, 3)).astype('float32'), + 'Y': np.random.uniform(0.1, .6, (1, 3)).astype('float32') + } + self.compare_grad(op, inputs) + self.check_grad(op, inputs, set(["X", "Y"]), "Out") + + def test_squared_l2_distance_b2(self): op = create_op("squared_l2_distance") inputs = { - 'X': np.random.uniform(0.1, 1., (2, 3)).astype('float32'), - 'Y': np.random.uniform(0.1, 1., (2, 3)).astype('float32') + 'X': np.random.uniform(0.1, .6, (2, 3, 4)).astype('float32'), + 'Y': np.random.uniform(0.1, .6, (1, 3, 4)).astype('float32') } + self.compare_grad(op, inputs) self.check_grad(op, inputs, set(["X", "Y"]), "Out") From 91215bcef907baffdf52bb7894a0a33d0253c16f Mon Sep 17 00:00:00 2001 From: Xinghai Sun Date: Sat, 2 Sep 2017 17:25:30 +0800 Subject: [PATCH 11/62] Fix a bug causing wrong gradient results in cos_sim op. --- paddle/operators/cos_sim_op.cc | 32 ++++++++++---- paddle/operators/cos_sim_op.h | 34 +++++++++------ .../v2/framework/tests/gradient_checker.py | 7 ---- .../v2/framework/tests/test_cos_sim_op.py | 42 ++++++++++++------- 4 files changed, 71 insertions(+), 44 deletions(-) diff --git a/paddle/operators/cos_sim_op.cc b/paddle/operators/cos_sim_op.cc index 21a616522b..3760d0b161 100644 --- a/paddle/operators/cos_sim_op.cc +++ b/paddle/operators/cos_sim_op.cc @@ -25,14 +25,16 @@ class CosSimOp : public framework::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("Y"), "Input(Y) should not be null."); + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"), "Input(X) must not be null."); + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Y"), "Input(Y) must not be null."); PADDLE_ENFORCE_EQ(ctx.Input("X")->dims(), ctx.Input("Y")->dims(), "Dimensions of Input(X) and Input(Y) must be the same."); auto dims = ctx.Input("X")->dims(); ctx.Output("Out")->Resize({dims[0], 1}); + ctx.Output("XNorm")->Resize({dims[0], 1}); + ctx.Output("YNorm")->Resize({dims[0], 1}); } }; @@ -43,6 +45,9 @@ class CosSimOpMaker : public framework::OpProtoAndCheckerMaker { AddInput("X", "The first input of cos_sim op."); AddInput("Y", "The second input of cos_sim op."); AddOutput("Out", "The output of cos_sim op."); + AddOutput("XNorm", "Row norm of the first input.").AsIntermediate(); + AddOutput("YNorm", "Row norm of the second input.").AsIntermediate(); + AddComment(R"DOC( Cosine Similarity Operator. @@ -57,20 +62,31 @@ class CosSimOpGrad : public framework::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("Y"), "Input(Y) should not be null."); + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("X"), "Input(X) must not be null."); + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("Y"), "Input(Y) must not be null."); + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("XNorm"), + "Input(XNorm) must not be null."); + PADDLE_ENFORCE_NOT_NULL(ctx.InputVar("YNorm"), + "Input(YNorm) must not be null."); PADDLE_ENFORCE_NOT_NULL(ctx.InputVar(framework::GradVarName("Out")), - "Input(Out@GRAD) should not be null."); + "Input(Out@GRAD) must not be null."); auto x_dims = ctx.Input("X")->dims(); auto y_dims = ctx.Input("Y")->dims(); + auto xnorm_dims = ctx.Input("XNorm")->dims(); + auto ynorm_dims = ctx.Input("YNorm")->dims(); auto out_dims = ctx.Input(framework::GradVarName("Out"))->dims(); PADDLE_ENFORCE_EQ(x_dims, y_dims, "Dimensions of Input(X) and Input(Y) must be the same."); + PADDLE_ENFORCE_EQ(xnorm_dims[0], x_dims[0], + "1st dimension of XNorm must equal that of Input(X)."); + PADDLE_ENFORCE_EQ(xnorm_dims[1], 1, "2st dimension of XNorm must be one."); + PADDLE_ENFORCE_EQ(ynorm_dims[0], y_dims[0], + "1st dimension of YNorm must equal that of Input(Y)."); + PADDLE_ENFORCE_EQ(ynorm_dims[1], 1, "2st dimension of YNorm must be one."); PADDLE_ENFORCE_EQ(out_dims[0], x_dims[0], - "1st dimension of Out@GRAD must equal to Input(X)"); - PADDLE_ENFORCE_EQ(out_dims[1], 1, - "1st dimension of Out@GRAD must equal to Input(X)"); + "1st dimension of Out@GRAD must equal that of Input(X)"); + PADDLE_ENFORCE_EQ(out_dims[1], 1, "1st dimension of Out@GRAD must be one."); auto *x_grad = ctx.Output(framework::GradVarName("X")); auto *y_grad = ctx.Output(framework::GradVarName("Y")); diff --git a/paddle/operators/cos_sim_op.h b/paddle/operators/cos_sim_op.h index 5247087cc1..69d35d8bc2 100644 --- a/paddle/operators/cos_sim_op.h +++ b/paddle/operators/cos_sim_op.h @@ -31,21 +31,27 @@ class CosSimKernel : public framework::OpKernel { auto* x = context.Input("X"); auto* y = context.Input("Y"); auto* z = context.Output("Out"); + auto* x_norm = context.Output("XNorm"); + auto* y_norm = context.Output("YNorm"); z->mutable_data(context.GetPlace()); + x_norm->mutable_data(context.GetPlace()); + y_norm->mutable_data(context.GetPlace()); auto dims = x->dims(); int size = static_cast(framework::product(dims)); auto new_dims = framework::make_ddim({dims[0], size / dims[0]}); auto X = EigenMatrix::From(*x, new_dims); auto Y = EigenMatrix::From(*y, new_dims); - auto Z = EigenMatrix::From(*z, new_dims); + auto Z = EigenMatrix::From(*z); + auto XNorm = EigenMatrix::From(*x_norm); + auto YNorm = EigenMatrix::From(*y_norm); - auto XY = (X * Y).sum(Eigen::array({1})); - auto XX = (X * X).sum(Eigen::array({1})); - auto YY = (Y * Y).sum(Eigen::array({1})); auto place = context.GetEigenDevice(); - Z.device(place) = XY / XX.sqrt() / YY.sqrt(); + auto XY = (X * Y).sum(Eigen::array({1})); + XNorm.device(place) = (X * X).sum(Eigen::array({1})).sqrt(); + YNorm.device(place) = (Y * Y).sum(Eigen::array({1})).sqrt(); + Z.device(place) = XY / XNorm / YNorm; } }; @@ -56,6 +62,8 @@ class CosSimGradKernel : public framework::OpKernel { auto* x = context.Input("X"); auto* y = context.Input("Y"); auto* z = context.Input("Out"); + auto* x_norm = context.Input("XNorm"); + auto* y_norm = context.Input("YNorm"); auto* grad_x = context.Output(framework::GradVarName("X")); auto* grad_y = context.Output(framework::GradVarName("Y")); auto* grad_z = context.Input(framework::GradVarName("Out")); @@ -69,23 +77,23 @@ class CosSimGradKernel : public framework::OpKernel { auto X = EigenMatrix::From(*x, new_dims); auto Y = EigenMatrix::From(*y, new_dims); auto Z = EigenMatrix::From(*z); + auto X_norm = EigenMatrix::From(*x_norm); + auto Y_norm = EigenMatrix::From(*y_norm); auto dX = EigenMatrix::From(*grad_x, new_dims); auto dY = EigenMatrix::From(*grad_y, new_dims); auto dZ = EigenMatrix::From(*grad_z); - auto XX = (X * X).sum(Eigen::array({1})); - auto YY = (Y * Y).sum(Eigen::array({1})); - Eigen::DSizes bcast(1, dims[1]); - auto denominator_bcast = (XX.sqrt() * YY.sqrt()).broadcast(bcast); + Eigen::DSizes bcast(1, new_dims[1]); auto Z_bcast = Z.broadcast(bcast); auto dZ_bcast = dZ.broadcast(bcast); auto place = context.GetEigenDevice(); + auto X_snorm_bcast = X_norm.square().eval().broadcast(bcast); + auto Y_snorm_bcast = Y_norm.square().eval().broadcast(bcast); + auto norm_prod_bcast = (X_norm * Y_norm).eval().broadcast(bcast); dX.device(place) = - dZ_bcast * (Y / denominator_bcast - Z_bcast * X / XX.broadcast(bcast)); + dZ_bcast * (Y / norm_prod_bcast - Z_bcast * X / X_snorm_bcast); dY.device(place) = - dZ_bcast * (X / denominator_bcast - Z_bcast * Y / YY.broadcast(bcast)); - // dX.device(place) = X; - // Y.device(place) = Y; + dZ_bcast * (X / norm_prod_bcast - Z_bcast * Y / Y_snorm_bcast); } }; diff --git a/python/paddle/v2/framework/tests/gradient_checker.py b/python/paddle/v2/framework/tests/gradient_checker.py index bf01ea4876..409b3caf33 100644 --- a/python/paddle/v2/framework/tests/gradient_checker.py +++ b/python/paddle/v2/framework/tests/gradient_checker.py @@ -304,13 +304,6 @@ class GradientChecker(unittest.TestCase): # get analytical gradients according to different device analytic_grads = self.__get_gradient(forward_op, backward_op, input_vars, check_names, place) - #print(numeric_grads[0], numeric_grads[0].shape) - print("dim0: ", numeric_grads[0], numeric_grads[0].shape) - print("dim0: ", analytic_grads[0], analytic_grads[0].shape) - print("---------------------") - print("dim1: ", numeric_grads[1], numeric_grads[1].shape) - print("dim1: ", analytic_grads[1], analytic_grads[1].shape) - assert False self.__assert_is_close(numeric_grads, analytic_grads, check_names, max_relative_error, "Gradient Check On %s" % str(place)) diff --git a/python/paddle/v2/framework/tests/test_cos_sim_op.py b/python/paddle/v2/framework/tests/test_cos_sim_op.py index f3b04d25f2..a19be47f76 100644 --- a/python/paddle/v2/framework/tests/test_cos_sim_op.py +++ b/python/paddle/v2/framework/tests/test_cos_sim_op.py @@ -10,30 +10,40 @@ class TestCosSimOp(unittest.TestCase): def setUp(self): self.type = "cos_sim" self.inputs = { - 'X': np.random.random((32, 84)).astype("float32"), - 'Y': np.random.random((32, 84)).astype("float32") + 'X': np.random.random((32, 64)).astype("float32"), + 'Y': np.random.random((32, 64)).astype("float32") + } + expect_x_norm = np.linalg.norm(self.inputs['X'], axis=1) + expect_y_norm = np.linalg.norm(self.inputs['Y'], axis=1) + expect_out = (self.inputs['X'] * self.inputs['Y']).sum(axis=1) / \ + expect_x_norm / expect_y_norm + self.outputs = { + 'XNorm': np.expand_dims(expect_x_norm, 1), + 'YNorm': np.expand_dims(expect_y_norm, 1), + 'Out': np.expand_dims(expect_out, 1) } - expect = (self.inputs['X'] * self.inputs['Y']).sum(axis=1) / \ - np.linalg.norm(self.inputs['X'], axis=1) / \ - np.linalg.norm(self.inputs['Y'], axis=1) - expect = np.expand_dims(expect, 1) - self.outputs = {'Out': expect} class CosSimGradOpTest(GradientChecker): - def test_cos_sim(self): + def test_cos_sim_2d(self): + op = create_op("cos_sim") + inputs = { + 'X': np.random.random((10, 5)).astype("float32"), + 'Y': np.random.random((10, 5)).astype("float32") + } + self.compare_grad(op, inputs) + self.check_grad( + op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.05) + + def test_cos_sim_3d(self): op = create_op("cos_sim") - #inputs = { - #'X': np.random.random((2, 2)).astype("float32"), - #'Y': np.random.random((2, 2)).astype("float32") - #} inputs = { - 'X': np.array([[0.9, 0.6], [1.9, 1.6]]).astype("float32"), - 'Y': np.array([[0.7, 0.8], [1.7, 1.8]]).astype("float32") + 'X': np.random.random((10, 5, 2)).astype("float32"), + 'Y': np.random.random((10, 5, 2)).astype("float32") } - print(inputs) + self.compare_grad(op, inputs) self.check_grad( - op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.5) + op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.05) if __name__ == '__main__': From 6fcdc91638c226209aae1244c9dcaf6882378dca Mon Sep 17 00:00:00 2001 From: qiaolongfei Date: Sat, 2 Sep 2017 13:30:58 -0700 Subject: [PATCH 12/62] add op() to InferShapeContext --- paddle/framework/operator.h | 5 +++++ paddle/framework/operator_test.cc | 12 ++++++------ paddle/operators/gaussian_random_op.cc | 6 +++--- paddle/operators/mul_op.cc | 4 ++-- paddle/operators/scale_op.h | 2 +- paddle/operators/sgd_op.h | 2 +- paddle/operators/uniform_random_op.cc | 6 +++--- 7 files changed, 21 insertions(+), 16 deletions(-) diff --git a/paddle/framework/operator.h b/paddle/framework/operator.h index 8397570d26..9874a7c295 100644 --- a/paddle/framework/operator.h +++ b/paddle/framework/operator.h @@ -229,6 +229,10 @@ class InferShapeContext { InferShapeContext(const OperatorBase& op, const Scope& scope) : op_(op), scope_(scope) {} + const OperatorBase& op() const { return op_; } + + const Scope& scope() const { return scope_; } + size_t InputSize(const std::string& name) const { return op_.Inputs(name).size(); } @@ -312,6 +316,7 @@ class InferShapeContext { return res; } + private: const OperatorBase& op_; const Scope& scope_; }; diff --git a/paddle/framework/operator_test.cc b/paddle/framework/operator_test.cc index 1d7efb7b94..f7c9e6b196 100644 --- a/paddle/framework/operator_test.cc +++ b/paddle/framework/operator_test.cc @@ -122,10 +122,10 @@ class CPUKernelTest : public OpKernel { public: void Compute(const ExecutionContext& ctx) const { std::cout << "this is cpu kernel" << std::endl; - std::cout << ctx.op_.DebugString() << std::endl; + std::cout << ctx.op().DebugString() << std::endl; cpu_kernel_run_num++; - ASSERT_EQ(ctx.op_.Input("x"), "IN1"); - ASSERT_EQ(ctx.op_.Output("y"), "OUT1"); + ASSERT_EQ(ctx.op().Input("x"), "IN1"); + ASSERT_EQ(ctx.op().Output("y"), "OUT1"); } }; @@ -148,7 +148,7 @@ class OpKernelTestMultiInputsProtoAndCheckerMaker class CPUKernalMultiInputsTest : public OpKernel { public: void Compute(const ExecutionContext& ctx) const { - auto xs = ctx.op_.Inputs("xs"); + auto xs = ctx.op().Inputs("xs"); ASSERT_EQ(xs.size(), 3UL); ASSERT_EQ(xs[0], "x0"); ASSERT_EQ(xs[1], "x1"); @@ -172,10 +172,10 @@ class CPUKernalMultiInputsTest : public OpKernel { auto outTensor0 = ctx.MultiOutput("ys"); ASSERT_EQ(outTensor0.size(), 2U); - auto k = ctx.op_.Input("k"); + auto k = ctx.op().Input("k"); ASSERT_EQ(k, "k0"); - auto ys = ctx.op_.Outputs("ys"); + auto ys = ctx.op().Outputs("ys"); ASSERT_EQ(ys.size(), 2UL); ASSERT_EQ(ys[0], "y0"); ASSERT_EQ(ys[1], "y1"); diff --git a/paddle/operators/gaussian_random_op.cc b/paddle/operators/gaussian_random_op.cc index a85363ad81..9eb976fed1 100644 --- a/paddle/operators/gaussian_random_op.cc +++ b/paddle/operators/gaussian_random_op.cc @@ -19,13 +19,13 @@ template class CPUGaussianRandomKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - float mean = context.op_.GetAttr("mean"); - float std = context.op_.GetAttr("std"); + float mean = context.op().GetAttr("mean"); + float std = context.op().GetAttr("std"); auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); unsigned int seed = - static_cast(context.op_.GetAttr("seed")); + static_cast(context.op().GetAttr("seed")); std::minstd_rand engine; if (seed == 0) { seed = std::random_device()(); diff --git a/paddle/operators/mul_op.cc b/paddle/operators/mul_op.cc index 173cc3850c..5b8b5f6c11 100644 --- a/paddle/operators/mul_op.cc +++ b/paddle/operators/mul_op.cc @@ -29,10 +29,10 @@ class MulOp : public framework::OperatorWithKernel { auto dim1 = ctx.Input("Y")->dims(); PADDLE_ENFORCE_EQ(dim0.size(), 2, "input X(%s) should be a tensor with 2 dims, a matrix", - ctx.op_.Input("X")); + ctx.op().Input("X")); PADDLE_ENFORCE_EQ(dim1.size(), 2, "input Y(%s) should be a tensor with 2 dims, a matrix", - ctx.op_.Input("Y")); + ctx.op().Input("Y")); PADDLE_ENFORCE_EQ( dim0[1], dim1[0], "First matrix's width must be equal with second matrix's height."); diff --git a/paddle/operators/scale_op.h b/paddle/operators/scale_op.h index aea64f1b04..760b26f5e9 100644 --- a/paddle/operators/scale_op.h +++ b/paddle/operators/scale_op.h @@ -27,7 +27,7 @@ class ScaleKernel : public framework::OpKernel { auto* in = context.Input("X"); tensor->mutable_data(in->place()); - auto scale = static_cast(context.op_.GetAttr("scale")); + auto scale = static_cast(context.op().GetAttr("scale")); auto eigen_out = framework::EigenVector::Flatten(*tensor); auto eigen_in = framework::EigenVector::Flatten(*in); diff --git a/paddle/operators/sgd_op.h b/paddle/operators/sgd_op.h index a0b5000ffb..b54a7864b0 100644 --- a/paddle/operators/sgd_op.h +++ b/paddle/operators/sgd_op.h @@ -31,7 +31,7 @@ class SGDOpKernel : public framework::OpKernel { auto param = ctx.Input("param"); auto grad = ctx.Input("grad"); auto param_out = ctx.Output("param_out"); - float lr = ctx.op_.GetAttr("learning_rate"); + float lr = ctx.op().GetAttr("learning_rate"); param_out->mutable_data(ctx.GetPlace()); diff --git a/paddle/operators/uniform_random_op.cc b/paddle/operators/uniform_random_op.cc index 29491137e6..dbff2a1365 100644 --- a/paddle/operators/uniform_random_op.cc +++ b/paddle/operators/uniform_random_op.cc @@ -27,15 +27,15 @@ class CPUUniformRandomKernel : public framework::OpKernel { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); unsigned int seed = - static_cast(context.op_.GetAttr("seed")); + static_cast(context.op().GetAttr("seed")); std::minstd_rand engine; if (seed == 0) { seed = std::random_device()(); } engine.seed(seed); std::uniform_real_distribution dist( - static_cast(context.op_.GetAttr("min")), - static_cast(context.op_.GetAttr("max"))); + static_cast(context.op().GetAttr("min")), + static_cast(context.op().GetAttr("max"))); ssize_t size = framework::product(tensor->dims()); for (ssize_t i = 0; i < size; ++i) { data[i] = dist(engine); From 848c317aa84aea797654a3f0ee7a2db0fb0e8d09 Mon Sep 17 00:00:00 2001 From: qiaolongfei Date: Sat, 2 Sep 2017 14:13:05 -0700 Subject: [PATCH 13/62] update gpu code --- paddle/operators/gaussian_random_op.cu | 6 +++--- paddle/operators/uniform_random_op.cu | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/paddle/operators/gaussian_random_op.cu b/paddle/operators/gaussian_random_op.cu index 018a4bfcb2..9769fbcd2b 100644 --- a/paddle/operators/gaussian_random_op.cu +++ b/paddle/operators/gaussian_random_op.cu @@ -43,13 +43,13 @@ class GPUGaussianRandomKernel : public framework::OpKernel { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); unsigned int seed = - static_cast(context.op_.GetAttr("seed")); + static_cast(context.op().GetAttr("seed")); if (seed == 0) { std::random_device rd; seed = rd(); } - T mean = static_cast(context.op_.GetAttr("mean")); - T std = static_cast(context.op_.GetAttr("std")); + T mean = static_cast(context.op().GetAttr("mean")); + T std = static_cast(context.op().GetAttr("std")); thrust::counting_iterator index_sequence_begin(0); ssize_t N = framework::product(tensor->dims()); thrust::transform(index_sequence_begin, index_sequence_begin + N, diff --git a/paddle/operators/uniform_random_op.cu b/paddle/operators/uniform_random_op.cu index 1d6709934c..fc8397f134 100644 --- a/paddle/operators/uniform_random_op.cu +++ b/paddle/operators/uniform_random_op.cu @@ -46,13 +46,13 @@ class GPUUniformRandomKernel : public framework::OpKernel { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); unsigned int seed = - static_cast(context.op_.GetAttr("seed")); + static_cast(context.op().GetAttr("seed")); if (seed == 0) { std::random_device rd; seed = rd(); } - T min = static_cast(context.op_.GetAttr("min")); - T max = static_cast(context.op_.GetAttr("max")); + T min = static_cast(context.op().GetAttr("min")); + T max = static_cast(context.op().GetAttr("max")); thrust::counting_iterator index_sequence_begin(0); ssize_t N = framework::product(tensor->dims()); thrust::transform(index_sequence_begin, index_sequence_begin + N, From 879866cc565ed5e2fe76e92bcb2268c6916f7ffd Mon Sep 17 00:00:00 2001 From: Zhuo Zhang Date: Sun, 3 Sep 2017 15:57:14 +0800 Subject: [PATCH 14/62] add PyDataProvider2.InputType pretty print function --- python/paddle/trainer/PyDataProvider2.py | 35 ++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/python/paddle/trainer/PyDataProvider2.py b/python/paddle/trainer/PyDataProvider2.py index 7e305e2cd9..033c71cf8f 100644 --- a/python/paddle/trainer/PyDataProvider2.py +++ b/python/paddle/trainer/PyDataProvider2.py @@ -27,6 +27,14 @@ class SequenceType(object): SEQUENCE = 1 SUB_SEQUENCE = 2 + @classmethod + def tostring(cls, value): + for k in cls.__dict__: + if not k.startswith('__'): + if getattr(cls, k) == value: + return cls.__name__ + '.' + k + return 'INVALID(' + str(value) + ')' + # TODO(yuyang18): Add string data type here. class DataType(object): @@ -35,6 +43,14 @@ class DataType(object): SparseValue = 2 Index = 3 + @classmethod + def tostring(cls, value): + for k in cls.__dict__: + if not k.startswith('__'): + if getattr(cls, k) == value: + return cls.__name__ + '.' + k + return 'INVALID(' + str(value) + ')' + class CacheType(object): NO_CACHE = 0 # No cache at all @@ -69,6 +85,25 @@ class InputType(object): self.seq_type = seq_type self.type = tp + def __repr__(self): + """ + Return a human readable representation like 'InputType(dim=25921, seq_type=SequenceType.NO_SEQUENCE, type=DataType.Dense)' + """ + repr_str = type(self).__name__ + repr_str += '(' + serialize_func_map = { + 'dim': repr, + 'seq_type': SequenceType.tostring, + 'type': DataType.tostring + } + for idx, k in enumerate(self.__slots__): + if idx != 0: + repr_str += ', ' + repr_str += ( + k + '=' + serialize_func_map.get(k, repr)(getattr(self, k))) + repr_str += ')' + return repr_str + def dense_slot(dim, seq_type=SequenceType.NO_SEQUENCE): """ From d323831a0bee005a5f58d13d2691eaa338cc6d38 Mon Sep 17 00:00:00 2001 From: qiaolongfei Date: Sun, 3 Sep 2017 12:13:22 -0700 Subject: [PATCH 15/62] add GetAttr to InferShapeContext --- paddle/framework/operator.h | 5 +++++ paddle/operators/gaussian_random_op.cc | 7 +++---- paddle/operators/gaussian_random_op.cu | 7 +++---- paddle/operators/scale_op.h | 2 +- paddle/operators/sgd_op.h | 2 +- paddle/operators/uniform_random_op.cc | 7 +++---- paddle/operators/uniform_random_op.cu | 7 +++---- 7 files changed, 19 insertions(+), 18 deletions(-) diff --git a/paddle/framework/operator.h b/paddle/framework/operator.h index 9874a7c295..29fa3ffd87 100644 --- a/paddle/framework/operator.h +++ b/paddle/framework/operator.h @@ -233,6 +233,11 @@ class InferShapeContext { const Scope& scope() const { return scope_; } + template + inline const T& GetAttr(const std::string& name) const { + return op_.GetAttr(name); + } + size_t InputSize(const std::string& name) const { return op_.Inputs(name).size(); } diff --git a/paddle/operators/gaussian_random_op.cc b/paddle/operators/gaussian_random_op.cc index 9eb976fed1..056447901d 100644 --- a/paddle/operators/gaussian_random_op.cc +++ b/paddle/operators/gaussian_random_op.cc @@ -19,13 +19,12 @@ template class CPUGaussianRandomKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - float mean = context.op().GetAttr("mean"); - float std = context.op().GetAttr("std"); + float mean = context.GetAttr("mean"); + float std = context.GetAttr("std"); auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = - static_cast(context.op().GetAttr("seed")); + unsigned int seed = static_cast(context.GetAttr("seed")); std::minstd_rand engine; if (seed == 0) { seed = std::random_device()(); diff --git a/paddle/operators/gaussian_random_op.cu b/paddle/operators/gaussian_random_op.cu index 9769fbcd2b..833a82bbf2 100644 --- a/paddle/operators/gaussian_random_op.cu +++ b/paddle/operators/gaussian_random_op.cu @@ -42,14 +42,13 @@ class GPUGaussianRandomKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext& context) const override { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = - static_cast(context.op().GetAttr("seed")); + unsigned int seed = static_cast(context.GetAttr("seed")); if (seed == 0) { std::random_device rd; seed = rd(); } - T mean = static_cast(context.op().GetAttr("mean")); - T std = static_cast(context.op().GetAttr("std")); + T mean = static_cast(context.GetAttr("mean")); + T std = static_cast(context.GetAttr("std")); thrust::counting_iterator index_sequence_begin(0); ssize_t N = framework::product(tensor->dims()); thrust::transform(index_sequence_begin, index_sequence_begin + N, diff --git a/paddle/operators/scale_op.h b/paddle/operators/scale_op.h index 760b26f5e9..65fb77eefa 100644 --- a/paddle/operators/scale_op.h +++ b/paddle/operators/scale_op.h @@ -27,7 +27,7 @@ class ScaleKernel : public framework::OpKernel { auto* in = context.Input("X"); tensor->mutable_data(in->place()); - auto scale = static_cast(context.op().GetAttr("scale")); + auto scale = static_cast(context.GetAttr("scale")); auto eigen_out = framework::EigenVector::Flatten(*tensor); auto eigen_in = framework::EigenVector::Flatten(*in); diff --git a/paddle/operators/sgd_op.h b/paddle/operators/sgd_op.h index b54a7864b0..8422b622ee 100644 --- a/paddle/operators/sgd_op.h +++ b/paddle/operators/sgd_op.h @@ -31,7 +31,7 @@ class SGDOpKernel : public framework::OpKernel { auto param = ctx.Input("param"); auto grad = ctx.Input("grad"); auto param_out = ctx.Output("param_out"); - float lr = ctx.op().GetAttr("learning_rate"); + float lr = ctx.GetAttr("learning_rate"); param_out->mutable_data(ctx.GetPlace()); diff --git a/paddle/operators/uniform_random_op.cc b/paddle/operators/uniform_random_op.cc index dbff2a1365..2d943c4508 100644 --- a/paddle/operators/uniform_random_op.cc +++ b/paddle/operators/uniform_random_op.cc @@ -26,16 +26,15 @@ class CPUUniformRandomKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext& context) const override { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = - static_cast(context.op().GetAttr("seed")); + unsigned int seed = static_cast(context.GetAttr("seed")); std::minstd_rand engine; if (seed == 0) { seed = std::random_device()(); } engine.seed(seed); std::uniform_real_distribution dist( - static_cast(context.op().GetAttr("min")), - static_cast(context.op().GetAttr("max"))); + static_cast(context.GetAttr("min")), + static_cast(context.GetAttr("max"))); ssize_t size = framework::product(tensor->dims()); for (ssize_t i = 0; i < size; ++i) { data[i] = dist(engine); diff --git a/paddle/operators/uniform_random_op.cu b/paddle/operators/uniform_random_op.cu index fc8397f134..df993c0779 100644 --- a/paddle/operators/uniform_random_op.cu +++ b/paddle/operators/uniform_random_op.cu @@ -45,14 +45,13 @@ class GPUUniformRandomKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext& context) const override { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = - static_cast(context.op().GetAttr("seed")); + unsigned int seed = static_cast(context.GetAttr("seed")); if (seed == 0) { std::random_device rd; seed = rd(); } - T min = static_cast(context.op().GetAttr("min")); - T max = static_cast(context.op().GetAttr("max")); + T min = static_cast(context.GetAttr("min")); + T max = static_cast(context.GetAttr("max")); thrust::counting_iterator index_sequence_begin(0); ssize_t N = framework::product(tensor->dims()); thrust::transform(index_sequence_begin, index_sequence_begin + N, From 8c048aa0996f57c7a94d83c0bd043fa40fb3ab9f Mon Sep 17 00:00:00 2001 From: dangqingqing Date: Mon, 4 Sep 2017 11:15:45 +0800 Subject: [PATCH 16/62] Remove cudnn_helper.cc --- paddle/platform/CMakeLists.txt | 1 - paddle/platform/cudnn_helper.cc | 15 --------------- paddle/platform/cudnn_helper.h | 22 ---------------------- paddle/platform/cudnn_helper_test.cc | 3 +-- 4 files changed, 1 insertion(+), 40 deletions(-) delete mode 100644 paddle/platform/cudnn_helper.cc diff --git a/paddle/platform/CMakeLists.txt b/paddle/platform/CMakeLists.txt index 9a3ad8eb64..17bdac8749 100644 --- a/paddle/platform/CMakeLists.txt +++ b/paddle/platform/CMakeLists.txt @@ -23,5 +23,4 @@ cc_library(device_context SRCS device_context.cc DEPS memory buddy_allocator system_allocator memory_block meta_data meta_cache place eigen3 ${GPU_CTX_DEPS}) nv_test(device_context_test SRCS device_context_test.cc DEPS device_context gpu_info) -nv_library(cudnn_helper SRCS cudnn_helper.cc DEPS dynload_cuda) nv_test(cudnn_helper_test SRCS cudnn_helper_test.cc DEPS dynload_cuda) diff --git a/paddle/platform/cudnn_helper.cc b/paddle/platform/cudnn_helper.cc deleted file mode 100644 index 764285e2ba..0000000000 --- a/paddle/platform/cudnn_helper.cc +++ /dev/null @@ -1,15 +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/platform/cudnn_helper.h" diff --git a/paddle/platform/cudnn_helper.h b/paddle/platform/cudnn_helper.h index 6a43f49cfc..24ddf3441c 100644 --- a/paddle/platform/cudnn_helper.h +++ b/paddle/platform/cudnn_helper.h @@ -14,9 +14,6 @@ limitations under the License. */ #pragma once -#ifndef PADDLE_ONLY_CPU -#include -#include "glog/logging.h" #include "paddle/platform/dynload/cudnn.h" #include "paddle/platform/enforce.h" #include "paddle/platform/macros.h" @@ -42,30 +39,12 @@ template <> class CudnnDataType { public: static const cudnnDataType_t type = CUDNN_DATA_FLOAT; - typedef const float ScalingParamType; - static ScalingParamType* kOne() { - static ScalingParamType v = 1.0; - return &v; - } - static const ScalingParamType* kZero() { - static ScalingParamType v = 0.0; - return &v; - } }; template <> class CudnnDataType { public: static const cudnnDataType_t type = CUDNN_DATA_DOUBLE; - typedef const double ScalingParamType; - static ScalingParamType* kOne() { - static ScalingParamType v = 1.0; - return &v; - } - static ScalingParamType* kZero() { - static ScalingParamType v = 0.0; - return &v; - } }; inline cudnnTensorFormat_t GetCudnnTensorFormat(const DataLayout& order) { @@ -219,4 +198,3 @@ class ScopedPoolingDescriptor { } // namespace platform } // namespace paddle -#endif diff --git a/paddle/platform/cudnn_helper_test.cc b/paddle/platform/cudnn_helper_test.cc index 729f2f8a10..6bd85ae1ca 100644 --- a/paddle/platform/cudnn_helper_test.cc +++ b/paddle/platform/cudnn_helper_test.cc @@ -13,8 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ #include "paddle/platform/cudnn_helper.h" -#include "glog/logging.h" -#include "gtest/gtest.h" +#include TEST(CudnnHelper, ScopedTensorDescriptor) { using paddle::platform::ScopedTensorDescriptor; From faa4da4835e0622387e2ab1f6481875c5243c5c9 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Mon, 4 Sep 2017 13:02:27 +0800 Subject: [PATCH 17/62] fix ctc edit distance in v2 API. --- .../gserver/evaluators/CTCErrorEvaluator.cpp | 56 +++++++++++++++---- 1 file changed, 46 insertions(+), 10 deletions(-) diff --git a/paddle/gserver/evaluators/CTCErrorEvaluator.cpp b/paddle/gserver/evaluators/CTCErrorEvaluator.cpp index 132119015f..8e2dc020cd 100644 --- a/paddle/gserver/evaluators/CTCErrorEvaluator.cpp +++ b/paddle/gserver/evaluators/CTCErrorEvaluator.cpp @@ -26,6 +26,7 @@ private: int numTimes_, numClasses_, numSequences_, blank_; real deletions_, insertions_, substitutions_; int seqClassficationError_; + mutable std::unordered_map evalResults_; std::vector path2String(const std::vector& path) { std::vector str; @@ -183,6 +184,18 @@ private: return stringAlignment(gtStr, recogStr); } + void storeLocalValues() const { + evalResults_["error"] = numSequences_ ? totalScore_ / numSequences_ : 0; + evalResults_["deletion_error"] = + numSequences_ ? deletions_ / numSequences_ : 0; + evalResults_["insertion_error"] = + numSequences_ ? insertions_ / numSequences_ : 0; + evalResults_["substitution_error"] = + numSequences_ ? substitutions_ / numSequences_ : 0; + evalResults_["sequence_error"] = + (real)seqClassficationError_ / numSequences_; + } + public: CTCErrorEvaluator() : numTimes_(0), @@ -245,16 +258,12 @@ public: } virtual void printStats(std::ostream& os) const { - os << config_.name() << "=" - << (numSequences_ ? totalScore_ / numSequences_ : 0); - os << " deletions error" - << "=" << (numSequences_ ? deletions_ / numSequences_ : 0); - os << " insertions error" - << "=" << (numSequences_ ? insertions_ / numSequences_ : 0); - os << " substitutions error" - << "=" << (numSequences_ ? substitutions_ / numSequences_ : 0); - os << " sequences error" - << "=" << (real)seqClassficationError_ / numSequences_; + storeLocalValues(); + os << config_.name() << "=" << evalResults_["error"]; + os << " deletions error = " << evalResults_["deletion_error"]; + os << " insertions error = " << evalResults_["insertion_error"]; + os << " substitution error = " << evalResults_["substitution_error"]; + os << " sequence error = " << evalResults_["sequence_error"]; } virtual void distributeEval(ParameterClient2* client) { @@ -272,6 +281,33 @@ public: seqClassficationError_ = (int)buf[4]; numSequences_ = (int)buf[5]; } + + void getNames(std::vector* names) { + storeLocalValues(); + names->reserve(names->size() + evalResults_.size()); + for (auto it = evalResults_.begin(); it != evalResults_.end(); ++it) { + names->push_back(config_.name() + "." + it->first); + } + } + + real getValue(const std::string& name, Error* err) const { + storeLocalValues(); + + const std::string delimiter("."); + std::string::size_type foundPos = name.find(delimiter, 0); + CHECK(foundPos != std::string::npos); + + auto it = evalResults_.find( + name.substr(foundPos + delimiter.size(), name.length())); + if (it == evalResults_.end()) { + *err = Error("Evaluator does not have the key %s", name.c_str()); + return 0.0f; + } + + return it->second; + } + + std::string getTypeImpl() const { return "ctc_edit_distance"; } }; REGISTER_EVALUATOR(ctc_edit_distance, CTCErrorEvaluator); From a60128aeb235c3e53b6785537bf3f67502ca079d Mon Sep 17 00:00:00 2001 From: Luo Tao Date: Mon, 4 Sep 2017 14:11:43 +0800 Subject: [PATCH 18/62] move identity_op from scale_op.cc to be a single file --- paddle/operators/CMakeLists.txt | 2 ++ paddle/operators/identity_op.cc | 54 +++++++++++++++++++++++++++++++++ paddle/operators/scale_op.cc | 31 +------------------ 3 files changed, 57 insertions(+), 30 deletions(-) create mode 100644 paddle/operators/identity_op.cc diff --git a/paddle/operators/CMakeLists.txt b/paddle/operators/CMakeLists.txt index e5efcccb0e..d85c3d575a 100644 --- a/paddle/operators/CMakeLists.txt +++ b/paddle/operators/CMakeLists.txt @@ -48,12 +48,14 @@ add_subdirectory(math) list(REMOVE_ITEM GENERAL_OPS net_op + identity_op minus_op mul_op recurrent_op scale_op) op_library(net_op SRCS net_op.cc) +op_library(identity_op SRCS identity_op.cc DEPS scale_op) op_library(minus_op SRCS minus_op.cc minus_op.cu DEPS scale_op) op_library(mul_op SRCS mul_op.cc mul_op.cu DEPS math_function) op_library(recurrent_op SRCS recurrent_op.cc rnn/recurrent_op_utils.cc diff --git a/paddle/operators/identity_op.cc b/paddle/operators/identity_op.cc new file mode 100644 index 0000000000..be956bf3b3 --- /dev/null +++ b/paddle/operators/identity_op.cc @@ -0,0 +1,54 @@ +/* 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/net_op.h" +#include "paddle/operators/scale_op.h" + +namespace paddle { +namespace operators { + +// identity is a alias of scale op. This is also a example for creating a alias +// operator. +template +class IdentityOpMaker : public framework::OpProtoAndCheckerMaker { + public: + IdentityOpMaker(framework::OpProto *proto, + framework::OpAttrChecker *op_checker) + : OpProtoAndCheckerMaker(proto, op_checker) { + AddInput("X", "input tensor of identity op"); + AddOutput("Out", "output tensor of identity op"); + AddComment("identity operator. Just a alias of scale op which scale = 1.0"); + } +}; + +template +class IdentityOp : public NetOp { + public: + IdentityOp(const std::string &type, const framework::VariableNameMap &inputs, + const framework::VariableNameMap &outputs, + const framework::AttributeMap &attrs) + : NetOp(type, inputs, outputs, attrs) { + AppendOp(framework::OpRegistry::CreateOp( + "scale", {{"X", {Input("X")}}}, {{"Out", {Output("Out")}}}, + {{"scale", static_cast(1)}})); + } +}; + +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; + +REGISTER_OP_WITHOUT_GRADIENT(identity, ops::IdentityOp, + ops::IdentityOpMaker); diff --git a/paddle/operators/scale_op.cc b/paddle/operators/scale_op.cc index 4e039688d4..57696d2ee6 100644 --- a/paddle/operators/scale_op.cc +++ b/paddle/operators/scale_op.cc @@ -48,7 +48,7 @@ The equation is: Out = scale*X } }; -// Identity Op's gradient is identity op, too. +// Scale Op's gradient is scale op, too. // Grad(Out=scale(X)) => Grad(X) = scale(Grad(Out)) template class ScaleGradOp : public NetOp { @@ -65,33 +65,6 @@ class ScaleGradOp : public NetOp { } }; -// identity is a alias of scale op. This is also a example for creating a alias -// operator. -template -class IdentityOpMaker : public framework::OpProtoAndCheckerMaker { - public: - IdentityOpMaker(framework::OpProto *proto, - framework::OpAttrChecker *op_checker) - : OpProtoAndCheckerMaker(proto, op_checker) { - AddInput("X", "input tensor of identity op"); - AddOutput("Out", "output tensor of identity op"); - AddComment("identity operator. Just a alias of scale op which scale = 1.0"); - } -}; - -template -class IdentityOp : public NetOp { - public: - IdentityOp(const std::string &type, const framework::VariableNameMap &inputs, - const framework::VariableNameMap &outputs, - const framework::AttributeMap &attrs) - : NetOp(type, inputs, outputs, attrs) { - AppendOp(framework::OpRegistry::CreateOp( - "scale", {{"X", {Input("X")}}}, {{"Out", {Output("Out")}}}, - {{"scale", static_cast(1)}})); - } -}; - } // namespace operators } // namespace paddle @@ -101,5 +74,3 @@ REGISTER_OP(scale, ops::ScaleOp, ops::ScaleOpMaker, ops::ScaleGradOp); REGISTER_OP_CPU_KERNEL(scale, ops::ScaleKernel); -REGISTER_OP_WITHOUT_GRADIENT(identity, ops::IdentityOp, - ops::IdentityOpMaker); From fb49bc2c99c5deb0d7ebc9507410b8e60b0bb27c Mon Sep 17 00:00:00 2001 From: caoying03 Date: Mon, 4 Sep 2017 14:15:50 +0800 Subject: [PATCH 19/62] rename mse_cost into square_error_cost. --- .../paddle/trainer_config_helpers/layers.py | 29 +++++++++++-------- .../test_cost_layers_with_weight.protostr | 8 ++--- .../configs/test_cost_layers_with_weight.py | 2 +- 3 files changed, 22 insertions(+), 17 deletions(-) diff --git a/python/paddle/trainer_config_helpers/layers.py b/python/paddle/trainer_config_helpers/layers.py index 2bd274fad2..47ac601e67 100644 --- a/python/paddle/trainer_config_helpers/layers.py +++ b/python/paddle/trainer_config_helpers/layers.py @@ -53,7 +53,7 @@ __all__ = [ 'cos_sim', 'hsigmoid', 'conv_projection', - 'mse_cost', + 'square_error_cost', 'regression_cost', 'classification_cost', 'LayerOutput', @@ -4238,13 +4238,18 @@ def __cost_input__(input, label, weight=None): @wrap_name_default() @layer_support() -def mse_cost(input, label, weight=None, name=None, coeff=1.0, layer_attr=None): +def square_error_cost(input, + label, + weight=None, + name=None, + coeff=1.0, + layer_attr=None): """ - mean squared error cost: + sum of square error cost: .. math:: - \\frac{1}{N}\sum_{i=1}^N(t_i-y_i)^2 + cost = \\sum_{i=1}^N(t_i-y_i)^2 :param name: layer name. :type name: basestring @@ -4273,7 +4278,7 @@ def mse_cost(input, label, weight=None, name=None, coeff=1.0, layer_attr=None): return LayerOutput(name, LayerType.COST, parents=parents, size=1) -regression_cost = mse_cost +regression_cost = square_error_cost @wrap_name_default("cost") @@ -5798,9 +5803,9 @@ def huber_regression_cost(input, coeff=1.0, layer_attr=None): """ - In statistics, the Huber loss is a loss function used in robust regression, - that is less sensitive to outliers in data than the squared error loss. - Given a prediction f(x), a label y and :math:`\delta`, the loss function + In statistics, the Huber loss is a loss function used in robust regression, + that is less sensitive to outliers in data than the squared error loss. + Given a prediction f(x), a label y and :math:`\delta`, the loss function is defined as: .. math: @@ -5848,13 +5853,13 @@ def huber_classification_cost(input, coeff=1.0, layer_attr=None): """ - For classification purposes, a variant of the Huber loss called modified Huber - is sometimes used. Given a prediction f(x) (a real-valued classifier score) and - a true binary class label :math:`y\in \left \{-1, 1 \right \}`, the modified Huber + For classification purposes, a variant of the Huber loss called modified Huber + is sometimes used. Given a prediction f(x) (a real-valued classifier score) and + a true binary class label :math:`y\in \left \{-1, 1 \right \}`, the modified Huber loss is defined as: .. math: - loss = \max \left ( 0, 1-yf(x) \right )^2, yf(x)\geq 1 + loss = \max \left ( 0, 1-yf(x) \right )^2, yf(x)\geq 1 loss = -4yf(x), \text{otherwise} The example usage is: diff --git a/python/paddle/trainer_config_helpers/tests/configs/protostr/test_cost_layers_with_weight.protostr b/python/paddle/trainer_config_helpers/tests/configs/protostr/test_cost_layers_with_weight.protostr index 96fb1d4ebd..cec8a73db6 100644 --- a/python/paddle/trainer_config_helpers/tests/configs/protostr/test_cost_layers_with_weight.protostr +++ b/python/paddle/trainer_config_helpers/tests/configs/protostr/test_cost_layers_with_weight.protostr @@ -45,7 +45,7 @@ layers { coeff: 1.0 } layers { - name: "__mse_cost_0__" + name: "__square_error_cost_0__" type: "square_error" size: 1 active_type: "" @@ -130,7 +130,7 @@ input_layer_names: "label" input_layer_names: "weight" input_layer_names: "multi_class_label" output_layer_names: "__cost_0__" -output_layer_names: "__mse_cost_0__" +output_layer_names: "__square_error_cost_0__" output_layer_names: "__nce_layer_0__" evaluators { name: "classification_error_evaluator" @@ -146,7 +146,7 @@ sub_models { layer_names: "weight" layer_names: "__fc_layer_0__" layer_names: "__cost_0__" - layer_names: "__mse_cost_0__" + layer_names: "__square_error_cost_0__" layer_names: "multi_class_label" layer_names: "__nce_layer_0__" input_layer_names: "input" @@ -154,7 +154,7 @@ sub_models { input_layer_names: "weight" input_layer_names: "multi_class_label" output_layer_names: "__cost_0__" - output_layer_names: "__mse_cost_0__" + output_layer_names: "__square_error_cost_0__" output_layer_names: "__nce_layer_0__" evaluator_names: "classification_error_evaluator" is_recurrent_layer_group: false diff --git a/python/paddle/trainer_config_helpers/tests/configs/test_cost_layers_with_weight.py b/python/paddle/trainer_config_helpers/tests/configs/test_cost_layers_with_weight.py index c369062930..caa6aaa943 100644 --- a/python/paddle/trainer_config_helpers/tests/configs/test_cost_layers_with_weight.py +++ b/python/paddle/trainer_config_helpers/tests/configs/test_cost_layers_with_weight.py @@ -10,7 +10,7 @@ fc = fc_layer(input=data, size=10, act=SoftmaxActivation()) outputs( classification_cost( input=fc, label=lbl, weight=wt), - mse_cost( + square_error_cost( input=fc, label=lbl, weight=wt), nce_layer( input=fc, From c2c5df29110c69f3cf64e627c78ce7897e487025 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Mon, 4 Sep 2017 14:56:13 +0800 Subject: [PATCH 20/62] update doc. --- doc/api/v2/config/layer.rst | 4 ++-- doc/getstarted/basic_usage/index_en.rst | 2 +- doc/getstarted/concepts/src/train.py | 2 +- doc/getstarted/concepts/use_concepts_cn.rst | 4 ++-- doc/howto/usage/k8s/k8s_distributed_cn.md | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/doc/api/v2/config/layer.rst b/doc/api/v2/config/layer.rst index 1329b77bb4..c94627a728 100644 --- a/doc/api/v2/config/layer.rst +++ b/doc/api/v2/config/layer.rst @@ -434,9 +434,9 @@ lambda_cost .. autoclass:: paddle.v2.layer.lambda_cost :noindex: -mse_cost +square_error_cost -------- -.. autoclass:: paddle.v2.layer.mse_cost +.. autoclass:: paddle.v2.layer.square_error_cost :noindex: rank_cost diff --git a/doc/getstarted/basic_usage/index_en.rst b/doc/getstarted/basic_usage/index_en.rst index 6775da20c2..2cc438ebbe 100644 --- a/doc/getstarted/basic_usage/index_en.rst +++ b/doc/getstarted/basic_usage/index_en.rst @@ -49,7 +49,7 @@ To recover this relationship between ``X`` and ``Y``, we use a neural network wi x = data_layer(name='x', size=1) y = data_layer(name='y', size=1) y_predict = fc_layer(input=x, param_attr=ParamAttr(name='w'), size=1, act=LinearActivation(), bias_attr=ParamAttr(name='b')) - cost = mse_cost(input=y_predict, label=y) + cost = square_error_cost(input=y_predict, label=y) outputs(cost) Some of the most fundamental usages of PaddlePaddle are demonstrated: diff --git a/doc/getstarted/concepts/src/train.py b/doc/getstarted/concepts/src/train.py index 7e604f23de..8aceb23406 100644 --- a/doc/getstarted/concepts/src/train.py +++ b/doc/getstarted/concepts/src/train.py @@ -8,7 +8,7 @@ paddle.init(use_gpu=False) x = paddle.layer.data(name='x', type=paddle.data_type.dense_vector(2)) y_predict = paddle.layer.fc(input=x, size=1, act=paddle.activation.Linear()) y = paddle.layer.data(name='y', type=paddle.data_type.dense_vector(1)) -cost = paddle.layer.mse_cost(input=y_predict, label=y) +cost = paddle.layer.square_error_cost(input=y_predict, label=y) # create parameters parameters = paddle.parameters.create(cost) diff --git a/doc/getstarted/concepts/use_concepts_cn.rst b/doc/getstarted/concepts/use_concepts_cn.rst index f15b11bd78..25bf7ff1d0 100644 --- a/doc/getstarted/concepts/use_concepts_cn.rst +++ b/doc/getstarted/concepts/use_concepts_cn.rst @@ -81,7 +81,7 @@ PaddlePaddle支持不同类型的输入数据，主要包括四种类型，和 .. code-block:: bash y_predict = paddle.layer.fc(input=x, size=1, act=paddle.activation.Linear()) - cost = paddle.layer.mse_cost(input=y_predict, label=y) + cost = paddle.layer.square_error_cost(input=y_predict, label=y) 其中，x与y为之前描述的输入层；而y_predict是接收x作为输入，接上一个全连接层；cost接收y_predict与y作为输入，接上均方误差层。 @@ -147,4 +147,4 @@ PaddlePaddle支持不同类型的输入数据，主要包括四种类型，和 .. literalinclude:: src/train.py :linenos: -有关线性回归的实际应用，可以参考PaddlePaddle book的 `第一章节 `_。 \ No newline at end of file +有关线性回归的实际应用，可以参考PaddlePaddle book的 `第一章节 `_。 diff --git a/doc/howto/usage/k8s/k8s_distributed_cn.md b/doc/howto/usage/k8s/k8s_distributed_cn.md index 3121b3f59d..a9bebf0955 100644 --- a/doc/howto/usage/k8s/k8s_distributed_cn.md +++ b/doc/howto/usage/k8s/k8s_distributed_cn.md @@ -213,7 +213,7 @@ I1116 09:10:17.123440 50 Util.cpp:130] Calling runInitFunctions I1116 09:10:17.123764 50 Util.cpp:143] Call runInitFunctions done. [WARNING 2016-11-16 09:10:17,227 default_decorators.py:40] please use keyword arguments in paddle config. [INFO 2016-11-16 09:10:17,239 networks.py:1282] The input order is [movie_id, title, genres, user_id, gender, age, occupation, rating] -[INFO 2016-11-16 09:10:17,239 networks.py:1289] The output order is [__mse_cost_0__] +[INFO 2016-11-16 09:10:17,239 networks.py:1289] The output order is [__square_error_cost_0__] I1116 09:10:17.392917 50 Trainer.cpp:170] trainer mode: Normal I1116 09:10:17.613910 50 PyDataProvider2.cpp:257] loading dataprovider dataprovider::process I1116 09:10:17.680917 50 PyDataProvider2.cpp:257] loading dataprovider dataprovider::process From 0b478e991c95f838da41bfcbf11f1e2b80ac17eb Mon Sep 17 00:00:00 2001 From: caoying03 Date: Mon, 4 Sep 2017 15:12:56 +0800 Subject: [PATCH 21/62] follow comments. --- paddle/gserver/evaluators/CTCErrorEvaluator.cpp | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/paddle/gserver/evaluators/CTCErrorEvaluator.cpp b/paddle/gserver/evaluators/CTCErrorEvaluator.cpp index 8e2dc020cd..928c77a088 100644 --- a/paddle/gserver/evaluators/CTCErrorEvaluator.cpp +++ b/paddle/gserver/evaluators/CTCErrorEvaluator.cpp @@ -14,6 +14,7 @@ limitations under the License. */ #include "Evaluator.h" #include "paddle/gserver/gradientmachines/NeuralNetwork.h" +#include "paddle/utils/StringUtil.h" namespace paddle { @@ -259,7 +260,7 @@ public: virtual void printStats(std::ostream& os) const { storeLocalValues(); - os << config_.name() << "=" << evalResults_["error"]; + os << config_.name() << " error = " << evalResults_["error"]; os << " deletions error = " << evalResults_["deletion_error"]; os << " insertions error = " << evalResults_["insertion_error"]; os << " substitution error = " << evalResults_["substitution_error"]; @@ -293,12 +294,10 @@ public: real getValue(const std::string& name, Error* err) const { storeLocalValues(); - const std::string delimiter("."); - std::string::size_type foundPos = name.find(delimiter, 0); - CHECK(foundPos != std::string::npos); + std::vector buffers; + paddle::str::split(name, '.', &buffers); + auto it = evalResults_.find(buffers[buffers.size() - 1]); - auto it = evalResults_.find( - name.substr(foundPos + delimiter.size(), name.length())); if (it == evalResults_.end()) { *err = Error("Evaluator does not have the key %s", name.c_str()); return 0.0f; @@ -307,7 +306,11 @@ public: return it->second; } - std::string getTypeImpl() const { return "ctc_edit_distance"; } + std::string getType(const std::string& name, Error* err) const { + getValue(name, err); + if (!err->isOK()) return ""; + return "ctc_edit_distance"; + } }; REGISTER_EVALUATOR(ctc_edit_distance, CTCErrorEvaluator); From 5b93ac7778754943914b3f9511208e55a3526f64 Mon Sep 17 00:00:00 2001 From: Luo Tao Date: Mon, 4 Sep 2017 15:49:33 +0800 Subject: [PATCH 22/62] package a new USE_NO_KERNEL_OP for USE_OP_ITSELF --- doc/howto/dev/new_op_cn.md | 6 ++++++ paddle/framework/backward.cc | 2 +- paddle/framework/op_registry.h | 2 ++ paddle/operators/minus_op.cc | 2 +- paddle/operators/recurrent_op.cc | 2 +- paddle/pybind/pybind.cc | 4 ++-- python/paddle/v2/framework/op.py | 2 +- 7 files changed, 14 insertions(+), 6 deletions(-) diff --git a/doc/howto/dev/new_op_cn.md b/doc/howto/dev/new_op_cn.md index ec79b7f42b..dfcbce9037 100644 --- a/doc/howto/dev/new_op_cn.md +++ b/doc/howto/dev/new_op_cn.md @@ -227,6 +227,12 @@ make mul_op USE_CPU_ONLY_OP(gather); ``` + 如果OP不带Kernel，则使用`USE_NO_KENREL_OP`: + + ``` + USE_NO_KENREL_OP(recurrent); + ``` + 使用`USE_OP`告知编译器需要链接该Op的目标文件，具体解释参考[代码注释](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/op_registry.h#L81)。 diff --git a/paddle/framework/backward.cc b/paddle/framework/backward.cc index 6b4c612cd8..c5d4662215 100644 --- a/paddle/framework/backward.cc +++ b/paddle/framework/backward.cc @@ -182,7 +182,7 @@ static std::unique_ptr BackwardRecursive( }); // process recurrent gradient op as a special operator. - if (forwardOp.Type() == "recurrent_op") { + if (forwardOp.Type() == "recurrent") { // NOTE clean up cycle call somewhere (RNN's stepnet constains itself), or // this will result in infinite loop. const auto& rnnop = diff --git a/paddle/framework/op_registry.h b/paddle/framework/op_registry.h index 64c7f23ab6..27f1927aed 100644 --- a/paddle/framework/op_registry.h +++ b/paddle/framework/op_registry.h @@ -194,6 +194,8 @@ class OpKernelRegistrar : public Registrar { USE_OP_DEVICE_KERNEL(op_type, GPU) #endif +#define USE_NO_KERNEL_OP(op_type) USE_OP_ITSELF(op_type); + #define USE_CPU_ONLY_OP(op_type) \ USE_OP_ITSELF(op_type); \ USE_OP_DEVICE_KERNEL(op_type, CPU); diff --git a/paddle/operators/minus_op.cc b/paddle/operators/minus_op.cc index b4afebcd97..138cdbd563 100644 --- a/paddle/operators/minus_op.cc +++ b/paddle/operators/minus_op.cc @@ -79,7 +79,7 @@ class MinusGradOp : public NetOp { } // namespace paddle USE_OP(scale); -USE_OP_ITSELF(identity); +USE_NO_KERNEL_OP(identity); namespace ops = paddle::operators; REGISTER_OP(minus, ops::MinusOp, ops::MinusOpMaker, ops::MinusGradOp); REGISTER_OP_CPU_KERNEL(minus, diff --git a/paddle/operators/recurrent_op.cc b/paddle/operators/recurrent_op.cc index 16bd249cb3..e826703c60 100644 --- a/paddle/operators/recurrent_op.cc +++ b/paddle/operators/recurrent_op.cc @@ -235,5 +235,5 @@ RecurrentGradientOp::RecurrentGradientOp( } // namespace paddle REGISTER_OP_WITHOUT_GRADIENT( - recurrent_op, paddle::operators::RecurrentOp, + recurrent, paddle::operators::RecurrentOp, paddle::operators::RecurrentAlgorithmProtoAndCheckerMaker); diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc index 3bc150ccb7..6896422617 100644 --- a/paddle/pybind/pybind.cc +++ b/paddle/pybind/pybind.cc @@ -39,12 +39,12 @@ USE_OP(sigmoid); USE_OP(softmax); USE_OP(rowwise_add); USE_OP(fill_zeros_like); -USE_OP_ITSELF(recurrent_op); +USE_NO_KERNEL_OP(recurrent); USE_OP(gaussian_random); USE_OP(uniform_random); USE_OP(lookup_table); USE_OP(scale); -USE_OP_ITSELF(identity); +USE_NO_KERNEL_OP(identity); USE_OP(minus); USE_CPU_ONLY_OP(gather); USE_CPU_ONLY_OP(scatter); diff --git a/python/paddle/v2/framework/op.py b/python/paddle/v2/framework/op.py index 6ac656321e..e7e932f6fe 100644 --- a/python/paddle/v2/framework/op.py +++ b/python/paddle/v2/framework/op.py @@ -179,7 +179,7 @@ class OperatorFactory(object): class __RecurrentOp__(object): __proto__ = None - type = 'recurrent_op' + type = 'recurrent' def __init__(self): # cache recurrent_op's proto From 10eacac9a700c02909f2c714280d66246db954b1 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Mon, 4 Sep 2017 16:01:40 +0800 Subject: [PATCH 23/62] follow comments and fix unittest. --- doc/getstarted/basic_usage/index_cn.rst | 4 ++-- doc/getstarted/concepts/use_concepts_cn.rst | 2 +- python/paddle/v2/tests/test_layer.py | 5 +++-- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/doc/getstarted/basic_usage/index_cn.rst b/doc/getstarted/basic_usage/index_cn.rst index 428f58830e..b473944fc7 100644 --- a/doc/getstarted/basic_usage/index_cn.rst +++ b/doc/getstarted/basic_usage/index_cn.rst @@ -55,7 +55,7 @@ PaddlePaddle是源于百度的一个深度学习平台。这份简短的介绍 # 线性计算网络层: ȳ = wx + b ȳ = fc_layer(input=x, param_attr=ParamAttr(name='w'), size=1, act=LinearActivation(), bias_attr=ParamAttr(name='b')) # 计算误差函数，即 ȳ 和真实 y 之间的距离 - cost = mse_cost(input= ȳ, label=y) + cost = square_error_cost(input= ȳ, label=y) outputs(cost) @@ -69,7 +69,7 @@ PaddlePaddle是源于百度的一个深度学习平台。这份简短的介绍 - **数据层**：数据层 `data_layer` 是神经网络的入口，它读入数据并将它们传输到接下来的网络层。这里数据层有两个，分别对应于变量 `x` 和 `y`。 - **全连接层**：全连接层 `fc_layer` 是基础的计算单元，这里利用它建模变量之间的线性关系。计算单元是神经网络的核心，PaddlePaddle支持大量的计算单元和任意深度的网络连接，从而可以拟合任意的函数来学习复杂的数据关系。 - - **回归误差代价层**：回归误差代价层 `mse_cost` 是众多误差代价函数层的一种，它们在训练过程作为网络的出口，用来计算模型的误差，是模型参数优化的目标函数。 + - **回归误差代价层**：回归误差代价层 `square_error_cost` 是众多误差代价函数层的一种，它们在训练过程作为网络的出口，用来计算模型的误差，是模型参数优化的目标函数。 定义了网络结构并保存为 `trainer_config.py` 之后，运行以下训练命令： diff --git a/doc/getstarted/concepts/use_concepts_cn.rst b/doc/getstarted/concepts/use_concepts_cn.rst index 25bf7ff1d0..c243083794 100644 --- a/doc/getstarted/concepts/use_concepts_cn.rst +++ b/doc/getstarted/concepts/use_concepts_cn.rst @@ -83,7 +83,7 @@ PaddlePaddle支持不同类型的输入数据，主要包括四种类型，和 y_predict = paddle.layer.fc(input=x, size=1, act=paddle.activation.Linear()) cost = paddle.layer.square_error_cost(input=y_predict, label=y) -其中，x与y为之前描述的输入层；而y_predict是接收x作为输入，接上一个全连接层；cost接收y_predict与y作为输入，接上均方误差层。 +其中，x与y为之前描述的输入层；而y_predict是接收x作为输入，接上一个全连接层；cost接收y_predict与y作为输入，接上平方误差层。 最后一层cost中记录了神经网络的所有拓扑结构，通过组合不同的layer，我们即可完成神经网络的搭建。 diff --git a/python/paddle/v2/tests/test_layer.py b/python/paddle/v2/tests/test_layer.py index 783a0ca85d..de932ad715 100644 --- a/python/paddle/v2/tests/test_layer.py +++ b/python/paddle/v2/tests/test_layer.py @@ -134,8 +134,9 @@ class CostLayerTest(unittest.TestCase): cost3 = layer.cross_entropy_cost(input=inference, label=label) cost4 = layer.cross_entropy_with_selfnorm_cost( input=inference, label=label) - cost5 = layer.mse_cost(input=inference, label=label) - cost6 = layer.mse_cost(input=inference, label=label, weight=weight) + cost5 = layer.square_error_cost(input=inference, label=label) + cost6 = layer.square_error_cost( + input=inference, label=label, weight=weight) cost7 = layer.multi_binary_label_cross_entropy_cost( input=inference, label=label) cost8 = layer.rank_cost(left=score, right=score, label=score) From 740c8ba12a29418eefeb22a843bebb1781f300fe Mon Sep 17 00:00:00 2001 From: Luo Tao Date: Mon, 4 Sep 2017 16:40:23 +0800 Subject: [PATCH 24/62] remove scatter_op.cu/gather_op.cu as they support only_cpu now --- paddle/operators/CMakeLists.txt | 24 ++++++++++++++++-------- paddle/operators/gather_op.cu | 20 -------------------- paddle/operators/scatter_op.cu | 20 -------------------- 3 files changed, 16 insertions(+), 48 deletions(-) delete mode 100644 paddle/operators/gather_op.cu delete mode 100644 paddle/operators/scatter_op.cu diff --git a/paddle/operators/CMakeLists.txt b/paddle/operators/CMakeLists.txt index d85c3d575a..90185101c4 100644 --- a/paddle/operators/CMakeLists.txt +++ b/paddle/operators/CMakeLists.txt @@ -46,15 +46,20 @@ endfunction() add_subdirectory(math) -list(REMOVE_ITEM GENERAL_OPS - net_op - identity_op - minus_op - mul_op - recurrent_op - scale_op) +set(ONLYCPU_OPS + net_op + gather_op + scatter_op) +foreach(src ${ONLYCPU_OPS}) + op_library(${src} SRCS ${src}.cc) +endforeach() -op_library(net_op SRCS net_op.cc) +set(DEPS_OPS + identity_op + minus_op + mul_op + recurrent_op + scale_op) op_library(identity_op SRCS identity_op.cc DEPS scale_op) op_library(minus_op SRCS minus_op.cc minus_op.cu DEPS scale_op) op_library(mul_op SRCS mul_op.cc mul_op.cu DEPS math_function) @@ -62,6 +67,9 @@ op_library(recurrent_op SRCS recurrent_op.cc rnn/recurrent_op_utils.cc DEPS framework_proto tensor operator net_op) op_library(scale_op SRCS scale_op.cc scale_op.cu DEPS net_op) +list(REMOVE_ITEM GENERAL_OPS + ${ONLYCPU_OPS} + ${DEPS_OPS}) foreach(src ${GENERAL_OPS}) op_library(${src} SRCS ${src}.cc ${src}.cu) endforeach() diff --git a/paddle/operators/gather_op.cu b/paddle/operators/gather_op.cu deleted file mode 100644 index 3f04a7b3f8..0000000000 --- a/paddle/operators/gather_op.cu +++ /dev/null @@ -1,20 +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. */ - -#define EIGEN_USE_GPU -#include "paddle/operators/gather_op.h" - -namespace ops = paddle::operators; -REGISTER_OP_GPU_KERNEL(gather, - ops::GatherOpKernel); diff --git a/paddle/operators/scatter_op.cu b/paddle/operators/scatter_op.cu deleted file mode 100644 index 6716b47883..0000000000 --- a/paddle/operators/scatter_op.cu +++ /dev/null @@ -1,20 +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. */ - -#define EIGEN_USE_GPU -#include "paddle/operators/scatter_op.h" - -namespace ops = paddle::operators; -REGISTER_OP_GPU_KERNEL(scatter, - ops::ScatterOpKernel); From a523bea8e585bd63f4167e012a05b03ad435b574 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Mon, 4 Sep 2017 20:40:33 +0800 Subject: [PATCH 25/62] fix getType. --- paddle/gserver/evaluators/CTCErrorEvaluator.cpp | 8 +++++--- paddle/gserver/evaluators/ChunkEvaluator.cpp | 8 +++++++- paddle/gserver/evaluators/Evaluator.h | 13 ++++++++----- 3 files changed, 20 insertions(+), 9 deletions(-) diff --git a/paddle/gserver/evaluators/CTCErrorEvaluator.cpp b/paddle/gserver/evaluators/CTCErrorEvaluator.cpp index 928c77a088..92087fa32b 100644 --- a/paddle/gserver/evaluators/CTCErrorEvaluator.cpp +++ b/paddle/gserver/evaluators/CTCErrorEvaluator.cpp @@ -21,7 +21,7 @@ namespace paddle { /** * calculate sequence-to-sequence edit distance */ -class CTCErrorEvaluator : public NotGetableEvaluator { +class CTCErrorEvaluator : public Evaluator { private: MatrixPtr outActivations_; int numTimes_, numClasses_, numSequences_, blank_; @@ -307,8 +307,10 @@ public: } std::string getType(const std::string& name, Error* err) const { - getValue(name, err); - if (!err->isOK()) return ""; + this->getValue(name, err); + if (!err->isOK()) { + return ""; + } return "ctc_edit_distance"; } }; diff --git a/paddle/gserver/evaluators/ChunkEvaluator.cpp b/paddle/gserver/evaluators/ChunkEvaluator.cpp index 1658282f3a..a2ab15eede 100644 --- a/paddle/gserver/evaluators/ChunkEvaluator.cpp +++ b/paddle/gserver/evaluators/ChunkEvaluator.cpp @@ -268,7 +268,13 @@ public: } // get type of evaluator - std::string getTypeImpl() const { return "chunk"; } + std::string getType(const std::string& name, Error* err) const { + this->getValue(name, err); + if (!err->isOK()) { + return ""; + } + return "chunk"; + } private: void storeLocalValues() const { diff --git a/paddle/gserver/evaluators/Evaluator.h b/paddle/gserver/evaluators/Evaluator.h index b114500e2b..90203553e0 100644 --- a/paddle/gserver/evaluators/Evaluator.h +++ b/paddle/gserver/evaluators/Evaluator.h @@ -211,6 +211,7 @@ public: *err = Error("Not implemented"); return .0f; } + std::string getType(const std::string& name, Error* err) const { *err = Error("Not implemented"); return ""; @@ -331,6 +332,7 @@ private: protected: std::string getTypeImpl() const; }; + /** * @brief precision, recall and f1 score Evaluator * \f[ @@ -358,6 +360,12 @@ public: virtual void distributeEval(ParameterClient2* client); + void getNames(std::vector* names); + + real getValue(const std::string& name, Error* err) const; + + std::string getType(const std::string& name, Error* err) const; + struct StatsInfo { /// numbers of true positives double TP; @@ -428,11 +436,6 @@ private: mutable std::unordered_map values_; void storeLocalValues() const; - // Evaluator interface -public: - void getNames(std::vector* names); - real getValue(const std::string& name, Error* err) const; - std::string getType(const std::string& name, Error* err) const; }; /* From 7c785426e4f15c7ef3a6659e1d32385ed5e48273 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Mon, 4 Sep 2017 22:04:08 +0800 Subject: [PATCH 26/62] add missing protostr for sub_nested_seq_layer. --- ..._layers.protostr => test_sub_nested_seq_select_layer.protostr} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename python/paddle/trainer_config_helpers/tests/configs/protostr/{test_seq_select_layers.protostr => test_sub_nested_seq_select_layer.protostr} (100%) diff --git a/python/paddle/trainer_config_helpers/tests/configs/protostr/test_seq_select_layers.protostr b/python/paddle/trainer_config_helpers/tests/configs/protostr/test_sub_nested_seq_select_layer.protostr similarity index 100% rename from python/paddle/trainer_config_helpers/tests/configs/protostr/test_seq_select_layers.protostr rename to python/paddle/trainer_config_helpers/tests/configs/protostr/test_sub_nested_seq_select_layer.protostr From 447033296d927dd0b0c1240e2ecccaa667eb0fe8 Mon Sep 17 00:00:00 2001 From: dangqingqing Date: Mon, 4 Sep 2017 22:29:34 +0800 Subject: [PATCH 27/62] Make some operator correctly handle gradients for multi inputs. --- paddle/operators/mul_op.cc | 4 +-- paddle/operators/mul_op.h | 36 ++++++++++--------- paddle/operators/rowwise_add_op.cc | 6 ++-- paddle/operators/rowwise_add_op.h | 24 +++++++------ paddle/operators/scatter_op.cc | 4 +-- paddle/operators/scatter_op.h | 10 +++--- .../v2/framework/tests/gradient_checker.py | 25 +++++++++++-- .../paddle/v2/framework/tests/test_mul_op.py | 3 +- 8 files changed, 72 insertions(+), 40 deletions(-) diff --git a/paddle/operators/mul_op.cc b/paddle/operators/mul_op.cc index 8d0f59745f..603dc7f4bd 100644 --- a/paddle/operators/mul_op.cc +++ b/paddle/operators/mul_op.cc @@ -75,8 +75,8 @@ class MulOpGrad : public framework::OperatorWithKernel { PADDLE_ENFORCE(y_dims[1] == out_dims[1], "Out@GRAD M X N must equal to Y dims 1, N "); - x_grad->Resize(x_dims); - y_grad->Resize(y_dims); + if (x_grad) x_grad->Resize(x_dims); + if (y_grad) y_grad->Resize(y_dims); } }; diff --git a/paddle/operators/mul_op.h b/paddle/operators/mul_op.h index 8facc02814..66ed2f81c7 100644 --- a/paddle/operators/mul_op.h +++ b/paddle/operators/mul_op.h @@ -31,13 +31,13 @@ template class MulKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - auto* X = context.Input("X"); - auto* Y = context.Input("Y"); - auto* Z = context.Output("Out"); - Z->mutable_data(context.GetPlace()); + auto* x = context.Input("X"); + auto* y = context.Input("Y"); + auto* z = context.Output("Out"); + z->mutable_data(context.GetPlace()); auto* device_context = const_cast(context.device_context_); - math::matmul(*X, false, *Y, false, 1, Z, 0, device_context); + math::matmul(*x, false, *y, false, 1, z, 0, device_context); } }; @@ -45,20 +45,24 @@ template class MulGradKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& ctx) const override { - auto* X = ctx.Input("X"); - auto* Y = ctx.Input("Y"); - auto* dOut = ctx.Input(framework::GradVarName("Out")); + auto* x = ctx.Input("X"); + auto* y = ctx.Input("Y"); + auto* dout = ctx.Input(framework::GradVarName("Out")); - auto* dX = ctx.Output(framework::GradVarName("X")); - auto* dY = ctx.Output(framework::GradVarName("Y")); - dX->mutable_data(ctx.GetPlace()); - dY->mutable_data(ctx.GetPlace()); + auto* dx = ctx.Output(framework::GradVarName("X")); + auto* dy = ctx.Output(framework::GradVarName("Y")); auto* device_context = const_cast(ctx.device_context_); - // dX = dOut * Y'. dX: M x K, dOut : M x N, Y : K x N - math::matmul(*dOut, false, *Y, true, 1, dX, 0, device_context); - // dY = X' * dOut. dY: K x N, dOut : M x N, X : M x K - math::matmul(*X, true, *dOut, false, 1, dY, 0, device_context); + if (dx) { + // dx = dout * y'. dx: M x K, dout : M x N, y : K x N + dx->mutable_data(ctx.GetPlace()); + math::matmul(*dout, false, *y, true, 1, dx, 0, device_context); + } + if (dy) { + dy->mutable_data(ctx.GetPlace()); + // dy = x' * dout. dy K x N, dout : M x N, x : M x K + math::matmul(*x, true, *dout, false, 1, dy, 0, device_context); + } } }; diff --git a/paddle/operators/rowwise_add_op.cc b/paddle/operators/rowwise_add_op.cc index 63de91254f..a9dfba3e95 100644 --- a/paddle/operators/rowwise_add_op.cc +++ b/paddle/operators/rowwise_add_op.cc @@ -64,8 +64,10 @@ class RowwiseAddGradOp : public framework::OperatorWithKernel { auto dims0 = ctx.Input("X")->dims(); auto dims1 = ctx.Input("b")->dims(); PADDLE_ENFORCE_EQ(1, dims1.size(), "b dims should be 1") - ctx.Output(framework::GradVarName("X"))->Resize(dims0); - ctx.Output(framework::GradVarName("b"))->Resize(dims1); + auto *dx = ctx.Output(framework::GradVarName("X")); + auto *db = ctx.Output(framework::GradVarName("b")); + if (dx) dx->Resize(dims0); + if (db) db->Resize(dims1); } }; diff --git a/paddle/operators/rowwise_add_op.h b/paddle/operators/rowwise_add_op.h index 1cbd8bb31a..4e926d9f29 100644 --- a/paddle/operators/rowwise_add_op.h +++ b/paddle/operators/rowwise_add_op.h @@ -51,20 +51,24 @@ template class RowwiseAddGradKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - auto* dOut = context.Input(framework::GradVarName("Out")); - auto* dX = context.Output(framework::GradVarName("X")); + auto* dout = context.Input(framework::GradVarName("Out")); + auto* dx = context.Output(framework::GradVarName("X")); auto* db = context.Output(framework::GradVarName("b")); - dX->mutable_data(context.GetPlace()); - db->mutable_data(context.GetPlace()); - auto OutGrad = EigenMatrix::From(*dOut); + auto out_grad = EigenMatrix::From(*dout); auto place = context.GetEigenDevice(); - EigenMatrix::From(*dX).device(place) = OutGrad; + if (dx) { + dx->mutable_data(context.GetPlace()); + EigenMatrix::From(*dx).device(place) = out_grad; + } - // https://eigen.tuxfamily.org/dox/unsupported/TensorBase_8h_source.html - // colwise add - Eigen::array dims{{0}}; /* dimension to reduce */ - EigenVector::Flatten(*db).device(place) = OutGrad.sum(dims); + if (db) { + db->mutable_data(context.GetPlace()); + // https://eigen.tuxfamily.org/dox/unsupported/TensorBase_8h_source.html + // colwise add + Eigen::array dims{{0}}; /* dimension to reduce */ + EigenVector::Flatten(*db).device(place) = out_grad.sum(dims); + } } }; } // namespace operators diff --git a/paddle/operators/scatter_op.cc b/paddle/operators/scatter_op.cc index 35c185ad80..9b5068f07c 100644 --- a/paddle/operators/scatter_op.cc +++ b/paddle/operators/scatter_op.cc @@ -50,8 +50,8 @@ class ScatterGradOp : public framework::OperatorWithKernel { auto *dRef = ctx.Output(framework::GradVarName("Ref")); auto *Ref = ctx.Input("Ref"); - dRef->Resize(Ref->dims()); - dUpdates->Resize(Updates->dims()); + if (dRef) dRef->Resize(Ref->dims()); + if (dUpdates) dUpdates->Resize(Updates->dims()); } }; diff --git a/paddle/operators/scatter_op.h b/paddle/operators/scatter_op.h index e9595638a8..7551480211 100644 --- a/paddle/operators/scatter_op.h +++ b/paddle/operators/scatter_op.h @@ -49,10 +49,12 @@ class ScatterGradientOpKernel : public framework::OpKernel { auto *dOut = ctx.Input(framework::GradVarName("Out")); // In place gradient: dRef = dO - dRef->ShareDataWith(*dOut); - dUpdates->mutable_data(ctx.GetPlace()); - // Gradient by Gather: dUpdates += dO[Index] - Gather(ctx.GetPlace(), dOut, Index, dUpdates); + if (dRef) dRef->ShareDataWith(*dOut); + if (dUpdates) { + dUpdates->mutable_data(ctx.GetPlace()); + // Gradient by Gather: dUpdates += dO[Index] + Gather(ctx.GetPlace(), dOut, Index, dUpdates); + } } }; diff --git a/python/paddle/v2/framework/tests/gradient_checker.py b/python/paddle/v2/framework/tests/gradient_checker.py index 518f828bac..82ab7ad39b 100644 --- a/python/paddle/v2/framework/tests/gradient_checker.py +++ b/python/paddle/v2/framework/tests/gradient_checker.py @@ -286,6 +286,9 @@ class GradientChecker(unittest.TestCase): for no_grad in no_grad_set: if no_grad not in in_names: raise ValueError("no_grad should be in in_names") + if name in inputs_to_check: + raise ValueError("no_grad should not be in inputs_to_check") + backward_op = core.Operator.backward(forward_op, no_grad_set) places = [core.CPUPlace()] @@ -301,9 +304,25 @@ class GradientChecker(unittest.TestCase): check_names = [grad_var_name(name) for name in inputs_to_check] for place in places: - # get analytical gradients according to different device - analytic_grads = self.__get_gradient(forward_op, backward_op, - input_vars, check_names, place) + # analytic_grads = self.__get_gradient(forward_op, backward_op, + # input_vars, check_names, place) + # In fact, the above two lines can be used to replace following + # codes. But most of the gradient operators need to handle the case + # where one of more of the gradient of the input is not needed. + # We change the unit test framework to explicitly test whether + # the operator correctly handles this through follow codes. + # In addtion, if all the inputs have no gradients, the NOP operator + # will be returned by core.Operator.backward(). The following codes + # do not test this case. + analytic_grads = [] + for name in inputs_to_check: + no_grads = [name for name in no_grad_set] + no_grads.extend(filter(lambda x: x != name, inputs_to_check)) + backward_op = core.Operator.backward(forward_op, set(no_grads)) + # get analytical gradients according to different device + analytic_grads.extend( + self.__get_gradient(forward_op, backward_op, input_vars, + [grad_var_name(name)], place)) self.__assert_is_close(numeric_grads, analytic_grads, check_names, max_relative_error, "Gradient Check On %s" % str(place)) diff --git a/python/paddle/v2/framework/tests/test_mul_op.py b/python/paddle/v2/framework/tests/test_mul_op.py index ee0d81a64e..81371b1d11 100644 --- a/python/paddle/v2/framework/tests/test_mul_op.py +++ b/python/paddle/v2/framework/tests/test_mul_op.py @@ -16,13 +16,14 @@ class TestMulOp(unittest.TestCase): self.outputs = {'Out': np.dot(self.inputs['X'], self.inputs['Y'])} -class MulGradOpTest(GradientChecker): +class TestMulGradOp(GradientChecker): def test_mul(self): op = create_op("mul") inputs = { 'X': np.random.random((32, 84)).astype("float32"), 'Y': np.random.random((84, 100)).astype("float32") } + self.compare_grad(op, inputs) # mul op will enlarge the relative error self.check_grad( op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.5) From 9a3c69c268d65c340ed5d0ae9aee1a90ca50ee84 Mon Sep 17 00:00:00 2001 From: fengjiayi Date: Mon, 4 Sep 2017 10:45:11 -0700 Subject: [PATCH 28/62] Revert "Remove `grad_op_type` in `REGISTER_OP`" --- doc/howto/dev/new_op_cn.md | 4 ++-- paddle/framework/backward.md | 2 +- paddle/framework/backward_test.cc | 12 +++++++----- paddle/framework/grad_op_builder_test.cc | 4 ++-- paddle/framework/op_registry.h | 25 ++++++++++++++---------- paddle/operators/add_op.cc | 2 +- paddle/operators/cross_entropy_op.cc | 3 ++- paddle/operators/gather_op.cc | 3 ++- paddle/operators/lookup_table_op.cc | 2 +- paddle/operators/mean_op.cc | 2 +- paddle/operators/minus_op.cc | 3 ++- paddle/operators/mul_op.cc | 2 +- paddle/operators/rowwise_add_op.cc | 2 +- paddle/operators/scale_op.cc | 2 +- paddle/operators/scatter_op.cc | 3 ++- paddle/operators/sigmoid_op.cc | 3 ++- paddle/operators/softmax_op.cc | 3 ++- 17 files changed, 45 insertions(+), 32 deletions(-) diff --git a/doc/howto/dev/new_op_cn.md b/doc/howto/dev/new_op_cn.md index ec79b7f42b..7f8da2da5a 100644 --- a/doc/howto/dev/new_op_cn.md +++ b/doc/howto/dev/new_op_cn.md @@ -178,13 +178,13 @@ class MulKernel : public framework::OpKernel { ```c++ namespace ops = paddle::operators; -REGISTER_OP(mul, ops::MulOp, ops::MulOpMaker, ops::MulOpGrad); +REGISTER_OP(mul, ops::MulOp, ops::MulOpMaker, mul_grad, ops::MulOpGrad); REGISTER_OP_CPU_KERNEL(mul, ops::MulKernel); REGISTER_OP_CPU_KERNEL(mul_grad, ops::MulGradKernel); ``` - - `REGISTER_OP` ： 注册`ops::MulOp`类，类型名为`mul`，该类的`ProtoMaker`为`ops::MulOpMaker`，并且注册`ops::MulOpGrad`为其反向Op。 + - `REGISTER_OP` ： 注册`ops::MulOp`类，类型名为`mul`，该类的`ProtoMaker`为`ops::MulOpMaker`，注册`ops::MulOpGrad`，类型名为`mul_grad`， - `REGISTER_OP_WITHOUT_GRADIENT` ： 用于注册没有反向的Op。 - `REGISTER_OP_CPU_KERNEL` ：注册`ops::MulKernel`类，并特化模板参数为`paddle::platform::CPUPlace`和`float`类型，同理，注册`ops::MulKernel`类。 diff --git a/paddle/framework/backward.md b/paddle/framework/backward.md index 9500c92a26..8aa6728a95 100644 --- a/paddle/framework/backward.md +++ b/paddle/framework/backward.md @@ -18,7 +18,7 @@ A backward network is built up with several backward operators. Backward operato For example, we have got a `mul_op`, and we can register it's information and corresponding backward operator by the following macro: ```cpp -REGISTER_OP(mul, MulOp, MulOpMaker, MulOpGrad); +REGISTER_OP(mul, MulOp, MulOpMaker, mul_grad, MulOpGrad); ``` `mul` is the operator's type. `MulOp` and `MulOpMaker` are the operator class and the operator maker class respectively. diff --git a/paddle/framework/backward_test.cc b/paddle/framework/backward_test.cc index bf8b11e5f5..ad8003420d 100644 --- a/paddle/framework/backward_test.cc +++ b/paddle/framework/backward_test.cc @@ -148,14 +148,16 @@ class AddOpMaker : public OpProtoAndCheckerMaker { namespace f = paddle::framework; namespace ops = paddle::operators; using EnforceNotMet = paddle::platform::EnforceNotMet; -REGISTER_OP(rowwise_add, f::NOP, f::RowWiseAddOpMaker, f::NOP); -REGISTER_OP(mul, f::NOP, f::MulOpMaker, f::NOP); -REGISTER_OP(sigmoid, f::NOP, f::SigmoidOpMaker, f::NOP); +REGISTER_OP(rowwise_add, f::NOP, f::RowWiseAddOpMaker, rowwise_add_grad, + f::NOP); +REGISTER_OP(mul, f::NOP, f::MulOpMaker, mul_grad, f::NOP); +REGISTER_OP(sigmoid, f::NOP, f::SigmoidOpMaker, sigmoid_grad, f::NOP); REGISTER_OP_WITHOUT_GRADIENT(nograd, f::NOP, f::NoGradOpMaker); REGISTER_OP_WITHOUT_GRADIENT(fill_zeros_like, f::NOP, f::FillZeroOpMaker); -REGISTER_OP(add, f::NOP, f::AddOpMaker, f::NOP); +REGISTER_OP(add, f::NOP, f::AddOpMaker, add_grad, f::NOP); REGISTER_OP_WITHOUT_GRADIENT(fc, f::FcOp, f::FcOpMaker); -REGISTER_OP(many_output_op, f::NOP, f::ManyOutputOpMaker, f::NOP); +REGISTER_OP(many_output_op, f::NOP, f::ManyOutputOpMaker, many_output_op_grad, + f::NOP); TEST(Backward, simple_op_grad) { auto fwd = f::OpRegistry::CreateOp( diff --git a/paddle/framework/grad_op_builder_test.cc b/paddle/framework/grad_op_builder_test.cc index 8a817a3e13..902c2655e9 100644 --- a/paddle/framework/grad_op_builder_test.cc +++ b/paddle/framework/grad_op_builder_test.cc @@ -54,8 +54,8 @@ TEST(GradOpBuilder, AddTwo) { EXPECT_EQ(grad_add_op->Output(f::GradVarName("Y")), f::GradVarName("y")); } -REGISTER_OP(mult_io, f::NOP, f::MutiInOutOpMaker, f::NOP); -REGISTER_OP(io_ignored, f::NOP, f::IOIgnoredOpMaker, f::NOP); +REGISTER_OP(mult_io, f::NOP, f::MutiInOutOpMaker, mult_io_grad, f::NOP); +REGISTER_OP(io_ignored, f::NOP, f::IOIgnoredOpMaker, io_ignored_grad, f::NOP); TEST(GradOpBuilder, MutiInOut) { std::shared_ptr test_op(f::OpRegistry::CreateOp( diff --git a/paddle/framework/op_registry.h b/paddle/framework/op_registry.h index 64c7f23ab6..2d09cde41e 100644 --- a/paddle/framework/op_registry.h +++ b/paddle/framework/op_registry.h @@ -33,7 +33,8 @@ namespace framework { class OpRegistry { public: template - static void RegisterOp(const std::string& op_type) { + static void RegisterOp(const std::string& op_type, + const std::string& grad_op_type) { PADDLE_ENFORCE(!OpInfoMap::Instance().Has(op_type), "'%s' is registered more than once.", op_type); OpInfo op_info; @@ -42,9 +43,9 @@ class OpRegistry { const VariableNameMap& outputs, const AttributeMap& attrs) { return new OpType(type, inputs, outputs, attrs); }; + op_info.grad_op_type_ = grad_op_type; if (std::type_index(typeid(ProtoMakerType)) != std::type_index(typeid(NOPMaker))) { - op_info.grad_op_type_ = op_type + "_grad"; op_info.proto_ = new OpProto; op_info.checker_ = new OpAttrChecker; auto maker = ProtoMakerType(op_info.proto_, op_info.checker_); @@ -54,14 +55,15 @@ class OpRegistry { op_info.proto_->IsInitialized(), "Fail to initialize %s's OpProto, because %s is not initialized", op_type, op_info.proto_->InitializationErrorString()); - // register gradient op - RegisterOp(op_info.grad_op_type_); } else { - op_info.grad_op_type_ = ""; op_info.proto_ = nullptr; op_info.checker_ = nullptr; } OpInfoMap::Instance().Insert(op_type, op_info); + // register gradient op + if (!grad_op_type.empty()) { + RegisterOp(grad_op_type, ""); + } } static std::unique_ptr CreateOp(const std::string& type, @@ -90,8 +92,10 @@ class Registrar { template class OpRegistrar : public Registrar { public: - explicit OpRegistrar(const char* op_type) { - OpRegistry::RegisterOp(op_type); + explicit OpRegistrar(const char* op_type) { OpRegistrar(op_type, ""); } + OpRegistrar(const char* op_type, const char* grad_op_type) { + OpRegistry::RegisterOp(op_type, + grad_op_type); } }; @@ -117,7 +121,8 @@ class OpKernelRegistrar : public Registrar { /** * Macro to register Operator. */ -#define REGISTER_OP(op_type, op_class, op_maker_class, grad_op_class) \ +#define REGISTER_OP(op_type, op_class, op_maker_class, grad_op_type, \ + grad_op_class) \ STATIC_ASSERT_GLOBAL_NAMESPACE( \ __reg_op__##op_type, "REGISTER_OP must be called in global namespace"); \ class _OpClass_##op_type##_ : public op_class { \ @@ -132,14 +137,14 @@ class OpKernelRegistrar : public Registrar { }; \ static ::paddle::framework::OpRegistrar< \ _OpClass_##op_type##_, op_maker_class, _OpGradClass_##op_type##_> \ - __op_registrar_##op_type##__(#op_type); \ + __op_registrar_##op_type##__(#op_type, #grad_op_type); \ int TouchOpRegistrar_##op_type() { \ __op_registrar_##op_type##__.Touch(); \ return 0; \ } #define REGISTER_OP_WITHOUT_GRADIENT(op_type, op_class, op_maker_class) \ - REGISTER_OP(op_type, op_class, op_maker_class, ::paddle::framework::NOP) + REGISTER_OP(op_type, op_class, op_maker_class, , ::paddle::framework::NOP) /** * Macro to register OperatorKernel. diff --git a/paddle/operators/add_op.cc b/paddle/operators/add_op.cc index 6384d8c8ce..8ab748ed71 100644 --- a/paddle/operators/add_op.cc +++ b/paddle/operators/add_op.cc @@ -57,7 +57,7 @@ class AddOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OP(add_two, ops::AddOp, ops::AddOpMaker, ops::AddOpGrad); +REGISTER_OP(add_two, ops::AddOp, ops::AddOpMaker, add_two_grad, ops::AddOpGrad); REGISTER_OP_CPU_KERNEL(add_two, ops::AddKernel); diff --git a/paddle/operators/cross_entropy_op.cc b/paddle/operators/cross_entropy_op.cc index ac76326262..ab1e1c101a 100644 --- a/paddle/operators/cross_entropy_op.cc +++ b/paddle/operators/cross_entropy_op.cc @@ -67,7 +67,8 @@ OnehotCrossEntropy Operator. namespace ops = paddle::operators; REGISTER_OP(onehot_cross_entropy, ops::OnehotCrossEntropyOp, - ops::OnehotCrossEntropyOpMaker, ops::OnehotCrossEntropyGradientOp); + ops::OnehotCrossEntropyOpMaker, onehot_cross_entropy_grad, + ops::OnehotCrossEntropyGradientOp); REGISTER_OP_CPU_KERNEL(onehot_cross_entropy, ops::OnehotCrossEntropyOpKernel); REGISTER_OP_CPU_KERNEL(onehot_cross_entropy_grad, diff --git a/paddle/operators/gather_op.cc b/paddle/operators/gather_op.cc index 07fa704824..123bed296c 100644 --- a/paddle/operators/gather_op.cc +++ b/paddle/operators/gather_op.cc @@ -63,7 +63,8 @@ Out = X[Index] } // namespace paddle namespace ops = paddle::operators; -REGISTER_OP(gather, ops::GatherOp, ops::GatherOpMaker, ops::GatherGradOp); +REGISTER_OP(gather, ops::GatherOp, ops::GatherOpMaker, gather_grad, + ops::GatherGradOp); REGISTER_OP_CPU_KERNEL(gather, ops::GatherOpKernel); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/operators/lookup_table_op.cc b/paddle/operators/lookup_table_op.cc index c3108ba8ec..94d40890a7 100644 --- a/paddle/operators/lookup_table_op.cc +++ b/paddle/operators/lookup_table_op.cc @@ -66,7 +66,7 @@ class LookupTableOpGrad : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OP(lookup_table, ops::LookupTableOp, ops::LookupTableOpMaker, - ops::LookupTableOpGrad); + lookup_table_grad, ops::LookupTableOpGrad); REGISTER_OP_CPU_KERNEL(lookup_table, ops::LookupTableKernel); REGISTER_OP_CPU_KERNEL(lookup_table_grad, ops::LookupTableGradKernel); diff --git a/paddle/operators/mean_op.cc b/paddle/operators/mean_op.cc index e66e0abb25..d3d0e55a67 100644 --- a/paddle/operators/mean_op.cc +++ b/paddle/operators/mean_op.cc @@ -54,7 +54,7 @@ class MeanGradOp : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OP(mean, ops::MeanOp, ops::MeanOpMaker, ops::MeanGradOp); +REGISTER_OP(mean, ops::MeanOp, ops::MeanOpMaker, mean_grad, ops::MeanGradOp); REGISTER_OP_CPU_KERNEL(mean, ops::MeanKernel); REGISTER_OP_CPU_KERNEL(mean_grad, diff --git a/paddle/operators/minus_op.cc b/paddle/operators/minus_op.cc index b4afebcd97..1eee9644ba 100644 --- a/paddle/operators/minus_op.cc +++ b/paddle/operators/minus_op.cc @@ -81,6 +81,7 @@ class MinusGradOp : public NetOp { USE_OP(scale); USE_OP_ITSELF(identity); namespace ops = paddle::operators; -REGISTER_OP(minus, ops::MinusOp, ops::MinusOpMaker, ops::MinusGradOp); +REGISTER_OP(minus, ops::MinusOp, ops::MinusOpMaker, minus_grad, + ops::MinusGradOp); REGISTER_OP_CPU_KERNEL(minus, ops::MinusKernel); diff --git a/paddle/operators/mul_op.cc b/paddle/operators/mul_op.cc index 8d0f59745f..5b8b5f6c11 100644 --- a/paddle/operators/mul_op.cc +++ b/paddle/operators/mul_op.cc @@ -84,7 +84,7 @@ class MulOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OP(mul, ops::MulOp, ops::MulOpMaker, ops::MulOpGrad); +REGISTER_OP(mul, ops::MulOp, ops::MulOpMaker, mul_grad, ops::MulOpGrad); REGISTER_OP_CPU_KERNEL(mul, ops::MulKernel); REGISTER_OP_CPU_KERNEL(mul_grad, ops::MulGradKernel); diff --git a/paddle/operators/rowwise_add_op.cc b/paddle/operators/rowwise_add_op.cc index 63de91254f..6825dce332 100644 --- a/paddle/operators/rowwise_add_op.cc +++ b/paddle/operators/rowwise_add_op.cc @@ -74,7 +74,7 @@ class RowwiseAddGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OP(rowwise_add, ops::RowwiseAddOp, ops::RowwiseAddOpMaker, - ops::RowwiseAddGradOp); + rowwise_add_grad, ops::RowwiseAddGradOp); REGISTER_OP_CPU_KERNEL( rowwise_add, ops::RowwiseAddKernel); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/operators/scale_op.cc b/paddle/operators/scale_op.cc index 4e039688d4..8e96a74c94 100644 --- a/paddle/operators/scale_op.cc +++ b/paddle/operators/scale_op.cc @@ -97,7 +97,7 @@ class IdentityOp : public NetOp { namespace ops = paddle::operators; -REGISTER_OP(scale, ops::ScaleOp, ops::ScaleOpMaker, +REGISTER_OP(scale, ops::ScaleOp, ops::ScaleOpMaker, scale_grad, ops::ScaleGradOp); REGISTER_OP_CPU_KERNEL(scale, ops::ScaleKernel); diff --git a/paddle/operators/scatter_op.cc b/paddle/operators/scatter_op.cc index 35c185ad80..f901edefa2 100644 --- a/paddle/operators/scatter_op.cc +++ b/paddle/operators/scatter_op.cc @@ -77,7 +77,8 @@ Out[Index] = Ref[Index] + Updates } // namespace paddle namespace ops = paddle::operators; -REGISTER_OP(scatter, ops::ScatterOp, ops::ScatterOpMaker, ops::ScatterGradOp); +REGISTER_OP(scatter, ops::ScatterOp, ops::ScatterOpMaker, scatter_grad, + ops::ScatterGradOp); REGISTER_OP_CPU_KERNEL(scatter, ops::ScatterOpKernel); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/operators/sigmoid_op.cc b/paddle/operators/sigmoid_op.cc index f35b702384..761c6de8d4 100644 --- a/paddle/operators/sigmoid_op.cc +++ b/paddle/operators/sigmoid_op.cc @@ -53,7 +53,8 @@ class SigmoidOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OP(sigmoid, ops::SigmoidOp, ops::SigmoidOpMaker, ops::SigmoidOpGrad); +REGISTER_OP(sigmoid, ops::SigmoidOp, ops::SigmoidOpMaker, sigmoid_grad, + ops::SigmoidOpGrad); REGISTER_OP_CPU_KERNEL(sigmoid, ops::SigmoidKernel); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/operators/softmax_op.cc b/paddle/operators/softmax_op.cc index 471bb288fb..40c51a64c4 100644 --- a/paddle/operators/softmax_op.cc +++ b/paddle/operators/softmax_op.cc @@ -62,7 +62,8 @@ class SoftmaxOpGrad : public framework::OperatorWithKernel { namespace ops = paddle::operators; -REGISTER_OP(softmax, ops::SoftmaxOp, ops::SoftmaxOpMaker, ops::SoftmaxOpGrad); +REGISTER_OP(softmax, ops::SoftmaxOp, ops::SoftmaxOpMaker, softmax_grad, + ops::SoftmaxOpGrad); REGISTER_OP_CPU_KERNEL(softmax, ops::SoftmaxKernel); REGISTER_OP_CPU_KERNEL( From bb0a11cd14902971902987e2ed6f7107ae758bef Mon Sep 17 00:00:00 2001 From: Yi Wang Date: Mon, 4 Sep 2017 13:01:18 -0700 Subject: [PATCH 29/62] Add a graph building example --- doc/design/graph.md | 51 ++++++++++++++ .../images/graph_construction_example.bash | 11 +++ .../images/graph_construction_example.dot | 63 ++++++++++++++++++ .../images/graph_construction_example_all.png | Bin 0 -> 60087 bytes ..._construction_example_forward_backward.png | Bin 0 -> 55715 bytes ...raph_construction_example_forward_only.png | Bin 0 -> 32082 bytes 6 files changed, 125 insertions(+) create mode 100644 doc/design/graph.md create mode 100755 doc/design/images/graph_construction_example.bash create mode 100644 doc/design/images/graph_construction_example.dot create mode 100644 doc/design/images/graph_construction_example_all.png create mode 100644 doc/design/images/graph_construction_example_forward_backward.png create mode 100644 doc/design/images/graph_construction_example_forward_only.png diff --git a/doc/design/graph.md b/doc/design/graph.md new file mode 100644 index 0000000000..87f696f90f --- /dev/null +++ b/doc/design/graph.md @@ -0,0 +1,51 @@ +# Design Doc: Computations as Graphs + +A primary goal of the refactorization of PaddlePaddle is a more flexible representation of deep learning computation, in particular, a graph of operators and variables, instead of sequences of layers as before. + +This document explains that the construction of a graph as three steps: + +- construct the forward part +- construct the backward part +- construct the optimization part + +Let us take the problem of image classification as a simple example. The application program that trains the model looks like: + +```python +x = layer.data("images") +l = layer.data("label") +y = layer.fc(x) +cost = layer.mse(y, l) +optimize(cost) +train(cost, reader=mnist.train()) +``` + +### Forward Part + +The first four lines of above program build the forward part of the graph. + +![](images/graph_construction_example_forward_only.png) + +In particular, the first line `x = layer.data("images")` creates variable x and a Feed operator that copies a column from the minibatch to x. `y = layer.fc(x)` creates not only the FC operator and output variable y, but also two parameters, W and b. + +In this example, all operators are created as `OpDesc` protobuf messages, and all variables are `VarDesc`. These protobuf messages are saved in a `BlockDesc` protobuf message. + +### Backward Part + +The fifth line `optimize(cost)` calls two functions, `ConstructBackwardGraph` and `ConstructOptimizationGraph`. + +`ConstructBackwardGraph` traverses the forward graph in the `BlockDesc` protobuf message and builds the backward part. + +![](images/graph_construction_example_forward_backward.png) + +According to the chain rule of gradient computation, `ConstructBackwardGraph` would + +1. create a gradient operator G for each operator F, +1. make all inputs, outputs, and outputs' gradient of F as inputs of G, +1. create gradients for all inputs of F, except for those who don't have gradients, like x and l, and +1. make all these gradients as outputs of G. + +### Optimization Part + +For each parameter, like W and b created by `layer.fc`, marked as double circles in above graphs, `ConstructOptimizationGraph` creates an optimization operator to apply its gradient. Here results in the complete graph: + +![](images/graph_construction_example_all.png) diff --git a/doc/design/images/graph_construction_example.bash b/doc/design/images/graph_construction_example.bash new file mode 100755 index 0000000000..35e6997abd --- /dev/null +++ b/doc/design/images/graph_construction_example.bash @@ -0,0 +1,11 @@ +cat ./graph_construction_example.dot | \ + sed 's/color=red/color=red, style=invis/g' | \ + sed 's/color=green/color=green, style=invis/g' | \ + dot -Tpng > graph_construction_example_forward_only.png + +cat ./graph_construction_example.dot | \ + sed 's/color=green/color=green, style=invis/g' | \ + dot -Tpng > graph_construction_example_forward_backward.png + +cat ./graph_construction_example.dot | \ + dot -Tpng > graph_construction_example_all.png diff --git a/doc/design/images/graph_construction_example.dot b/doc/design/images/graph_construction_example.dot new file mode 100644 index 0000000000..b77ddd448e --- /dev/null +++ b/doc/design/images/graph_construction_example.dot @@ -0,0 +1,63 @@ +digraph ImageClassificationGraph { + ///////// The forward part ///////// + FeedX [label="Feed", color=blue, shape=box]; + FeedY [label="Feed", color=blue, shape=box]; + FC [label="FC", color=blue, shape=box]; + MSE [label="MSE", color=blue, shape=box]; + + x [label="x", color=blue, shape=oval]; + l [label="l", color=blue, shape=oval]; + y [label="y", color=blue, shape=oval]; + W [label="W", color=blue, shape=doublecircle]; + b [label="b", color=blue, shape=doublecircle]; + cost [label="cost", color=blue, shape=oval]; + + FeedX -> x -> FC -> y -> MSE -> cost [color=blue]; + FeedY -> l -> FC [color=blue]; + W -> FC [color=blue]; + b -> FC [color=blue]; + l -> MSE [color=blue]; + + ////////// The backward part ///////// + MSE_Grad [label="MSE_grad", color=red, shape=box]; + FC_Grad [label="FC_grad", color=red, shape=box]; + + d_cost [label="d cost", color=red, shape=oval]; + d_y [label="d y", color=red, shape=oval]; + d_b [label="d b", color=red, shape=oval]; + d_W [label="d W", color=red, shape=oval]; + + cost -> MSE_Grad [color=red]; + d_cost -> MSE_Grad [color=red]; + x -> MSE_Grad [color=red]; + l -> MSE_Grad [color=red]; + y -> MSE_Grad -> d_y [color=red]; + + x -> FC_Grad [color=red]; + y -> FC_Grad [color=red]; + d_y -> FC_Grad [color=red]; + W -> FC_Grad -> d_W [color=red]; + b -> FC_Grad -> d_b [color=red]; + + ////////// The optimizaiton part ////////// + + OPT_W [label="SGD", color=green, shape=box]; + OPT_b [label="SGD", color=green, shape=box]; + + d_W -> OPT_W -> W [color=green]; + d_b -> OPT_b -> b [color=green]; + + ////////// Groupings ////////// + + subgraph clusterMSE { + style=invis; + MSE; + MSE_Grad; + } + + subgraph clusterFC { + style=invis; + FC; + FC_Grad; + } +} diff --git a/doc/design/images/graph_construction_example_all.png b/doc/design/images/graph_construction_example_all.png new file mode 100644 index 0000000000000000000000000000000000000000..3ee61f9ef4544da786480f188403742d48a1d9e3 GIT binary patch literal 60087 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 z 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 literal 0 HcmV?d00001 From 9f3bcd0e4608119cbafce9db7191a74bc8a8bfeb Mon Sep 17 00:00:00 2001 From: Yi Wang Date: Mon, 4 Sep 2017 13:10:05 -0700 Subject: [PATCH 30/62] Update image --- .../images/graph_construction_example.dot | 2 +- .../images/graph_construction_example_all.png | Bin 60087 -> 58932 bytes ..._construction_example_forward_backward.png | Bin 55715 -> 54429 bytes ...raph_construction_example_forward_only.png | Bin 32082 -> 29878 bytes 4 files changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/design/images/graph_construction_example.dot b/doc/design/images/graph_construction_example.dot index b77ddd448e..86f82fe05a 100644 --- a/doc/design/images/graph_construction_example.dot +++ b/doc/design/images/graph_construction_example.dot @@ -13,7 +13,7 @@ digraph ImageClassificationGraph { cost [label="cost", color=blue, shape=oval]; FeedX -> x -> FC -> y -> MSE -> cost [color=blue]; - FeedY -> l -> FC [color=blue]; + FeedY -> l [color=blue]; W -> FC [color=blue]; b -> FC [color=blue]; l -> MSE [color=blue]; diff --git a/doc/design/images/graph_construction_example_all.png b/doc/design/images/graph_construction_example_all.png index 3ee61f9ef4544da786480f188403742d48a1d9e3..d769d70af759873802144f0dd0ddad21976a22eb 100644 GIT binary patch literal 58932 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 a`Y)g9=2N@ALobK{2s~Z=T-G@yGywpYgtEf` literal 55715 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 literal 32082 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 z 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 From e4494bb4417561ae59e26aec176e766214aa61f7 Mon Sep 17 00:00:00 2001 From: Yi Wang Date: Mon, 4 Sep 2017 13:12:48 -0700 Subject: [PATCH 31/62] Correct optimziation part --- .../images/graph_construction_example.dot | 2 ++ .../images/graph_construction_example_all.png | Bin 58932 -> 55421 bytes ..._construction_example_forward_backward.png | Bin 54429 -> 47228 bytes ...raph_construction_example_forward_only.png | Bin 29878 -> 29192 bytes 4 files changed, 2 insertions(+) diff --git a/doc/design/images/graph_construction_example.dot b/doc/design/images/graph_construction_example.dot index 86f82fe05a..bedb6de011 100644 --- a/doc/design/images/graph_construction_example.dot +++ b/doc/design/images/graph_construction_example.dot @@ -44,6 +44,8 @@ digraph ImageClassificationGraph { OPT_W [label="SGD", color=green, shape=box]; OPT_b [label="SGD", color=green, shape=box]; + W -> OPT_W [color=green]; + b -> OPT_b [color=green]; d_W -> OPT_W -> W [color=green]; d_b -> OPT_b -> b [color=green]; diff --git a/doc/design/images/graph_construction_example_all.png b/doc/design/images/graph_construction_example_all.png index d769d70af759873802144f0dd0ddad21976a22eb..18d8330b60e12720bb993c8cf588d64ff8db1ea9 100644 GIT binary patch literal 55421 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 FicZNdOu{6!~x|$4e8^R-WH)b|ew`rf%5jbt;cg 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 literal 54429 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 a`Y)g9=2N@ALobK{2s~Z=T-G@yGywpYgtEf` diff --git a/doc/design/images/graph_construction_example_forward_only.png b/doc/design/images/graph_construction_example_forward_only.png index eb1a22da72e1d9aa7abddad1b70e1da995ebda67..14805df11fc09f64d6bc17f5e969f1400d615148 100644 GIT binary patch literal 29192 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.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
TSm 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 From 29fa887475b724cabaee9c69265d9e5e6db0076c Mon Sep 17 00:00:00 2001 From: Yi Wang Date: Mon, 4 Sep 2017 14:57:44 -0700 Subject: [PATCH 32/62] Add initialization operators --- doc/design/graph.md | 4 +++- .../images/graph_construction_example.dot | 4 ++++ .../images/graph_construction_example_all.png | Bin 55421 -> 59679 bytes ..._construction_example_forward_backward.png | Bin 47228 -> 51389 bytes ...raph_construction_example_forward_only.png | Bin 29192 -> 32270 bytes 5 files changed, 7 insertions(+), 1 deletion(-) diff --git a/doc/design/graph.md b/doc/design/graph.md index 87f696f90f..e59d04e1f5 100644 --- a/doc/design/graph.md +++ b/doc/design/graph.md @@ -25,7 +25,9 @@ The first four lines of above program build the forward part of the graph. ![](images/graph_construction_example_forward_only.png) -In particular, the first line `x = layer.data("images")` creates variable x and a Feed operator that copies a column from the minibatch to x. `y = layer.fc(x)` creates not only the FC operator and output variable y, but also two parameters, W and b. +In particular, the first line `x = layer.data("images")` creates variable x and a Feed operator that copies a column from the minibatch to x. `y = layer.fc(x)` creates not only the FC operator and output variable y, but also two parameters, W and b, and the initialization operators. + +Initialization operators are kind of "run-once" operators -- the `Run` method increments a class data member counter so to run at most once. By doing so, a parameter wouldn't be initialized repeatedly, say, in every minibatch. In this example, all operators are created as `OpDesc` protobuf messages, and all variables are `VarDesc`. These protobuf messages are saved in a `BlockDesc` protobuf message. diff --git a/doc/design/images/graph_construction_example.dot b/doc/design/images/graph_construction_example.dot index bedb6de011..8d1b673abf 100644 --- a/doc/design/images/graph_construction_example.dot +++ b/doc/design/images/graph_construction_example.dot @@ -2,6 +2,8 @@ digraph ImageClassificationGraph { ///////// The forward part ///////// FeedX [label="Feed", color=blue, shape=box]; FeedY [label="Feed", color=blue, shape=box]; + InitW [label="Init", color=blue, shape=diamond]; + Initb [label="Init", color=blue, shape=diamond]; FC [label="FC", color=blue, shape=box]; MSE [label="MSE", color=blue, shape=box]; @@ -14,6 +16,8 @@ digraph ImageClassificationGraph { FeedX -> x -> FC -> y -> MSE -> cost [color=blue]; FeedY -> l [color=blue]; + InitW -> W [color=blue]; + Initb -> b [color=blue]; W -> FC [color=blue]; b -> FC [color=blue]; l -> MSE [color=blue]; diff --git a/doc/design/images/graph_construction_example_all.png b/doc/design/images/graph_construction_example_all.png index 18d8330b60e12720bb993c8cf588d64ff8db1ea9..181187503472d15779b87284105841168b3945c4 100644 GIT binary patch literal 59679 zcmYg&WmuG5*ES8(AdS?ZAl)Gif>Kh_4MTT#cS@Ji(%s!LAl=>F-7$RQt-jCqYdGeZ zYhP=xz4Bb=CR9%5Ga51xG87aPnuNHh0u&TX1r!u?9})uOo6q6qkT0O1?G-+YK$VTW z*@uD>f|3vwR&;?rN`r4v6npF=gOgVj!op%`zZts@-o-(id7s?FDX6PC`RhQ&U`bQmDTZ03X6* z0hvheVZwa=eaI0awJZ%KUe*k}FHTgzl7qv678CmS5lwYTgY>`O{`aKNJBmzHi+8n& ziAw)|_UEB^-|3|Pd-A`pGP5y-5bHKfPBdehPx1DxheyGWIx#<^@KU_NVa1<*(p1!` zIDN$+rMKJ9o!`Au;e?T5Vz_uXg#4ZKpM29nJ|l?N^(JlinHvOi@;^mo1k|>EMu|Gj z32$9Zidi)X8+1U$Xty39ikybvLtBd#P=8W8l8}Z%ajF z&}kUR^|o2}nfe5COl_DSE~R5WlVZ&~X>fIxRtELwNPG)jb~TPEt-~f{7tfJO>hjr} z-oqNZp^dODR-Sndet1EGE0lO`s0-^m9tY8jTmsUbM|8Uy$}nQ#tnc%+3fH*v3H`-> zK46rO@?yyzz+66dF&O@I>J2DwrRtK*Ggrx1W_B!cR(t7<@TpT7@-cV%r(PjSQSw^U zqoa8M*Yew{ivfW1%KqD83p%TIPa8VRs?h$uae(s@#l_VmptuBJ*NY4Aej)K_Pe=Q` zZ=3U}ss9}uxgboTfo@DyHiA#tVODTh1&QZTCE&}CopK}n>Fq!V z_%iBpJ1qThGb$XF5O6WV3;1D8%J}}UjLwfYKbRET^^hS(Nd@=ADPN2r7>O&xO!muS z@q&ixVg5g}S44mbWvRdrq_2870N`tq+iiqeHIsR&T&e!dUUtS8W?0V-Pd%NJNfQl1 z$L$<%Q_zE}X+_@rse=1|oXO>v|Eai5TJ z8oi#CMSNSpvW9RlZ=9x>=<}*!t&74N_|~!?At1v?%d^tXCl{Jg%YL>UD zZ#`X#fufv?U`+#%Znelf$nB16WmqHh=Fzx9)-u~!q9G??Vp#g~pJB+6Ac=N$08GWY z-0s!^yvJKGSgEdg{V*sw#OyHd-q=UP^^iIxPbO%YGvLqDEx%(bcUaKgUeA}M`@g^= z)PfW+(BXBR(4X$k!=)O|#CQRI1k^79s(P@`m5Y{^kW$Cm+b>mpBs;(HhFLV1_BYsW z=cShI*0xSeld2Q_+lvs^dvsqpf;mDq(Gl+M#@?AU6xVc2xYP=FgIhf}{oyomV|PHGFrnSsCQJD#qGCPC@@d=6*D*mVekh zDga3AyAfIYlxRx$%G_N^*`1@Nu-WO@tediZ`#NRPBH)|%QC-IyIqU+gEb__#`G8Or(_nv)DwGAkk!g6w8+%M3c3} zER>(|?sZ|UiP=q}9XsBEWWvxqCYHgJ@WWZWr!8!|(k_C15iCa4!x5$vJ;|^b>_!9e zXA_Ln?<~u8uO`N{VG#(bm+U&X>9$J@60Si90B^HelA)2&n>iD9S< zF@hf_!iP$H8V%Z+NW|12?77+bu$vlZOSM!Ukk#97KF1uxwPNFC{doQQ{&Ljjl7^GR zvb;+?x3m>Gsji`zL8Fe|W%Im`jESzKLZs7uppkpkl;2|JH76v}gjuoGl$oY*`b-cfS?Ks@DZK580AsCR}kJbJWgA8XZ&n zQx$zxKVSyq_+f>u`KT(Ky%M>ke#NcWVQ);>?fPJQmGpr6q}yp_9$uv3N+E{gqv+jR z55|XTTZpfpzt7KV4P&z0cV2NnZMExwMx1(kmUcX3@#uXy%;gt0qO4)5WIz0J(S^d) zZ$f-XSex!y@@;72u4gb)$Ln5<)NPLqihJTb;LZo(bh%`$&Lf?P0Ff_#akHza)L@F{!@p zy)HibWe`qUy3BYz!UFBQKhcXIrz)hZ3p z4SR2|$}_wkej$+0|I&aet6MPBUcETgTW@&2SsYa7>_P;^EMay)7RoC4#mAG}CI^7#jW`6e@_80JD zxidJFI{j=!&D3Jplg#Tb%lTyIhjrNpV`@`iE5X#$x68o>Tad%yr)XuM)9P}vjyD>Y z^Y3gQ(bW1h5mb6OJEgT&a!NB6v}Ypp~9pbWOB|-+gtmyy!l{ zh}3EiYti{|eW+sZ8K$(Cw`y6x?8LFlxn%RvU#3*nX|`Kx_9Wmge*lb1oKc06^Xk7E z5fckWFUmR6M1UYVSEORiZ$w@YTZL}x%A;i?a^R$eS`uZ!FAJe!LXu9R+NiAGyreQn zB~SX$>}{!VPqpo9KfU5wa!5K+My8+0$8c+1PZU|CjDL<1WPQ`9UV`{t89~N_> zrtjW=ZiDEfml4jg1B=+!fb{vS8$&zeq3faR(5ha&1Ufe#JDMiJaJOr9+hspDiEkQa zaO*+B(<*I83)D-9IOH= znX6Nz)5)ZZyNn#^21!NuirAZ1hsH>)0vRD9aQCx!BXu-QUI8i37lTZ#5~-JZ(O+iN zEyGKi%ld~>Mlg>2F~S^<2tFO;=4Tz_Mrf%o(lyldW(2+pv@uVJIvW!fH_CRruGgU5 z?2D>z3lIJ!?-UNjL>A34ab1%+OBNX?j#4fu(s&_ED~ zCN?y!qGMTtgY*s_2#cLeSJu$w0ZA{~ii{(*)~hRPj%$zu;%Gju`{A6SB|!j?owNCF zG|GQ_HKIns&*pJw!vuTC)34gi=$a{bR-vqi~= z&dXwk5n-b(5=E1HR;l3OuLwQ*9s;ugj{ZfGU;a@D1;MC*$eJ_63p zb#{0}%7^MB1E7S^A|3xR?v9Vrz##Bl?apC&`^e*-^rJ#lwLovlfbfbt#QTgqk~ACk zkmF)O)I&`s>inGk#?ukVy7C!BolR@aa#0vR)O;rKFD$PH`C51`gBg4ss)hLj#sGw`yA&Rlx>>=_E ziA;XS85YH6KzpT`tNDXZ&EVy^H>kq#lO^1J)3cLJ^EG&^l3&%0E`3wR=eYSF>j#y$uxFL#4;5=>X*2p`11O>F4lc`%9Lzp;5}%})jRflWB#>Qp%D%Vxg(>sbl}-~f8Mp2-!* z4M(h%SUx=6T(vTE*I4R@y03M)xPhWCT*?PV`|(LLvw# zE~dWfr`1w_O|RK1I!;JT9JBi$jv<5zQ^{Q61zK+ArJDJa7mu%v*%^&QG8v((4la%H z%8qhhc9apkZF>|gYhRHFte>Zvu%KhKwJZ-aXJx4PC)C(`%#Z}%Yph;tdNX+Aw0Dpu zdt`#_)5NFn$kZSVXHx7D?w`uCx9u;urVH#BC3KvykOeGx7#jX90Ko&^c6In|`Jsee z9Ur2$o{>m#J9(658)3rFGapx7&j4E8LLK%2oOmt$2`XVVX1HQj(@A-CD%Z7zGyj#I zzgx@#ML2Aru4l(WJw738PvZ)p0%N@FW?5zHu>6^K;4zg)X{+F;Xpt{P&{l9h-lOLu~PxrZKW8`2nN{q2xb1PBf z4J?mK1rjtuSS})&LpmH|qv%%6q^M0?V3J}3C z!piXcg2$e7w~i6;Ohty$Gee1C((Bzb31@h-=?1=sI5Li#WO>5x6&jHaF8{Z}7$%&; zuZ{;?lSxoxGZB{z+-eSi-f>IyrS95l_ij850P)RQM8|iI*Mw}KLR5#nXxAjKC?W_X zQGhjb^}h}t3Ql3T9#)Oj$<@ z&h+r4Sw%*R=%WPN;^C5g8aqk7A-)d1-P1W>_y-pPj^E+kaXny=iOhpxqG3lE?DH1ysT%N3Rt(HY4NYT8s_>Z|l6e)*`O8-#)Uc}?YlY>2UMi?su z5!z69vs2Ap{!c@TMCMzhs~giHvg)}jaNQ1ha4M>!yq#y00hJ=*UnlP?DUwM`FqfNX z_qy_+Q+c8|-|!0&^xF!TK=JTe(+L-oe~?mwzmO7hg{Ys|tPENs?QZR4Y#uZ;f$FsP zmyc2=gnySK3j6&dMIwIHgbvP{`)e>L!iTjYvhlk116memTvFB{Gk-y~Hl4oMifyPJFrTz=^MOcs>7FR0O%7h7F zA-#vyfD?BM|N9&*mK*|S!fex-qlj#7z=D_IPwFbXBE8+SLxIx#}{37=O)8){@ zp(8$*|5-y$4M~v%ws^dO_7Hw*g32GF-(PEGjelFl0DqxrmI_*5wB6n@#Uf(p3}47f z2Uf4hqFCb3K?n7t0hnrQLM9eAq=ssHm(Nvr}|1U$;J!mnaGLlQI# z>hxmd?~n>G=Hl4{@IL-YZkcc4io$$*Lr`|EgUKYjM9382h|pjLIyk@Q&4m3Y2_(2f zq?Dp7q)<_6D^@SW#Pab~dY;9Ep3eDuDEeZVMFgsfNaP$_cHDd3V&r5nM1gcO384;Kn~wolg;annTy*T+4CH5^c&{aa@Jed{0EM|vOgwZf% z$lF%><3IhP5HpfyziI}IiDSwk)WxvZD1ZIWZE3|a4IwV(_Pq`;1Y;-j?g{&8l!v5<3bWTPQUrTwGxqXV;R(S)N~{&^{zP_4 zD}x2^z9B+SA(AI_@VvSD?XZ6;q_L8VFwKS@aa{`3Mjl7I)#n#b2)pUV%fx5_Ce&_m zIbI5XGbdt(Y11KNjQmft(aYn2*P?iu%#W$yFm&j4hIrpdbl?}YKYArshb!{)4U~Ua zN9?Qdx{QRJKVVjin$@8I0_g+3=7mWAp!y9j7MEZ%WPWebc+2-#(vQLvG9>8D0PrB= zYq){r^e{-&v;z^=?p|qJLHv-IAN1Y-uedcxihQu{b9xX+p2lx#l$sznKf?*TqtSj@ zE$7QX%L9_wi|d*%fT`_0tGP0`<@O+#FM`thqkJdtkD+HG1q2H99(LTE zqz$*gpvLkOP-nQNjm}gVk5-URI)n-9&T5H$=Vb7pj=l7}W$=j7Mk9j+t|9?UfwJ$} zf2HyGElu-&9)Q?NHCfHiciH3ePG~w+RJ|5^-jo_Er$jh_k@a|{5;&&BkN*y0!kW#UVdb|?b$6f7%RBdfihyzNN3mEhaaU<;Vl zjMGw%SUKOAYIVQ4ubsjEaNcud|LTP(+1Q_JT|XiE*>yMcjg8PU;(XDH38kU-A>j3M z3OpX>yg5_fdqYWmJ?;7>g_PMnjgCSaO{bJcgTn8PUn@7l%HXbI#PF~ngPpAq%8mC4 zJ6V5J63q@nSF*NaY!Q^4#I`>vYwpcrt?6!gd|Kl%NMolSHhpGy)LP%qIymKtPBO$$ zSKzKa+T-5=enc$BDtHj$yZcEwBH{-xN_F`?g*SpB%g}j|;j+X_<&VP^7{TFbtM+g; z7(=;A4(zX%D+`|HkQ4VZIQy!j%^1v940ETyyviKPnJ zJe}Cr_<6Tcg3_lr$7AqJkWG8aDq{y#?5!1gTf@G>kk=twB3np zU5<)D5XXHQYsi3bMkD;FI;#I-aCh*_Xp$e4FN#U9w3cdJaN9jq+DvZllzhhDB=H{2 zmj#&0AMnBsgYE!4ZCezKYZ@Ie)Wx#wu7EkAj0$-=4~{!pXALjVY_Jk}a69k)=Bob~ z@1ESB|HWRKF{XLNweOkY!;&s6HDms`qKL+wA-uN@bb%^XtL9w=%*StASGaD*l*rF2MSZO(Or-!c-^COnWl? ze{d~+D31dYThf5^VI-I6 zw-2AT;$+|Wd*95Dv)=U>AUslhOqF4K_&}qLme(e~>ZxMTdYvje$EYQ`;w^YBHUsmw z0_q8XYMz+O!E`N_C5s`p3ZdDYs47H7xM{t8v)KdZaa1Y8O5~`BRM-DQ zM77<&z%|F?e0?CCgCuUqP#yovVcri>C@!*f$F>g&)%(-@Qy`UE*CkW~_KCx8npl&Q1Zft)UXR0iG8$uos-kDVVBl80S_Z*nwA|)p`*?Uo&Tp;|5Hie>z%8eDg*W(i z0yiGC;LbbFJ9;19z3uHv~fg1$YP-H>?{6zmTvhqpUPQ37@#Cj!4O=|>3flBX!6a47bK z8THlzM~+dLxTpPUf*J-HoRiyK5zlXYRyZ?s_eQ&0+6e~k{rTOb!J-{cLq$Y8iE}eo z@H)s;O3st2i?q%AarO1jq5EAFcC_ZZBs(c?`GPc}1Wda$c&z#r26L zZ~P5&t0cOw!kMv!e!7qr)An6{oUfRzOE5`lI9Xk!zaJKP??(W)N%Z1Iu&H0?mVF>@ zn7gOi`M4Z&2eU~DA5zLpeL0e}24kmUwG2rKW)QdQd^%=2T7yk?SVNP`r@(kX5XO*uG_k9kxAkua2dAv&v}E zaydeFY3EbR0#Fl%2vitM=F|mn@p771#bhgIRqkv7+%YDoiUNE#qFntekq=!j{Lb}L z7fkbY*Ch&FmAmZq)<=mL#m}~Y(b!Lj3!%(fSHoPOlBzHkx>AFoB%K+C#id5jl2@2w>s+$~gSpaOeeWEInJ+0t0&ElF1_YB*&$6A$Tqd-1#w@{PNh|G+Vqr z6ioqQuO#&w{XpHoY29Wz#B)e6+0w{DorZ%BPWkYB_mgEe-F&DErP*1pCuFF&cD1|_ zlyEsAWj?AjS?~SAv6B@XF>gkvGCETlIq&U#n-0E^;^TNe<^raBOeA+>aOGKQ%yMxq z^d~o;uHXnYTrpdgDrRnZ}||Md=3($?hu3SVm~8G?ZNpBZNmc6YqtVlj;% z1P&#r5LIs{S_v7f9gTM<(3Qy$Ik&=I{NNn!tbi1juFBf;$&<2NJGHYB(0SZ@hvkut z+jzjb#gXLuT`nVE_$59W!lE=H8ZfLvZ^y*ytmb4g#|)AYX}&az(dBTY>B3a3kc|V$DzD;e+0V7?n zm4GgUlb>3+qXf)`R@{jvvjc%9`}9gf!k*wpmSEC@qJi%l0k0!mU!J#!gIHccf33GV znTAYglMzXojYd+p2Jwtu5q$vf>*=PXa?ST78zyleeBww-cLgQ);ya_9RRZnHgI*p- z1=DhHO^>iX!?9sFC@Z`E{1lksjZM?`SjK|FXfoveqQT{SHfKuBC8y=-xO^y|F1!%T zo_M>tn{l`^1)(DqT}qf83dD@CUHO8amruF?;RN;|LJ+xSSu9xE7~BTtPD zh|U8svx~~UCAeWuMxX)}MT`Ny`LB18_u$7Nx`bO#5Ndv%Fu%P@A#>z%b2Ed%6k=>< zl%SJ>ZO)}IO6v0sTb>p#uxI(AqlEkezN0yrYDn4IB7D>%%pkSR-^@cE%? zh!w>5Wb>vmC?j}-Odtc{=k1t_#-^3a%9DW^GpvbB>>qBP3)k*@t=K`R(iKrd&lk05(Q* ziLGpAA8v+Qu~)6@L>KD0jGnI#Su2^n91IjQ?FifNBvrj+9*;H;l8bM{6(ik#Dqz(P z2zk~D&8Fb8N09Oerod75-ZRvRew}9?!P#!>;!n}(fAwSoxIvnp#mKC(@pA21n>_oJBGK`7j zVLgnL%$e13=6rLMp52xj@ZdnxKm&G^lS=m$YYMjQm;XFXlbR3iL7y;8nr_9rO<`)Y zK_zXcWmpY!W=HoE!ZtAzrr#T8Yt9=MZ zY`TQkrH-F>vJpNRVc}xfe638~DiL0;-7DBq$ME4@os+6(m8Uiha>zTCx)4P99;1rh zN=^+}8uB*+YmP>hy%EB4+Q(aL;YjwFCGWn3dCN0Izk%hoN+s^Ld!$>OwovIn%}XG# z9y=dg?%K%(@(PIel1DoJ>f2l2O#GHQp;b!sK4uE2nG{|>n#?Af7aC1Oc~2?+5eQht ze7(aWq3{$Z>aD$E5jpniq=6DXP(mK70?LT|BMi2|@Ed#il*KVC6V#z%42C)e7iysb z|L^LtId}MhUUsPTo(Y+>jVLw|IcK*iPWlnTAsy&)RF!N&D<)+!);s*B_vqlhH*s1- zZ-lyA@;Yr8n+-bKLk95PUbmfzQ1{A)ABrQ0+Vtkz0N*A%p^~h+Ql~7?fq!kB*7Eox z57ALzB=})*-y3jcwq7ZmT@#E{t%-(QT}`qWBv#R5%3wYDbRc@aq)D&iykwut2KjFH z>YDqRd`t-t;aDu*)5%NIZL!@K?Vp$SgYMy`K2AJi#@3At?~?XA|7mIGxni^umv_os zFvz5ng!MVnA09zZE{k6c|&0SnpMC`;VIG-3jB+?fMC2jq(A8(pm)|X?8P7rHDbEO78sSqXgx=-K`Mi4WDU(yC2@0v`zN`Q89RbxQ zP9(6=6P1Lsg&~vIYr!;&T8mk@ceOJP2do{B571(tIS%%-HtrB}$ZT@rFzQAFIy1_2 z5TybXt8Go8HXLQJGNGZx%Y5=jA}KQDo=7sqHZo9Q!*d0|Tdc1_$uv$0JQb1kjzkHD zh5f6f_$-naX{4%&po7Yd(^IspL@EIZ&qviqm!>a)xHLByjc$_xErEKHtQ~OJt^?8L z?~|OQf6|h<%{KIf(}|XCWGu(pZk}$-yczvQa#+S(9iG?Diq&Dx&%?Es(<^G?)KQZ= zY^g6jT^@(Vhb$7^AbvjjsR`)`aftfWm=sf}MXiz(D2kto)%aWgio0=!>}5GTKF++o zY|P{7D5K$MI>3H6tmQ)T=Dz0X0qhn{%Xh&3aZte0k$%c{`q(mupOt4&J=S<$?zWzhZzn<>#4ny4}S-2;o^) z@VUmKAF}(8X zsCsnZYJalz6lK2asA`aLdlnd<7mSNx(rP4X)n@ym~zZjrd0Q z63hPO`PSIz^@FoVboS_v!#zSSf`%<|%4^6(e2jGvl*o9@YG<%BztR4phbuQ)^|+x{cNSAeVgy2o1CImdW3eWt+}m(6q{XM=61(f-Lr z#S0ah?NxWeN-NuF&u!XRi>|sUEulPRzyP8doV>e&!jr!SE8`PCe2>CcBu z&4lezn!mI{hRahNk)n<7b*LhVcfAst9<=AIFtokyw;_C%Lsg~d4~dpQZ7j911GTH; zMHL9Gk|TxRy^h^_Me{pk7{XfpqETmInj25DtxkuxQLUIQa3uF|eKsjkMUw8VZ7|G1 zC;P6ukFiKrQDDw9)XiMx9K))!;Vdbb)NWCs`GiO_nsv0y0CD97;%VBnPPUpxX4`_` z%_u=PUdiqJ_!yDX70B2-G=enEmi4LpDq-0fLvXo4q2;iw8SpDi#d(JQoLvv_OIJJF zw8I-~F#foH)vIbfi1?G*G(xTx8CaQ@NxO=7SpR;I{(`VoGmrK#4*^`EAaoikZB*zh zf#d0p8Q1f{Y2*dmyl0@_%%VeFW6d;Cq~zMW2ch{Ub&O?wtj6Zq2%&6QRaS^~B+W}a z4ukL#IS)NPdUw3O)XrM`A(8sCO#-ty&ti~fTFj?3E5s?mob~IId1k@oJM<@hPv*Mo z-N;@?WUQ{xdpYL%E$^Uc0||)=lhsw)=mo8u*!0oIF?I6~p|Yw?j?jdjw`s4*&t((= zku`Iv{$)0B0qSc+=AyjHxoF;a{pps=@|Gb4NIds(!=3{J8n7k2keB-g`YfZZxiBVcqC5R9<5{nhf<%SJ48z2OC^2NCYNAfNmPqPUhDiDI~`6WI~T;w2qj6q?< zgm8@au5{yiUW|Fi_#vEN(iUk1trB^e*)lCl&zJbVlHLOdzx%NDcKe7Ye$vTyjp?+V z$?l+V8;9*|UZuqGs6hUwfiFB>#lv?Qz3Svw_#~d`&x?|{kg>swizhi7Y;)kj{Fh7> zDQ`Xb;e6R6+E$B5u9f<0{U?3tkEb_~C|6kri|FE6oTk*2PYaOGD-{yFOKULWz_4fj#+D84!hHc^C34>_Khw=x6+(+ zY!3?#ul4S<q+=n*A<@kSA3jZcg8!x1yahYw;`_*eV@$CgS?ZsvyNZoPO?D|0aE^f* z!z?O#C0smjm@;t2b~j}edJN&auE3P(w0n_KqQE{tY|b?W*Pqw2(+_ri(sYKcn=*<| zAO4e!eoZp&cqO+13+zb>%C`!$>aAFSeB{@77RjgXF7jUv$m?Xhu!A}2g)hj=;(B(Y zf$#)z{SZp|E}FLV+Y*E*-jjxk*xQM$qsE9Los6Z+EF(>QePK&Xhq9in(qMo8*3X`f z&2c1y-`2XHuvIb^k;`N9%!L#lM#I4_8CWfzNLu2 z7?BFlB6py5t__P|PB{W~`T%U3Uxk?}D{Pawg~kypK@n=~`WzzjL_2r4=`-?%*T5&5)BhG1|VeZhx-Rx}GyM z78ms__(*l{IK-dfDyy)1tj{sQ=_4V6-5GG%>d5oxbG_Jm;A(!T5+Q;3i(W(6!j`fW zEqr1M-6{RbWM`el+pgPqdT5)HC zWQs9&$9L*SCqm(CS{UaQ*Zh3S9qU5YQ2X@Kj*2P7_vUR*6$kP$5_gw+Jx*_e#`ip^ zzc9-eV0u6Ol(tldp{=^hm$DJPx!s0b56W!auY|RpmNl)!&lallAtzw;!h&y zPN6cB6z_4m{N8ZgpZP$5pW|}}xBEQ$HvRJYG6q3J{EqdN_cSI?~fV2l$d&zx>|g$ z59Q*M@`U|4;x-vc&_M2V-t6pxv#6pL+kB1x6oNOp*J6Z?7BZs#2Kw_D?3ST1E>FO{E;c5QDfOmn5yem20ayo|wlD>63 z6J1gLRZ&N4vXjSMmn61PT$!?%Vy;j1>XFh^ujnc2^2b|yCXqdn zO#uj9De>iRQf}GrcnLOUr~ntoQ#*yZL5V00z?zUOB~09K-b=9;@bfl=rhbXKi7xnL zBb)G+ZTLSWc)pW#ye>E!?a7aA$L|t!LP*5d+vu_2_N-TL<1IZZUI**b!5Dg8!FFel z3KSm_MetN*M%no>);>8TOT<-Wh5^m?407G^-1mEus(cNR4@*4g7Fu9t#J-wlb2MhLw+s zfzwiERVdF=km#d528UgO@q&~ewYISFyaK9YaJF>`Dk(@!J{EW_F(uHx$gdI#=#N|w9P{1Idr8>z$S|kl%m4EF20t?oa zChM@lkx(ScDYsp>#wF3Rn1~j2H^!!0z&>S1eJ73Pc7=(c#{5Y*;2bYjb?G{*DZmPx z1p%wmE+d-=;&gM6a`#`GE+F~ZP04?Dy`Ch(+{tL%;WC533Y;rEtkALZcDX5Duxpc4UR zTEfGdzMIZe8P!LZoKt?3bmm`ByV@p)+%(XG>C*FW*qSHPki(h56S5 z#tuxJF^{-wqbrqnL2fY2Gu4p01C~H79m3|;3@$SB9+MJdsMF>8Pr4x1pK7<*7vI^B zMqF__f!uyjGfFwK*L(iXY8X~Y7giBFD7hO(7hyWf$g9Y) zSw})S9LZ(0{QWx_7@$w8^YtsE%fRzZ@jc-HKHW9Cbf23q5}(e&uQ*vwqte={4DkA~ z#@fIC1#oW+MCt|40q1u&pK32hKo)JTsUPwLnVP?`6I)=)ewg%YPasc$lxw`{lCyDA zsdpOalgVOuEL5Z1aaDiSa$L`+__&iA&bc6T_P4L~tjgh4N}EO& zNJQzJ*p2ej^ox_0D=HO?fJX=^v0`gW_K^t-#Fv9i=N(yh#+#aOU|9WGU$OkI16_?Y zyh^J?GY)z=0}w~Hl6(PeEk=gkph@>FEz_9czZSugRlUm};YBkSKttVfOTyLofo zG*<>;oh$Q@*F(VNFn!0*{Jri7-nm^!5Sr3rp12TVm!sB0V_EaJklK5Z)u@

bg)u5o6A_QRsi$vk`&jynYFs@TZHCz(jz|3>?JfWo0?Dog77^lV_ z2|SIdb`t|*^*7?W$bb{HcK zdVlc<;P2x4HZ^$Jz0{zFP$FBOLTBV`r&*q~GuPk(zYpu=V@%HrBNT@ zC`Y8G57~HF;{Xpt*Qembh2zbk@3Z(5t&!p%FjwX$|E1Z0=!)0O1=5gGk`iV z4>k;{!az>OxB4~VP_L?JKpnhn)6c505(3*S2yGbCb%17}L%(SSt^{{p6JGs+aVnt+ zESr>mEXJ%Ul1L|h7wlr4itlj7{dO+Bh_h-IgMHQUVfD5v^HL+iSK)LK>Tbr5$ymxr zDQ5khYe_V>ZaAu^w)5200U&ct<0SR^I0DhN0G{uf5R~%lxdi_>b4`L|Z!I3Bd@5}m zy^-1fUTDE!iO1~d(wz)5RNW~@W+YN{C?xB4R4@T~)HAH&Hme}* zYhxQ_h4PPeLaWu;hHcJj;vpa(u#;vG=?4(#*&6r zi~mG=@Cn{v!}9~Y^cQ_quPedD-^jN@)Vzp`o3{M!5E*_G_G|@)pd-+>Qgdf0imY$C z4c_nCte?Q8G1!zYRgRG+Ywb7_%W~3qN#{Iad)5P@9A(;NY3liwRF7&g^TvHd3mP0w zf;!&iYi@80CMBIRS#CwZ-hE`!YFeie|LqzXcG@wo+C`hd(bMiaVdCi}5^uv3A@5O+ zqmvcXcL=QJg){09HLWE=#bWY}Z@3f_h7Hy^O(oOJhL77l@R@KU6|LVV5zW5i3SP^K zmp)aPs?l^ln@GT63W6>=R*ze2;AERI(w?z>**WcT236p_KHJg7h}`P=I}{|tyf+HP zvwRE8ghn*&#SLNJQ^eIqb_rk$_i85@D*IkD#hYb+3^EaIkCNi>{WV7)7-y)wYZ-YX zf={PA)LiEB++#FfK^>uS9=DC~lV1^qBu<`s3{(#omH^+zf^T2XxhhMD?GEYu^R7^j zn~dG!aq&AmfL8m20eF&0977`f1AVNzel(7UfM1B2Q`UwnTR+*>#hz9YiO!8d(VXeB z?A2kfLy41gz&g-)^iI$X-|5X%#~Gs-DiotAdOPn$am~;)fj*>HDt$s-!|pESL9g=pLQMOWQaJaRKRB6(ez)bN*d{CP@yzP* z2rTLaCdTNP$+%V@h-6nB^uMC`CZ4TduMWy(RCAMUM6F+oo6Y z1Da_vvX_x#A?VHD_vJxp^$Y#azNzvr$?)?5yj1FUfEi77#lr}Ey*1Pa^IxRPWooZ! zr$yo`JTiD6bK&nJ?7rIyK7)+@r!*L4>bRLg9hDz{4F@>{HG;?yh7`B5nmdSb1#|WN z&Pd)C)T60B>O%_reG9nmY*YFSqswVBKM|cMF@~E7`r4iz1K-*8{Xk*^M`eKYBAuCt zt9d5+L;LZ&>7TYkb;kPnku0Hy64D9=unth-lE+_m=(Y@=l$=5zgG+8kY0 ztqwdJG2W9QrDU+EEQ_it#i=jGr(S)uR8$B6*dm_EW(o073V#K%eVm2@RtiqJ6t32>q_(HJNhb&;b?8|X<=r_vgf#B z&EPsJiFUPtsb7_jFBSjjr83kMBhu*pG0~gn+p61PT3|AIb6gYOPI|(pMH?f|dKAPu zt*OkDq+MYTXa+zCRryhlk>WUWZP7P!y;@z&oBipPG8~Qy6OSpuiJ-DDO1IisBiT;^ z`&k@?pBenUO^1Y%e}YDH%J$ARwKG|Lpjd!Vy!V%AT1Y0!TUl*Rw>7C(Ab&m5wE0*3 zM?NO73}uZ_>{M`&xPc~qv26@QV#A;-61cw> zc-@%&&o@Ds5c(9o_ognm5uPLm`eOP+gfGt+Yu_rrl`iiK+B$4ph%E2>H}bQF zLPDI63NVG}RiK`9cVV@L_`=?jJ6H+ts06~4h=LB~d<6zE#2FoaD%cIM+onx!#GEXn7tkzU2=Bx4o2-F0{4JNeY7yQ-rd*%jC%VcIgL}S2^?2av zTWsUd4~kO$xF+zBx$_c#^Dv1CFSk+b>1F(;mKJep)iAmF|`k+l9TVDhLh-=xn| zKCE5C%PZtGK)ew5r`ont4ke1x76Ck^u`tRd4Ll*4l4lb0)KBP2yhK!(hOjh4?v99Nnrp?1 zWQfmKLYZtYvNAbU_Z~NeJKhwG01>ir6U*(GG!}5~PR4D*l82PlDXh1#Io!_^n`Tkg z%*s?q!PDY+>b9GjPGB_ep{1^R=SXQZ)#B0bl07?=U(7UC4(WJ=jtQwsg*&Gv4o zX#*Hi=Z&qG&8ZVvH1?P6#L2oBS6VLGvF{J)%O<$7fGItVY1oVS>GA2Bn68cRX3L+r zvXi!E&7RmagJ`C;Q4D2ZlJ{~WGEo)F?SwLx#oBLn+{GE-;3&#sKJOw|e%m|B2eM7$ zE-vm9vx^1ZY`B*BhlbBrJA#|~e7J`u0UeF9W|z&sEb{7IG$5rN3GN81|G zb{jPmP8a5Qp4N!v{Z7iD=ks4w8+d0F15TUAMe5_jo$i(~u+7_xWL<-xHx9#fJoD|b?ZW}j+3S}@;S;oEME=;rMKi=PJJ)G<3g;>_) zjB3Y)0GFs!(_KE64D4l_;@(xSFyQP%%wsRUso;Jsd-ZrWX62=a0yQ$QGU|Z-yzVN! zJ`jgf@1&73QU(R*N1;6*le3b6RHU=0Z-&Wj@OI+a+np?9rC9;ng=DO@3#R(-{xKzm zw@iLW>PZgCfXB<4(Y3y0cD+SKPn}6b78G?;{MhZ@buBEc4~)<{g|N@AIfkmbWgr6c zU+Af_GYlXBm8{{k<1mh=~gXek{xVgHL}d^ExAa!T!MScU@pjUm9ZP-jJ1GbK>LNWbMn z84i;|dJv{kF66u>zqjSD?EwKwa3p&ocwxKjw{C1^au`({v&Fd!r?n4{V_raMe$Z&V zqC8lxTkF*t?Kyvc#E+uxBa;O}%%2?69Z6B@{eO|Coax)B-|RzSeP9Da19_nYv7)7@ zQtw9TqKXT&v)u}5kz?F!yDxd)wp9Gf_!?J6m?6Fm^4nds@m01TkVT_4Hxa&l3uYK3 z=;YAfzAQ?<7w320P~Tg3!AFSJ2axeiym3UB=G{AUYm!kwzPvDSKJgiqAWBG76nMAd6jc5pg{>8X+I?{3e~Y zci=w;k)n#KLI2Uqw$B3ViGPZMb@HKBzu``7S*bmsmZ0v#*4cTVG$c;m?1DuJH`Z?u z&ioHztbqOk=CCW-jU_~)J6j*pO^~br;nR_^>Pv9K*p2H3F(l=b(_$#VrXu^>z3Kfn z9jRM}CkAd3F^nT({=B~qhX|`kbQ382{=yy#2~Vn%G<6Kva%9+r58jw1FHY?P@t9j0 z>ns2S9`6QdLM$o%FM#G_-+^JZTeI^wq`yssHc1MEMxZG*JU~6bc6Zir$a zqem#<)9s1USNHNfwWy!h_-f{JR)3D5{z$pHEJ!#49goBqbcYLziMAC+`YVow^FFR} z@Qq^gt-gs|%7Aza`2bTS47SG>+Ls-f&Ssy3A$Yp{;g%ifZu^B*DKOx;O*kgUcg*jI0g;JiNv62z=47yRpsTtk5 z`;Zdwo!hjL1GcV+uS}Ii$1cj+Jd3HoQ6nK{-7lJL2s!pp7D0MysU)7EG`~0tG$7RO zeK0kRtlAUBsUOtjsTsT64yI9FYJ23T7O3@jM=#m+1F?%+%$y0uzh!voG`l=ACe+zh7`)^rO zftOzaNL8Sth+M(|q=@;!SJU;2gO}bx_Y!Lw4L0Z*@z&W4uI2?A%mK}#v_bwQzMRT1 zdyYSTot;BeV)aS=qAZQI_Q-eIHUatv15{k_+);5}12w+RhMmwMsU|3Xbxd%y2;C7v zt#^=aB!RXF;BGVHh-|vi4-@qv64Y8{T-wQmVD)gbqProDf8+`hJKCDn*V6)}q_BZ5 z&!@HYcDl(E%D2k$qgnl--%iwXW@ABoJDIXGm>3A~@%Ur#e^j<%w|INVA_l8Ub2C8| zqX-!K&MU*}3?RY)F={QqFaONkF9PwinBoM>Aoi3jurh_vbj0bB`W1mF2$Tjh?u2yi zHoRSQ_X}P_Al$sE7*d|*NgY(r^NRC+N z6sr-!w{3s;j$T}lG8XtLD+U7I!f}&op6vG5;HFbovaWGC5LN>{8S5w0*xKik)Z_`i zr85V-z9p!HdZA{WPVrwh#zYJG^;k#w@%38k1&b{Az8`zlmw|pv+K#xm1UW8O_<=w4 zy;KC0%tHmdU-z7E`*gF&LH0g~fIcr` zJA-%Y%i&3Axoz773X1V|pf$9cqw4Hl2vOD|+zVNRMBlBZ$@J-Gl!IcA=d{1a-Bpi$ zO~C|lN^@xP6YuBmuY`VY^9$Mh&n|@YP@GyipslJDK0dfgyFvVkePn-BDww9a-g4NB zvMq5vnaB21%G!zXM%UIXuIN%Sh>&}m@U4L$XaeuHH;FxQ-{x##v}HnTGFRb}P-UdR zNRS+R3d%L5E>la*)eb4)8JSbwEen%7tc=CCFH17brxi6}3S+%@`~&zczl0B>*WZL- z$gnO_k(B+SIU$;bu5Yw4cV_6RlC49xc1=qV%A$p?$m58~(iCN2I|!!LJ*DEyH=~~r z;Ed4aANI-N8GSnqu(n?>aMLD!Iw%0S96WomXW=qG461D3ajSr92Qr-M!LCEzD^Gle z;-0oV3qA@B&%gM8n$U;V+*dnIe3#)-lz*y`L{fweN_EVE7zj{FrTcD}z7UM~=V|OMq++5^5bAGP;1wNg zU|iT@&7_W%epX;_hjXp@Jr#F%)qcr|PWV?BWrXi_7=@4j2K{4AFSkNB&G8QvczUOH ziryA+C=Lc=?s5EbvR!nTyUPiz_ZU5{;~&S5lk3T~n3t;S5IR#M^|4Qh!WNt*)-hZH zaL#_I;zny-=1TX+o~x)DQQ#_?O1H7+V4^VF0l5=^RBJQ0Y}@l0S1NTG(0V(^bO|bC zQ^?y0+5fTAyY#4aKIOrihw{OgBb9u`KbN=1tume%3rnCe$SeB?%Kb48hl3fFmnSEz zRZ+H=8iATf%6BBS)7Iw8xzL}S07cjXOU&OOJC#VfBZ5NIY`wWr&Os)F(DL)n;fcuf zvD;LGk#`zhHo{e$b#)9>ZLH=;tWCf%$1kxCldCO{R_%!h&?4v=aFV;2^919*JikMUk!d-> ze7l;T%I#b)+K;l@D@JfkF-FY3T0;HwM!)9xbic@2=>3U;XnpcEtREcV`1IjlbO)2J z`y&fTdd%j5B2;9#A6n9BM|hC$Y)r?qdXv}fy(&zlRW2Vuz zXYy#d0pV&)x^J6tXf$sqEl<=KK0n$;|0?Qb;h>hripWekW?U7)@GO6XXP~$lu!~tK z;V@E1+sXI#AQj6;M0VSN#aniWvyv5|1QG>@_P4?!2B5ja^cj4UC7R15)5F=p|3{$! z#nRe51?}f1tV%_6lg|l#PtNpR0hQnZU>B_KRo#bfCeQ4Q!4MD;i9G{VhDe3m{0qi?4KGpEAX35KaH zph-&xAoq4;xNWl@>ED;%G9C#&dyq_^qkrG8ZgClYi&KEPMjqoL=2N0EAem#mQtL|T zT(O9aG7Pi~goyzok%H+m6?)m}{Rb*Z9H#?>8IS<%-0;yy zA@I=j#YR`YIvJ9!cs;B8rK8ThfrDk0|(xuJe2Uq|=08 z3O`Gm7f1EYLzwMQ4@UYOHHKoIKL0hR8K)bz?3OD`#3p3*1FN4^rzPHwM^!uBNa&obd({ zjCv#f&{7N3b~FC)Aa3&`3+An;j_;$@5`w?k(je4{?!)A>a}J!C0p^d@M}LTa7hZJG zaSQF>bAF%HXQK1y3&3D-@I!o&nN|>_ug10BOK29{h&I9xrBlZm-16D}8D#yel&I(% z%1~AD?J6ARHZ0btCqede{!;U3W$+*V-c*+zxGflc1qbQMsa*?AwO$X7Hr1HI#^0l*hR|gZA&h(`&>K0VR7KHv*#!L0wo%Rsnsj z8j*>i8g7Ka6wGrX*{_Bi;~a4QjRts730fprG=SaF^_0;tq%WFdM0()JS`$|uH^Ha7;)@d2UnX|c|{*~MiF6ibca$&%wt7|rp1)fv*L4d@HXcn zOPqmF&q<8~2=R__FU$o=*DUD6@!gExYjM!j8-(R)d_2B0Q8<2@^1kmiyry`jI@-04 z{7M<_s!7b^Fi89g4o%CxA(cn*%afs{#`P-%ZjDK|6gsI$WU8;RPq3TuATilNS%;>7pujm)qC$#+BF@k$ zVk+oke9O<__|JQWteBQejZYU_Day8W*C5v;`l87_jR0K1xpr>>7J^KeK^HMf9}8Fz zl3_ADEewbdY=?#{7bDI#z$Z+5x$j5@K&xWy_6MQ3?~rHi>1gyAZVx4kxe%fI3fny( zSDOfxLX#oxUMQhSQERbY7k54pClS}k`ys2_3Gk+55^M^N^o3Sq>=*}A{0f2jh zqw(_R)FwM!Im&Ir&^eX|su&&-BxuowY-DihZEKUJ`2&hKSyiB?vb$-p;#{|B=}2G( z<4R7f4wX1*e?CMR{MF)dU6pMYqEbN=C$T2LGlU&gn!bhcIZ5KL|0_*GyEy!5Kg#)Riej32tuuGrsp zV98ZjCWer@gx0l4v-`z6V3bDhOJ=2~e&%7OXeV|wzl1Q6oHl}$$LxldWwd8N^4FA~ z+468NLU0~Y+$C}Jj{2GqvCwhU8L2@+O*7rWp26tBsSmhb%IG3k-ExkepyUGkKaAz}q>oh7ShLy1umi4&nQ zpv#M&pxZqKB%dyUxTYZ%p2W15Wc0qG2t+8AotuYoZJa5raNLFoZ<~`mJQ|u9c%3!LilPPC6}HPHO8U7Kbx=tX$Vg>JabV1T-{@ zFxYrm`RZ1|WVDYGik=>%$j=0H&0ZL8Km+%M4CEiIM6y7WPr3OChR4CgDMICz^xwd1 zg`S^C2DV_r6(SL?j0NN#4x$hffwkzEp_{5TZS<@5AI8@fvwDb8`fdGimbNPSIg^5; zrUFf0NqyqqFd!icnju%$?6FM}rk;|^yX>_YbAJ}Q;&Uv+NW{(*&*8{nWS$%f?tZ0Jk!>z}B*BI05uD49J()p1>+$6MX~ z%^NAIv}NbZp=D-%p@D{HKzLsTpOR>S_G~N1KiY#O4W=H03lEiPH`7JJ$P5=AJRF(P zF$syC1XD^=P^WZO)+HSr(XH@6r%8~6!Y;&>rh8RjY1+er!SV?ks}&dn;5W%(86naM zkn)1MWXKVq5@mUZWorVsb!tRqJs_sjZwkk11`Qs}43T+SR}EP`w2Y!f#CHcm?~Z>0 zO)A8qKWKn*72A|Qf~oI=el;si?M5$s z!ux}h*ol`s>Pm$j^?qaT746AVs}01z$_Qtw^8vO{>*RhCy1L1?$HqQ1V(B!9y{Fep zVAMzhs1-x;vQTR=9g0BH0>FV78fOjnd@dMD(rh7HF~*KH8D|*bbSShe%@q_zVk6uY zaPQ3Ws2KA3df{}sKqJe3IEKo8OcIN0i_tvvAW0Aw&-28$cTy@$;L7*cSaOjLpy&J* z4E8Hv+lGjB*+6x>9rtT2_}roE46&+DgrVCRrE8r?s!;&qZZ|vO#6LxW7-HCvEN^I? z1!>K+2rk#JX4iW`9pWS5kEccXIobA%93Dv02(iJqjt zmJK7gTbA?HR)kn$@6Ufna(`!DcS;7B^qepNu!#L>3#u2i7$%#(YzR;$>O`v@WAI2A z&#nWw8O#@`W5weErc)2d-t+Ut(j`ikj3zsc6X#>u7@Jh#6v-ja0ImRCLS#H&`jBF>jWFP6fYfY4A+ z=`d;#zMtSWfDr5T@LLP^axbgDQ*A_yzJVq+mq6$Zz){MG!F~vqJKSH2A6u)W`N7)9D&*p zV(i!DMW%}i-mQe@x<}=ZesCxNo**C!+|03U-{<%NFN@XfalVhU7|Hr@DK<{te>yL@ z*ZwFZ5-sEOD1m756|$HB>Vex$cAl z&@D2f{||2rbr)@N98n4#e*hcO97go)(L-ypph-7oB`F)8>Hx@Hr1rknHw5rVZp-tu^%TVUXAFR4+&ydZP1^e z3}fpT?0c1)?L=Kn2Br9Wigt!zyLa4F?NZ`m` zUty@yORQ*y`&Z4PUkz{aQCz05>~D6e6CpK--0CS|1l&R|_YRh1{Eh=cKvRXx{LgZ< z{l-n_2x^4$9(c~_7-hPr>idxmFta`watvhrs=sIfmOi1zm_t^QuS$gP?~O3M-)Cq) z%m&2c&s>(}c&yq}+nRd6sBa>vzd4<2%-JQ|VCdBJ_+&bxEnBk=wy{{JUEE+%;A_}i z62-LQqI;_ne}|@X6%lGaE0Vp4PeCW{V5RvB_-%YUoUvn z?$|gw^}$R(+Td7>U7@345XOVTn6OLda;uy8Fk=@A#u02ej*{=kNN`O9H&6Xw$pb|a zZBqC?k4HqK=-)oE5GCXaSb6m?)%Cp@=ZuYK#6SD@>25hY)!$ynXnPQGv>ff10sa;1 zt!+PMW|R(JQbA_T&f#@=>u5RmkC@gC_4Qr4lu|jvi{;unlHEUWzGNj8KeF7596KH; zV)0!ZXA;~ov3F_B`Tn#K9>Eb}HSToiwpjmc2h!B6(#NEdG>Xk*0({ci!F-utGA&co zbZ)2!)2g0La7W0)ZOM{pS@;Gbe!pjRw5?b~VGD3TDTaUdx;?;DFvsxM*OABP<52G& z`xU}SP%Fst((t>co7|;|W7<{IY8xx&pQut#ivB53QB|Q1GO%K)q25ukV9gLg%%|D-*rl;-FG2ypw zkvp@SSSjMKO8ELx7Ij&nCXIx&daA*?%{S@V3C3`(n%+m~dsSUYD!gV#es9*eMxxDk;?;rd73+cr{IR?TNgMV^d zLJJvPfrL2k?I+OimVqbyFsMt&kG6&c+fB-6x43md(!_~}wMN87V#j_K-TS+#7ZMEb zg0`Dm&8OEtcQZW@n zISM%n8H--L03Jfm+%@k|Jj!7Jj^H>Lx>peFRq;v@JJo5;OWZE>y3KL}BNFB91JJIW z;_pr?i<8ArZQG6WOW$s@`R%&C@>g|3@lQ2gx^^}l><_`CeO^Z(FUgWWncx=O8pTW@0^94hsB z?jqep_UlC?8nnhGavHnu50{CR#~`e3!cO3Et3+xXj>C3@?e|tN<|K)^aJ%5$s zfo?8Dk07vK2OdN-JbzxwB9ubjj) zt{T2T|Eknt!^3=n!ZT3PIweU|`v}=)UER4YKEvEEW!~QCOZ9@p&Wo z-T1i&4Y|{kuJkuCo>$%f=B3|V6Z+IFP;^j)PhUScK?xaS3{CkuHHBY+kMO$h=i429%QNva&? zPK3}6AN*dSq}8(ma|oq~Q07BS`Ljr&e9Il15rpX4=R`=dtXWo*Lvek+^-vZ;eEqmn zgnu!D^4*4sN$0ZNOYHg+9H7ppIPI4Utx6k!_oMhkiGR$zTA?WpyoGwOR?c@6j!ip)vjC%0`--zq5B)A zVT6+;3+TQyw%^Iz%xuoqwfE>RI879nE@-G2O7v{L7p~q4=;%8=ZvKGKv^M@B^sgcm zdlUoxl?ui=pNr*&Oq9TUuv{xG%mo6tupbc~5L6f`OV$Y12;z!1{WtToN(TMEILs7f zVohYf+isZqX&56=d#(DM{kg=!sGE(gZVYS(%_-FFW|{7Pa}WZYR&Nhp)AG z3Qh0^;lW7FnGtPXQ&Btg>4)mvTnu+Tw*$4aLXvRO1riwDfO4P)|KOo};oHd(9vn`@ zF8KG&Pb4ravs+>_U81UppsA4q>F+{%lKT4ZJLQc~K%bq)BncBY3W2j4N)=8St=o;b zqz?pS6drC8(hmiA%6&!o&92TN z~;_3i;8n4A`T1>D(}V|6a-kLxSa@7UH@gW`z!8Wgc%IZGbku zLYl$JX95D}emVM%hnzG@tRzybPFi`V-8SFF;dYhd-tl~}bl?7<;bEy%O-~V6cf48c z)PIn8Xijjl>e#iTn!^U+Jgz4#nC%>m&_ASSB$l-Svk~H1ku`#}83 zq>(6rNFCoLBN9czZ1MFHoBduX7MTZysB0W(qa0&S9s(db0PTOYI9wJE2zHTu2$vb=IinWJkTQUU(^Av~2zv<@)7a*3$4+pXZjf z;pyNk;18q(hNg0f9VTgNE?S6z_E4aeQa^wLxO1ybme_BF*oWA08Yv&W2=yMY1KnyY zKE^7i8VT;watZLhJ~Ac>O7dX1nAInPj3Gx;P+U_N&7yk%l{RD?F}C?i0JUc>DFg_$ z;%pTT0}ZWsf0~S~F54IDEF9IZenu~$glQ9~y?$Zigt$K`J#X4c(iGYv48}L%C2AR^ zHXI}@5W@N+OL0@u6K)kRE!40wf&^2TT6mIM@9cPLa=OsoI>fT-c*0OGV|~QqdXNGl zfGsQaiYCD7CC@@}+lGwo$Hsns-8>iDO)&&Ez0RU0hwc)OaJoe^HZ2LOhe;9Y z{;blARbDnkj>Xo+c%JmOQoAl&s1>`XLhucIW0TfNfKmX%g)CngbSAF4u)~>3w+%b% zXdU_r9fG3w)_l08bF8o65}#J+>%`0s%vszHF_-^%0F2+Yg)>ivI`0!oRHXs}oO%a?N(Qp?7o@X01@A z5qOMQgszT^OeHVsHYTdubz}U3bZftnKwY}|^QvxTn!V04HA+{cW*1TB@rdR2q#p~g zq13&cN>8F=BeQ0rx`Zlu=t{F1lI}DtA=U5RHTN$4$@n*TpsNt{wro`g|9IWk2H$u(^A=zjfVCQnl!Ci=H5d$OXg2p=_qY|snuax*NPq`eTe(fLX{hD&3m$Xqq&M@}M3bmF>V z?xgJ?i0ppwt#n<0IX>==X#tNywhC-3({Vju8SiF-b!V@xCp= z13prEA90w!NghlMlL|;!)Jt=`ioB9FW%d?;91}ZvQhsy;8PA#px(r3laiR0WM~1`M znO6;1X~y{0bIs_PQm^}IXbv%ep8=f14gOSF$CPl4433}F7J8|AMhZqt^p^aw#0Y6l z-@pQis(v$9#Vkt26x9R`?@qRy#bB#-$$<17++WXCBJKJyXBdaR_(D3K4BEM0>2W%x z7X)>A>Mf`XAEe|H)$auQ4kWr94aE}UTIp@-GvP|;NoBevmv6jUyFH(a3#VKh5Kj8- z{0YV{GkD97<}%Hq=VYoXw$S}GkDT~S+qxvu{HWv62b2Ws@eO||D~uE^Ku}x~;WeiE z_8JDbIDryR3^+>HBm_Ca%B7n%=X98J9-XadAfuX?YbR!MS#4~3W;ey}9I+cEeHZHY zl~W~R|8aS6BCGwS1m+#dLp8+qYe6PJZ@u=i0})Ih++4704XPgnri>9f z#9i1-Ul|-1vwmXGUw_@Y>b!v%*c6?=AqXC`zd%1b-9cwES`Q=v6{hOHg-27W4ogYQ z({Z%ii@iAczhuxeuXc96&QHl=QNHi~AkOx-S!|Vms-1+mX|&NDY27_Y=6c^c37vviY)_$%3`^J#g<4nztEg!^eHq4M_;pFhiO>ObbXK$oT8}gRVJwjS zA!*?K)NNrfJy$vx+$Bk;zSB9U;GCl?pfk#tVoJa%d3{`@!aw;!i>1RL*>fgNO;pS8 ze|7>oTlq#0a%UO|G8vCGgia?#q=r8SV7L|4La*gBt`KnidY=ir#%1EarC@wAZqsbM zm!BFQbqu7@{Ui!NmtpG()xnv2(Xe}q;p2D+C;kdED#vYgjk(HACsd;gYD>ygWfdk9 zQS1*)fzSMN>3RVs=Tm~^>+~xrWN??$0ISyW21<*rmoPw98;sSVUfFDS#ZGT2C{W!w*wJF8d}rk;!t zm-|lv{V!d4>jx?)dY87eF{&6%0wtB58)^1`oz~NA5h231$j@H4UZY5KUx+|$Eq)E3HFz>yaOkGP`N;qOPKdfAKWI&cP* z0G}&`eZQY-ZCjPqLH9-49lSfX#OJ6rNs{NAyf6f=ITBD$)*JScr+8^O7;97CZW%rH zVjsRK?!zf8dmiOtacZr$Py}&-!FEQL9<=p+7l+I^Fx80QgPK77Fzhz0Ce)@@qh^~S zNqhpj3_Y>YmR|j+`ijEKl97{;k(el-UMz9Rvyz8SN};>cZJmD?F2BE=YX3lggvt9k z&gFn&)tKoOCr`Hl<@zkE7{%R?S*PMYjaC$M?mG5>e-T*ZP^ptC`1SqD-^;!i!?vw@ zXCB?v$EDWad_moRtMjwm)ofK{BmJ_|Hs8PAy6ieICS7T}`Os=AP{9>wMji;wa_J6k zlG)KSQZcKYm2IrH`D*?7?(gH;J|2V2Q`Jp_rOO3_7aG`xR^}^00;XQ}@0*hjg4=AR zB&XD~i->M%xr%8J2-)Mj{(&PQ?jc#X0o*mqBddK2fb8%0XJcz5F%Kt=;8mf0BZk&0?U4xh%XvZe`SIg0w?gBKut>5q>Kk& z3{zEDitHz>`T_AHVDI>O>sgHk(v73*e+L!I6RV+nw|lpmL7hg8W@+{>3y~J_wXA$O z=+3!!vjKd-d)t_=uhQas@6B%h2LTTk3|aaZPxpwf^S`Z`IKTm=WnzvW;_QFWSG4Ao z>}7CEd^tOaL^1T^hChL{Zr6#cd0OhM$?%mFXw%uBg;5_R1rco367+L^N5N1ESc3qA zhNb(4;TDOO7bqXB1rrdm)E3~nlO@nAo4)Xq{+>fXU@;!xNa!oo_Mx$q%@n3Luo8P+ ze123`SQ-4NyPaU^OFw1W&z{>3`(aGGbgwKX2JBIJ1f5m#R&Lp4TZbx8a&^B^v*yr@VP{Fw#;Aas=~%OSdp%hQ~G} ztaQc^0;t{5Mb<$cM$i6j6sZ@frf;^JpgiZWfw%!I;r=avztQxk>Q7a^I6g#Sk7RNY z)NFL)=7zq@Q}1}RG>;n!3iNz3y%*GPk$#ntxHWj-^;cb5QjWBxhRW+EkNd;5vmig$ zuP%<&_@)m^cZco9-k1+n-XqxAz9@5rNXw#_P%jCCs5Fb4Q-^Hr33eJECYkcrpkhZpp!|n$>(3q0ztwNmWAuU^ zgLa6p-4Dt#1uYEtTO%cR!(&hyr*#3AF0<$b`?I;K+VwAd?O885=H!#$NdNxa?M6d) zr&&VDj@WmnDW)l>9N68~&Zc104Dk>^BFxML{B<|xyl^`r(kv1YrXs6xea_F`bVMC^ zrji!T!GXXUFHH#`V~MiD06wO15}pt`usX1-Tjg8jYN=KPz{gxc_!~C|OvCyDPy2%I z<^-$5R_BLtxSYo3(l#O`>O1q?udclX1I4OOb)je5r=Fh z>V`ve*i5q(bIxSRXD#vvI&-)*Thou-ie;}XM}@aIx|Vbg|rCwmn_E;C2}c9Dks?yXzUNFRC?7B z$;N^pJ`fCbLnVrumHzHfmtIb;tVnMT8m@1VUr`Us6WbG;3c)JWYMOqZNd2VOlRjr; zqzKIUKSsHo;+`L}8gsDX2Pv)+oHb`Rlr55 zdL_+Mp2t~rO?NajsK=bzUy`xl-^t=PO$4qF63efTD?N~gmrhuS&q);I{>)WzvJtq%Nj&LN^ zQoetBZ;Yj2Z4|&PMJa1kMG?jFxX)`zX9@;P%{#`p>U%GXOPo;joVXBJhF7SJ}!^0SLJ#+}n4 zCGhv8(L$>4Ug z(*Lpb)=^Q0UDr6m00W4WfOJVnOLvE~(#;@9cQ*`3gGiT%v`BZu08-N34bt8H-Q)AV zzvug{_5I~qt{LXOuQ=Da_St9eF9l3Z=VudYdu^vUG>q$Vg8XX{5tE*(g|VE2lH*C5 zdH3E`1w)>%IZu*m2SmJWNnycSnBT#>+PGicT=lr0K4QGYscpME1(X72K; z7gy*}{yW{W-&>NVqY{?~dfqQCe&%EocD1bCs#>w8xHqF}{qf(Gn z{BZhfOFJLC-e11I_&mefTrg6$33mXoH{QESh^-X0&FyMoT!Yp2?rn_BjlqGV>{~uZ zkGq3fHR8u$Gr_%Lmq_39(IJPV4vgx1M-0j>u%x&otdB--hwsob#vPX?Yy#RwE)nE`Q%tlJ;oA6b2Xkw@m zsUXi{0Lr+^a)p=2P}}WpBU!q;P{SX#Qsc6g#%{a?G-z=AJqSuy+R%;is)%>)%?XK2 zltr2Max3+)5RKF2EKjA`)#1V20&nf2L(pB~5IvRY$%SD-%#90UtW4?o$sljtYH*mA zuG}`pXFZY41bOcw`*n{sY_{fdVY3c2CJF`7o>Wns?y)#B_m?}PIl}G&ud|BA;*2|` ztfY^eUE2jkD$>zDsw#x3id{nvjplOn>&dgd6GSEd#4z3X{!OI@EOA@X4spcrt-FjF z`o`|2Wk8&i;E#D*5lv(P83?E@TZS#oM%iYso#s>&@N3aH(ptYe zHlf7U+NCQ`*8gZ^XYiKNFi^-6Ej&dE!myQTPqU^d;<-gnQXv&Slo*mA)4Cci4?Dou zJl4adl0{ooJJ{ScEC%V&GY;p(Lr)G22y%6)-`3hfmM6k&z0n=q*H|zImPF0TtuHE6&Wqampvo_Z!hVE z_uqsHWp&fCbMlDKGd3oMCaib}q&~2Xa33b4_M59o%u|x-)BFOL*mjL^P!sAJCEDmYn zq7oyKZ+3r2SkZy@7%fKaxtoLmoH;In`|n%nmyUGID%gVBgAV#pS#Ulj4>|VqH=OEN zK>9Ly`xCWpGs}P$xLDCg3$}UVFtg{Fq)~YB$cBKYP!@CbS1@OxgK#CEN#)6`fLQ=3%J!?5f8`?54NiL-*^g9txJ_%~pNii_0F&D_lUg2zI)iGfwt8 zDQT;7%o|pV=ZJc85o0Z+?=R_fw5UKhD+$p*|!B)L_9|x^wL^S-hE(G2j3bnN%m> zAxKPaT(e?gUM0MLuS&mV%V_L2E0Ce#RIfPitg=@Z1w*tm#vvT^?GpY={F@uM?U`s{ z^L6$`*Y4@&cxOj@#3V8IAD-7)+2go@84j2$NOmre1qZ3bw9hb_@g-GS5ZUeuaeA#M0P0aOoq&*Dx*NE8HWKw@2fy&0#-LV;T>ZHi_tm7rH~a z-e0C|VLNM$THGYHb7+_H?qJ5R^-4R%l3I?{(G~udT+!y&JmlKJ2mbfQsnxQp{WMQ5 z95nbFfQ!;?=}t#w!z;()ttnyhzw(kx9mVbqBts*9kZKlw5z7>zW>6rZR!0897|}*0 zDL_oin~SUa&H&8bRq^!bN=Cd%X{Lm$jV1ktak?k}T6=(-^^Jz#&(!|jwrh5(ZKqp- zC-yuqWH}}9G3809TzIf$RTlwXsxeBe--A@`^3q)9$=WAzLT3{@D;7uNbxx0CaY4** zgG?3A6X|q4tw@3Fq?;+dq=#}utIEFYjA$~aZ;9HY^07Plc}3G{aw$FBtQz)0elJ1d}XlrE$C;db|7>POGVmPyOhbpY6*$}IjE!{k~P5ThrC z@hzDMQ7_`6`7Gl3tM`qx8Al0FWGd_pJgs?DA@Y7?Nc5oGwAEVH`)%N_RYP|qqe>Paol zL#|}#!c52k(jx07QYs$PHH2JuorD(Q@E`)-=Od!`2lfjVG*{Qbo_NM%QpHb`Sc)@R zDBj4j)QN%Ea}fX9^QR5Btr_`lsjE5&&?TiU&qv~;sI-#7ezF5%6pF%YV$pxx>fpY!{IX(b#g<~U<$c~2xHB8C ztX}-DLvR4~dkRE(2&VFk5%n)9rg7MX3Yrb`%=zno7R~=G9mAjjxY|f*mGTbb^(-0c7UMuZp(98Jz3sF~{0oZlMKK-9y`Dy?IJ9uU(AOZ@kl?iGMsQpt3V64^bE$Ir`sk2T*^dgO5+6-Lu$#-_BI# zCcC;jYU}T3YXeGnrx8BatDzl_t-g1EIQp4s;0oe4O$W8MJ!U8U>GrK}IzzFNr3rMT zru3Z$nKj?m2z1#xGoJU+X9CI(tqf(Yx4#tG+d&+|LT7+N2Mg_DqiZ~12%)a2@7Oi5 zn^6}<;d3m0bK1|=X%#da@C?bc1C74eizo)r-ww+XgseyNCVdz74iSC2UdL*<-7WgG z(HqOLS6mgs2RJcIoDT9X_X1L*^jC}SM%RlOdI!!q(L8a6EnXV)i{}T@t!%!RsNY-M z7aT+H&&O3Nf8#0u@K+ftT=mtaZqdz{gdk6pt3}eR9`P5HY?<#X+a#=euP_CRQVv`^ z{)4v@<rfUi1es^JYI^wdpWXtK)(ePUv+ypu#M{)bhHxBIkN=64C4U15DrX7-Qgp`3 zku0?-LJ#NTt2c11Saz7p)k(@*6TludGdaV3Nk`=A{;V>t>a1$}DzEJExXk}S0WQd$ zYL;f%Va|57h={>VdADDsqGv*oC0cC|g^u-pDUoEG;hBq&^Nkwg&fekRVJ%=VXwK!pKhV5n#+U0|-BN z9!%>yD~+^xU%{F!f`Cyk8LyBfb5(~_D`wQ1+jat?yf}tsocJH(yU~Bfx1T_>Hg_*)?V8+?lb=y~REv z^=xoJNT`|%8kRX!`Ku2dEj1f)3Yr417u+6iwoo|%5NL)TlmEbBp%5^Hdu8hmsa__l z1)lTpFOPlOFs2;lFz-fwr{iHLRc*U9z~c8aJLR16?MocsQp0{ulJtlBruiTqSbz=j zDk7d@^U3J-j{a%w^7DUXE>JVCt2GSUT!LX=7px)1!WIYLP|7%zj=Y$*nhK9gW2R{2 zaUAMtM`1kUpJ4`(o(zp;86pK~R*d|YGbWowWvy{-PY*{~wHF;2Yzg7?-|NRK=)XAx zo*ym>P9V6>rDkC&`qLb8N@`eZYwTJ&GdcsBCZT3X77(UX@BsI;zVVY-CaFKj}y&gk0Bn+$?!4%Ad%;{Cg z**Xjf>-o{(>4DDe!J+I`YF^{bPld5ZSQIMp#ZlW+tE4OY@*Lm-AYd^QIYJ?zpZmBS zAa;mWobCiLR}2ivu*WD2s8;}x0{J6ieB}%Ze4?XXy``?k5AJ|33)hpECDVwq;@?#AM$7r^K2ix2#tDE&A$`Pef-Fws^qrd*fWywWA0IN z=><{HJxvN~0){V<;73J4#y(x^5_~%pll`a+_Fy545z4D7fZTixEFnf21+BAsdBKV* zQ&_}o2e4gPWg?#_T$>Wl>}ww#&3PlsJ3yqHsUX8m_d2_$6{AU) z09;ZvB#?D^1ZeuB*T|xhIs_cA{Qczh8%H)QRR9C+?7R2jn|b>--=9=}^M)|$)W3+_ zZad&ar8*^+)Xp)!uH4rGa-6sa!@0j~E$4AjWP+OIjwN}csTSGcra&Os{+4Qoh6Ag0 zP0}$#>m$XekVhst)0KL8r$Zo@-QIPX(xtC_d$G6Gs`+60)qDW^^_LJ*r$5wL!34VR zzVQEj1(ekvX%hN6-h$Oi?r_)og`YeAHOwPt1_e(DSWez?*!c(CbG$=Um|}S~URo>O zuE;s~dR&P&BdB)Q92hfhwZ%~f_?TsMv%Z0D`Xp<0>QQYW3m~TdjwZl14Teb^Ymfe+ zz(Bf=W*$b)xc01z2i? zaYyz=J^Ww>R3oW~GJG#*kpl-Kr^3glUXTfJ>6?b2bk2NjSY&z9DH(i*VoS2tG}x)A zw@m@ceB)yZs888yy=d*u7iylK<4N*0p1T321q0Rj>2CSSG?dH@ySg%OZe~pF7<=__ z_3_~@^fwU}sv{`+Ek=hXfQ23}L4Q+YvlF;YHL~f@4pYC+uRCdlAy$9Lk*T>T)NEyo zKSv#?PqCFq|I$Nv+;TpqP{dO<{P?~G8$KHFj0y9TJ_x9~67pMCktqv=1;EUVv7hyM zuRu{dM8QnsH{dk+EyS?NL6Klf=_0B80IhLUd4_bN%WX zxwGm)tCaI|@gArL2|-1lcc5dc0bZ>KS8tsViJ`pf zHBuF{tnE?YwTFem9{zyQtK5=`ZsOIOq1xK1n|MWz@K;Bawj!Ub$@E(7CpEP27d(Uk z2cuP1MRdxlyw>=|hiwr9^81ixav&4QiWKGw4r}7oduUahqcHpCDARD#O|p5rS4KE@ z9jCyGGlkNNqAazAzYn@; z+#COVDNm|1F`m-Y-}U>yie3r5{sH~;fsn^oS#6+i#`^@(?Xqc;h%uH$R!Rah)7qJ9 zI$nuKXZr}>_M1EhsC?Dz_8Ra|d2wf5cr+x>kN5g>;k9b}P;8g_xieSsCexTgjO%j6 zn;w7W9w(IvCJ!0dZ_x74HK2-~&ELh-!jyGr5uSPwAZF6IE_I|3DK+s3(}kYSer2g! z;HZA0@3F$rCObUjwDWh^+A}}H=@o{$stt*Ni~Eai2II*? zN@%}o5GWXj>M}~Lf0Pzb?aMIOsmNP?(=^8Ayz@41xxqh$49d=lAH7&q70D)CI(CJp z%ttlB)71WTDcOxhJnk`ozxPwJ!4#TZ0gh}Fv2^xjD1+x-#SZoRSBU8eLXNGtGaea( zENk*}D1)_7S6$Lxb8cgN0j3|0%T-HWd%+)?i&c(UUgVHSC}5&93?M_En^YL%$^XK22LEmZ(rMU6ETM4ci!rT|L!8_k@L|U*5FZ z`O!r+|0_t^TZa{xLp!+EEw89|c31)bPOw~aCk!Dn?FcRj*#Q*8uVGG^YksB8 z8BB}G8(nUtPXMs=Vvy_`hEO*2Lyu-NTl{4x5ak3X%4;UUC4@%i;%s6t1B6FK5)K+hcZnQHH2!~=iTeW*S58FjG0&%ja^84*)+n<7%2S2dqcHWQL8MZ2_h@j#5-o zs|)G1^k~&lB1=K_fpEPv&cN(@5#{!F#(mj0h|tKVqFFxCpOuEqyC$As7PoH2c+h@c1^L z!uW}|iU_LXf&Yrdw!W;$TadYYBQrJb#Q?05#mGIzsqKvPr>haM_W&#f^Yf>(X7&x< zABJiw!ma?dNb7T+M*~~m8`Ri(pL5hIWlDCDAf$DC>R0R#F-Wrn$P8-eL6H{hO_hJI zP$XK7|Nb=ZSxi^l*!i9ZD8yx5A)enQd(9|*IyY0!K8>qQ&heA2j^1sGOSl~4D0aP^ zT^y9I{bM}%ngTM`PDe|iNlH@3D}$c~NNEv4B7;j9nc_~=`qm0n@5Xhvk`5)SK6{f( z(n;Dfq^Wbs@Qu7jLibaR91-g!ba{4Poy}C0O3JqHU5hN7sR;4KP<(|!nL{weD z{1co*ZUX;`a@_fiYGiMBu3jm~`jR+Flo@^r^CRTsNLL}{V8zgllVibo!8`BDVC^mr zeI@I2;{>?&L(%t|OYW80G7XJ+8 z716(8!q1lA*HX@#?{7!O6_N~I%(_diwG z@f-qoz>yp3x_Hn9Jnb#Fz8-4UWG!pA;A<^Rs8WPz9%ooD3G@J++tA4X&G5xBc0dvu zZlnT>p#>YzbFz(#;L+JQZjORNn}8UM>u@a9yHvHoTZMqrC=Y*W2!rClxFjl!-UJ4lUFEy|2* z606YgG}Xv45d^?NKNu0Oo!vw-ipWjf*cW3Oz!;w$u71OCtDwMbl%MP1&2;Y6ABC$o z0Q_R~FFoE-l!r`yru6Fp;2WR)h19R=3+I%@E>na#k}{(B(7#l$fu0}YK^>y|tdsls zp0-)EOo*G{jiuhCyu~Cz{ zZ9N+yW)A-`Un>9vayz8FusO+te!@ux+@-_z-u^F?BW6tlKc2xVs+h%b1=qZRDwsB^ zTKXqt62t1Ce@GV`P-~_H&V#*96wQLNbyqzj;u*WK5(h)@8r3gz_)7t!2gjWLL0zLi z=wgL#DV3aBM24l2fMZeFm$Lj9^kSAHE%`s61JE@^P+UdpbI4kCz8rVCl>~O%+qdiQ z5lJXSh1LFxiDmyw9Bd%*xY|SRrhLSoy{g$TnS;QSFe`u6|2|tOHvBZs9S=o=(sUX? z^X~+y5ui!}0hF@bRNG-ikN?+4|A05X!vw}s6T}KpYMoFE&5P2oCxYV0|37ez0kIXE z0R)wHPF8op(ei;OpcI1tzh{DvRwSCZ>H$;v4t42vMo-3SKZ>Rjm^Ayg@V~HM4g8rt z-3k;wFd-D8iI>=^dS|NOA)1ftH%a~95M)V|*j2NUP|=hxwl)CzE#py^i&U>HahC%? z_i;g-AV}nKhIv=PjwqpNue7ei_jbbDRK91?BM0oy$Px_W=&zpG-0dJl z{7)vRfCQ+bod{;A2%6gaL9~p7ACb9t2ks8>Qr!(>pCOGgIRd3Oz(sMRvR{h9eoStU z&AR16>U~4=)%V^^|G74x3M6tjfU8|gRW-y|30TZUvawcfXJ3}N+c&Xw`%|u}(B^=d z>-1%qG;?&zS{YA!D5$-UY*7ukUrZWg;6Pvre@%Wlhc`;&Y!gEl=3x>Z>PYjhk_Dbp zbll~ZhUI0=PgkO`I|WyXdYeA)KLIFPFNwW&Nh(c7V$5N^Ys4GooeV2Rlh-1~cOtT8 zi%BXXI1LYOvGK~d;=brvExU|$TJSAQbG%tq#sj^OIU@cNoI!PE3OB+-FtX62K@Q2)QAoA<*kZf?cbZWw*p-#{U4`VxytqR z6l$Ik&k&heD8_%3cj#xKo>?UKvZ&^$C|Y0e0?p5!4fFc#I6YYuZdqNVG*co#4Xg^A zCp7oqtJ#(E>s?(G8>UUa<_?k0+NEK$bk56iTikrbppzi!SeBndYFaiJi z^SYYW;frZP{-fr(p6t9u3z}FBtrFjFhZ-Q_aF~5tcogXyK+iXtS)(7=lh6blhTqhz z6uGi!Huv8{P^LmjO0KzkS5p=1o~}(y6v6VVvtHJ*fG_W?zrP+&QRQBu?_~u>V+bam zv4(rY58o~ygbwz;*PGrKb<`uIpyPAsVyzVYzA#mivJYRLgbe-}WH&MOf1`MtFa%Xw28ZmxALr>x9I-F5|tKE8za7ONgjtsFS*p z^gU-8A1Xr$v?+3p1AP!$H1gvd@PIE4k0iHTR2JBOgPFPuFpIHly;u?4Ks>f=ph?&( zA#KyEMd^{=wecFm_S%cay<(Fo69-$u7&@Re_m5Rn4H+Y0Z?h-gD^f;`#I~Imh%yaq5;K zdC*h7LVAX2mL|869chCAYNoJhZKx4$etNt;oyvLnY#F?b$hsV6#jj$gKCcvGwEcmiD#G8q^ zcm^m4d_K{!W{HK1I$y7T>DghErc?s?U5f*nwm@N>t~(8wi`V~7oiyy~1kC)N7h4KQ zdlmAt!@ow!!M~_DMy1@+DE!N;OW$yKxzx}I0*=Ujv4TfH!+GGYU6n(->(wH)iVzjY z$?qx2XNKtH-o?&-z*aquMwrv`d0B)C$PB~ZWE_44yZ9s_roaG=o~8f_9eU{gT;+pY z6b!bzeRNfH&%Ww#RV@1(HP&5TJw8Zl>Q`L8-8b;_EUNH5|KQC$rwu++Q*rezCC>u? zmPSBS&^8$`P>0X#d-%-$LaDuZ7%c!6CI7oKoWdLw>=`o;%AcCt`8VP97YB7yte4Y9 zMP#Wqck)cLVGt}4i$z;;n-i7D5Y2zj3ev18YyB{J{}QT52|r#jx{|1rTM?N0dXiCU zU-z&155}QPWi1xO^tN0@Gz0B2FzA$f{`}V6cq$G=7DGoSvZb%yG(?ASHw+_j&Y_&kPGf7A?+ zAuvBnArP~3tw>f$(Bov=ZxFpxBy^}T+uPHqLqP1)krfvM8bI2psJ@G!;+|N?<#1M+ zNxVm21f-Q0oFaQ`rXxtbEOx%1w+fC$sOUD+9FsUBadj|8h>?QWDPUdmaSGl1dcz-p z-5f>p15}#})s;umc3PBcyQMB?3HB#Y0?P{`x)o{}&;m3XKp6Z(BmLr$1%$#wY~!Ry zT3f$6o8#NavY+?u+=@$?qO(00VhYxPU|Da18c(Asiwckn5C;U{&YVydq44O~t6|!J z?jNruK~D)fClc>VcBOWRc@#IoXrx%%n&&?3*ccfj?-8xuY)Lzu)XbXk+!B6(bw?`{ zC=S+WgMUCL!TMcRYAwXlKR`eUalQRm8YW+En_31$NfxA6b6T$z48bAd zKF~E&gnZy5)u@-GEdexENCRf$xkjR~2X%z)Py2bv5$xFSKY)Hw!B&6>#_i(LME%tp zlmPo;-;tEodbwchi=%DCIx1xJ{b`>RI@k!r${Roupy`M;P=THfco#}W&y z&dWtDQ-HA&@&f;6r@(CDUHHj;{xE&g6A8GU zI`8J@nPENKH$t0i-p-yaN}qZMjB+#O50INsRO`ExWX(Puy4G@<%p}Tk3y5cfGPj1G zF7YtJ(_`JFMMXI}rWPmQlv8}^I>8W&gjEe9q4oyc&27{yZ9(P!($=DVuS=qX3|pw* zL;j70es8?I5D2LH89kb=8%QG!|M`VAQ%XrWv2R;9E3NSv+BIxe1+RgB5gdw}Qd6#Q zYqYSen^)dQ)JiiDWNFg@=1t=aYL->D$%u$4E{0}LB7UF)DB|R*-d)wPFK`;X)6b7T(S|pcq!6ymYYG#ZW(AKGA{{JN z6@ZOnHQ-^X9KHZ7b-Ae+p3!t@WrAvH=O~BiKzR>{f$To@8QIIWb^9`ZItaIwc*Eh6 z^(Z7^q`uWP>$GB>KvB#v){hMlk$FYe$1xU-p1EUkn;V|6;#W*n?PdOVhc z5B)|BEFhoG8){?z1Jv+e2a)%6FQJ3+z+8KwV&qWumchf1yJC+e*-~T1je`X19Y{GZ;61)nq z_APok?x3{yJ6NI{Okv`}z99?-Gf5mQF@ym^;O{Tt`sy{)#lmc@o;nFrK*khII2SDD zS^uKML=e$~;`&VGLTuzqn4cO5JrX!+nLncr8mOM+Nh|8cG=D!b!5+mW*4{UY74oJk z*BZHb^1BNs^)Buu_ty3=&WPzfOsbi}C3@QtHw&DAL|nadec6Q%`&Ii>de&1o&jwJB zF@>h}$?Eplfbup2DZEfG(i@LEbL~4HdYL$eAq(+;(AXH2m0t2u+t@1`L{5Whl6UsX z><|Z`Mgom@VB%R>@^B|Jo-dz_=eh{>1a+u=vXr`m+Ii-~05&bp?$4TXu!Cq~YOdafF_1z(MR+}2%p36Fe8CUB!&9;GO_ zhiAaCsg0u4?ij zMv_qE=QO!i{m6bx%-Jn4y(JxKO<(Ox|BdqWdVLf+yi0_A;r}$xnrjRt9IZHId@kWO z)6RPCwf|Odgi?`3cUDcMChelxP;Y5(v8fI$j=|bAVD&&~ICEK}XNSXo4Z%Uw0?O`7 zWvY8+K&qTBkR?N^t%r1ka>ukm4v{h&+=o==$}oC5!L1DQLGAM3O}+uo|K$$|Uu@@#qE^u(?{eCfBavA9 zwi?!7f4GgYvGX_1>ct`)^1Kf%AHIlO|EMvi(?77O3jgNgbQjptTxYDghXpO6ef~lx zp>9~D=F6Bb{2l@93~_)ZIlr(}Ks-ZyZSvIEO`JFgp5Yx9(iGI8iCj36FabJ`sO_7n zI2<5NA*abkQd4@vGA9!8spjI5etRWTD0mWnL;O?Ckh=rv?|uTqT1ktICZYNYuSgA@ zW(p`|Ik``HX5<^LWJ*Wc=U0X1e>DlF%D2PNJQn8?xZZ)OSKol zS*T4!52C7Gxz^Hz=UyGu@7=bxjsyUt2LP1}?}|`rUo2<`V_CX(DAZ08Bm+?v69fw^ zm1nwWyHnoiCLxpPx_fQWH7XnFbDcFQRTW^n9$liML*OgEtC39w3;227`VnwTqraMC z(iQQlhA+YwPzh{pipcs2_{&^mL0NK1SWuY`tG^M6$BsZo~^k(6D zBGbQn7|D83vF0aH$+I}&W$v*>M#3KWXE0mkM zI-+@&tnhK8`k(v5PoR4IeMb@r!&4gF5~)Af7l;EakEwT{rQM|k-97b;$GmZAK{Ch<~TMb{|?mS ze|bKdIM1yG0DaMv2a`z+a76Y3yu9uXCh_IgS&Mp^2}IHQ&-cG?MB6dt3w-+f&5f1} ztP+jXgxl!9YlD&j^FgZ9KTJu#0d4o*0nW(%YBiCEjVb3vxfm!6aQq$Q^ujE`kPI0N$AociS{L?@-6vjr`u6o(;Rr-PbJ_XOP#H z&4^}yNH-%cGFV3*pdi*E$SnVrwjRM~VWJ{xUsw`be4J*G zYNx;?lS&&FT8XJmduMcStO-c;OgSSXJ)`zJXliD%k zhm}n}He)Sxg;J6bX`K&A?3O8Vj+=rv%K2}1{NktB-^2%&kogHy_^NNj%I>=y@h;E& zTBF18mdW?INq3YHG&ls~{Z1r2IU9~-t_*uPG#sJuw=r7!%Gb+8%=hiSthw@`=x?!b zJf(E;#Js&;^f{Tkwo)2RCAMPkn>1Z|xf65Bc8b?wwY@Zt9uD=V@+8K)C3Q9dp#8|Y zC0zg^BU7DyBIT3;E;aKy_N@&D4I<-;o8|=TSDeGz^DUr|EwP2G0#iVQwE*Ky96{OD*oUw+cfY#R__e^2vK6EKLS z3lukc>3PVH(_4r~fayd5Z?1mzcEz;3L(HKQ^Pr`AN>`KQXlPUgh`_xhh&S}*G^U@6 zt;b%)({a8j-Dei;*P;^-140kNs(x?o89Luiemy1cOj+0YLjuENcSgGu1wxoTz zZI-UnmVv=Kld@ZZ_|SSM1!ysD95%s|Z&Lsz4BP%}G)vux-q`b;5{qBzv!yAQJ%@qxlM;ayHI(;&3lqMt=NY~gpp6;R+U90#11viz=_q$KrUx1R?x zXjmAJ&ft{DpOh_joa5OU*#nswWYN@~Vt-5cYG_Hhc38BC;gq6=;fO;Zz)wuKe9;uED3C z!@7|$kaxNIx9dsQf&5Ln9d0{MVz5-z;M9Fm`yj6JVX9Zx1Og^=ZZILI?wU_}Wn{t{ zRy#zOR8X$EBEtXS0m~lw95sJnSY%!~&tw-dR%nY#AVC3@soxerf?ZWLAtn>066Nc83|8m+(cFaE?@vD10<8`mAAgF7J z+nrdL`8l@6bKKtIXSxs+S}h}6LRzyD%t9<(zX2lc zui>dkksV1o-60;`UjV@7J%}S(%ord`u5?MKp8=RZmN0O^%Cd#IFr`uNpN%M=WSe`5 zumPrK7leP%?KJnQz9Ms?*2RhLO=n&6<_D)}{D@hfTm=lqWTGpjoPnFXGGF_nvMOHK z@mDH090D^6=HEf}66a^s4|ns(Mk$!aMUjGn)m88e`l}B7v?E&uI#b??zXwh{K*3MR zs$+GojEY#>u>P7_nkhIW<_#dEGvwoI`Q>s4_BR z$UK&m?hUqH7<1bAUTKwXFGEddKEB{5v$yPZ?KB8g&ph!7T35e62cSu}8RM=h&SC3$ zixzw+2b^u=i_Jh={;4HrD03xg;&W#zcKtKC3~5=>=k9UKg!{e+44gp(+Ym&jp=WZNlOdHLUmfNc~J^vnq$%Mp*`uz^| z0O|KLiDp14tH}DzV$73vvw*&1@T9in2=}ed8;M&3oL&$-FZ<#mfN7|&P6aEBFQ`xK zzxD(U%P+9}UjP#XdsW|2F1RT_=tZTQ15ppJ>ct2{6$Is}`r$5e!QVf3TuoT}LUSq9O_T9kF&Lcr1E~_SIS~iUJd+lm(BcAAJ}#KxybcgUV4nDRqL$;+K-bo> z%`di5F=_UJ5Ti9^5de_j5Fxy{27a%v{*UiuBCy+zGGz%_40!El%lNHN!Ts*wpnALI z%FJEECHPm*lGM97rm|{c^LNa@TXeFoc?qBR4!*eIyX)Jn5|$29I(*gCug77A{y-4+ z?(P#d+JevwD0U|s&52W)vBQ_#h|9kOD-~PphbondlKt8_(~2b09(Z5sqvrS>f#$n) zp$yA0X@ZjsZ@05f^4MU04_z3`E64S8stAAQ6P2;Q@k(Zdep#{7X8_@cr;+eVb>eH8 z-0tYUGgZZNzqc8b;6Qk=7Bnlsek7=30o_*tXq@{t90JZDwz|S@)R}} zO2sw%AfF?3Quhu|=m*jDosIc|U4~m4pei)`oOSg~*LpL!00ohIze3g}*`(%l5`G=R zCi>4y#LvMPq0tNObILz3<8ZYLpsokANuF_R)A}?VPPvmQ*scYMpT?D>r?fj+$1GpI zi0~I28-%sBoNp{2D+jzmFP+mhU=MG9Vj(B~ca^jRzYKxFSNm)JWhT!Ey;#!kaHQPe z&I|B-5j=Pes1ox_aR)Q5U*VCou6C;RHZv|l=s-lLNJKzjsF9Nr zSAYH)yWjkK>N13)4}05#huBsB80UHL@xKT&@)Fd@o2MQVEP#gy+#ZvYdveoA z&-U8cE(TtO(ccqP-x}9qcC;}y+jBE*`u7A+d!*Xd&PGu?wqyI(MGqI|r~Ro1^N0jS z`&`bN)0NNWthzt4*nYbh2DrPnZ6^MfuOBOzbXKKq`|r>6*g*Jh1r)Csb zRUZ3MoI~$&!c0AJ_n}^^;ZPXEzt!siQb!UbcY>EouY6LmJ%Fi}h+q)MoM>&e2cJn3 z8ki2)VkN3L3aX1Qd2W%J$a|zY0t`PNfIN)<<((%UPrC&q6;VkIFmV_57`E_9{|@15 zpMMqSn0aE-nCpndou?B}J)x@5H!4f9SPOL3YS~Jfn5|#El<4ONxatk(JL3hmMr&-* z9iooXJ>~)Z3rAdlOe%0)^M^ zXuO<{ighrQ6(g)Ai-uv--TB_(?&ujQJRM$J=V4)YzORrwijZ6-)ivB-=@rR_Fexs{ zGq2-zR0S-b-P<^s)uW=;6s(osnUs{62`sfU)W6&2d?#SP)Y;G#>tnjVl=wv*!b8!- zzXx?I60w1_;QpLQWA-Mx8-pn`cW=gH0kXn>p+F&JRMsx`GzEg_tQja6Z}QEMqUJzqY;i)l93k8S(wy;sA6c^vhECzD)B1nNdMX z?zW%hY`UBAEqJG=LdbkXfS)-HalGROdKO5!93#?9IMb1jovoAb(8Ckx zxtJsHNVE&R2N=j)8~_i#N%FxjKe}yrZY*hn_mk({L7md)IoI4wGy<6LdCg8{UHZ0X z&0)@FlAdzNt7OgR$^b(;^=q@LlA@^g^<a)PyOWu~0~$?Mk-an&F=ydwDn8&H8T zP(|EaM5%hdP5ty4MmHG{)W(Y!c+`s5DW)2F574#Ij1nZHov#dK@H)|fu9xMOL#NT_ zt)}@DRFxL-+MW;Yn!E)pGMu!KgrwZh{$#V6&bS2HTmw zR)~$T5il$ccWuDkW!7!pc3eU>%8K3K-goL-ZEouu45TQ4oQ#qCvPtVON5?@+L(=PV zf7Yz$ekBO2mW0_YHtJ1W&Gh3GQ@A9UkzALUM# zpbYXdtZnyBRbOoNf8H!vDykfK{6cq(uIPD0miEs`1q)S2~V!9GlPZ4D8!^d?(#ITVu_3ETcU zz3~2h)bM2W#<1v9f|1`1?F6X?Bh8E0t|x}AigE^xXUSZIk$C}aSj{H~5wd|t0|`fl z-UpL^KOvkp=7rloMN=i&EZa35s0JI2buXJA?9jhil2uPcjsok>I2CS*bSxk_BPn`< zaV364gw!v8qzu%Gfsr$EKpe7eEP>Wd3OMOjMg+~Ra9ep^_YhP%qQ2wZ)P`)@U&qcg;M}eQ?=^Rt!(Nq z^N8m=h9PzK8d#XK79)rKYGXuH`s4KAMP|9h#gP)L3RIHF9 z(b`|rdE(p`pRRGMgED`+L0n+qHY@Fr(G}sb&w>WnraxTu11`s^e)Y@C zTKZJ^*l%}D+HR7zk`RFq$67+nQ}%U2UK|}v*7Py$_xA`c^rx{%<={;qO3FFp?w2QiXs*YcZX{!yE18)*FxA)SaY@ zg1K9+;}5?QAmOmH%`Nn=wXe0~0CdO$_(rrv*4Xfp69_ zLG~*tFSgF`KT8`HreSg6KA}$oz4WYIQJNEcgV7n%E%dlTh?#%Dk$b!NLPS3r@-Wqs zD@?i+o5Eg2x9A8bc{%FB34-b}z|k<3j0VM>`IC`bRMH9tHlMcEDqvc@eyj#s8`%X6 z-akIKkp@(|sBr#B)Z;&08csjIpI1=19DM#~V?ym9!IOr%Yf?uqPzAg13$i{)f^RL1 zW><)F)p$WR(}&vWv=5DQY#jfYG$k6m^oFfc@PB&y@^GlX=zonRvSf=sRQ3s3vJ6F- zWE%~#GnNptCS-}k*qVqi)!*o7=vB7_Fh_`OHV_xJt(_xwE1@I2;y z-}l^e&pG$pbI*BQ^%%-XMN>MUMAl7s=99BcJv)af)H){cyi{~C!o-Xs%(ZZTiEaL3 zvFBxB633e3-1o}7ieM`rW2yG{MJMG7YbV4of;-YIcv`7zz+yfc=t7)_r`j5(($Zha zY^)>HucVRp@D$_#uOOIe!%_&h6#$$dK0~4X`3X9Ye>9@Htxh>otzj=Yjz28MhFE&0 z5wC4riBGxBQNN+!c8<$Jz3p~x8n72}XR|YXR?8q|E&rNVZS`P;V7ur6)u#WXVEGle zcH2D9ne)0d`XzaOb=0#jQ;j(5&u6dDmW~>4dWt3tdGq45SjEMtd=1bBENlw052)?m z>0*{Ci`e7G;gU^8@K*nL@4hqUHpnF-!z~X9QZwRwpkB^;VhOhE)6Uhsel~c2$mm(b z1FhFv3jDyP25b;2X$0W`)^yZUDCGt*6%u`)>%&ldKW#zv`Bk8fd6EW}E2-<9nb;ao zi}W$I<%m4aWjVxlETyNPxwFMdtQYg%0tJN|ZL?R8 zqw=RQx0*@72oEO4a zS`t^0M$hRTv=g72TE_3uvcAXu6Ap%-MCIEljH*zjl$DW-H5>AlFzVvzbKC z7?MO> zDWgw5f1#9aa9-R9aETho#)bowq((W3TUowfROcef&0ihHjaK9hgI{dlh+>l>+*6uis_U&MVp%3gqD4$P^F$dA69Jy6L?SR91}t@$(?Ip{{93LM0B8Vp zqiUemu*=GfXOl#CFYuxt%ZkLF6Vgn}QxaHEM;pBoAfsTjgQxEdDgco0DT@x~pK|?l zFq64;AmjzR!6NXk+{!hys0(pbJj7!D?MZi96BCQzU)6Z9luyfc*WPJ^6~o7eI`9y` zcuk(_U?;O9!utTuF+2Kr_ZpV80GBMGfbN@HKWQAcq~8gC1z>_{vB>GGp_df>c*Gk^ zwaTr18_SQvn-)oP*6%b@?stjF3Gnmq+0scV&4o8>4?QAh?^Mt-h*Ke(Ot49r@Tf+V zQyfD=fldH`a=A>)jHF**S_iwk85o`Tc?NzkoNEpsT`@rSsp>Q!5wr{3<24rGu-z$c-lhwrF0a#P zv`N1CdIQVUQ^>p#b7gnJVdnsiKMo-INLsDTgWSRgb`FjMy(sC zi6_fS$d-|v39yW22pay0?%cwJfU`q|XS(LL#@@D9-|&sDdo|XYtY=!;pcG#ZHTpDw zO=d;-DI?5fRc}AyQ$4F);Hh2`1s-uuz}2c7DvsN4e6kD@CDprN-At3mX-Jz*2+=7O zCzF=_{9np;9F(tDHv~8=doG7%ZY>Yw?702H0t+{_CfNmY-bi3JOVNBgsaV~8^Gg?l zJi_Vz+AgJqveo*uB`=+J>M5LAL`!JYm)rf3JrfSsb)~xJ^p4?8fLQ&rIek(a3r|63 zbbxwB0hOGn%lYR8j9)O!L@^caBg!QQe8dOq>CfuT4UNiF>_-Rp2Z0P=z%n0)O@Pkh zdA>5Mh`Nyp81~-vkEWoK!_u8tH=z$kc{*PX)$QG^W-(BQ0+Dp<9!sDV(3qD76d}zA z98EmCFuTG|>t;#h!{OahWR$Gd=^DlE8b%#ec$Ef!2bnkfm!$)2J`SU^++r+s=Auo+ zFbl5b%yODiT6Bg(3rf({nuC>>=7Ph|&5c4#2DMlB0r!dAL_C_DF(;7a2?@#gy6rUn zB5v~?kksqbpkRAL@S4?@9&PpuG7HJ!Yi6obwyLw=F5-dhM^L^UAF$ue8^T|C-t&FUc^k78Vuka?7>-PwN-tFakB3NktAUMu2(DrDS$~VKnM16#6mMs60{E zv`@slYa0xaO)zOXBfjiOCR^h=x4GoaW3oX4w@~VqReF}7=<(||0Dua5*K4yxlhWGR z=Wu4hLplN`x*~9k?nq!!YgZypc?S{toB1J{RHxK!*7$BMj@5e`QCh^pt7e$T5ON*W zCbdU`DxLP=qTDA?apKS=V{encWi*4=vln$}GsclXH$Io)v{N?O*9x%tCC&hZ&SK&I z;q)02NqaEkk1Vkx+krC+Mlq`4_yOU5axdJ}06MmbG+&`#1J|Uv5H3?nrykU?WY=f*y)z_TVht6xxJ4%OrqMy@||&Jfq%dTto`Kj1jB+(=cHvA%`M4u6F~ zpv)xx<=TA^eOJBCS z2`_tLZ8VTOb;w0sv3G~BP{20i8h`<^j)P znLjMuegb_7=oVwC%h4;JscrnaN2kT>Xc($e1S_wpX#AaF~Pl-V~d{)e%^l{+lL3_vJD zw3vf~F7GR*fMTdlc=nc!RVk-<%=Yo7m@^qI`0Jiaf? zg(drf+mJs!)Fj517NK zU=|+n0G)r71kf&+P;zTAyI8a&moIXo32He9g)mLbhnjNuK^80wJ~5T+WqZK&^oxAW zwdZ0-jtv1QSOI2uQt%CZsdIwfzWL*14;_%lr<0%MSNPF{^%}`b-CZxhNztzFo$WE( zRuP10S|a_4MCD@3eI^=i zGxP!*$>8BM$OBI5o>}~!F9g1P;~BIaQ-y&gQ88XwH&O$o%aM{chu!~;rGz)mf-Q8~ zUOsIs*8s_Iy-+LmO)sxZ$0M+D0zZaXw#(AS$J{DkrYIpq$(`b%da-lRKtI1aKMpwA zq0&A2SJ)^X1-(Zn=8KLSy8t#uZ)or|VqthHMlnHu1N62;jP-PEw=`UaP%6Z5!BMs- z;R;Bx3~u46~bj0*}w)aae@Tccqmk+u24PK z-2Y>}zhnny;lxp?ZT>D0cl`Y_t_UcWPK@`wTSBFu_(^x`wA$4j$VbPtR=W#Zxv;=g zqsKvuL-?OvO7Ozsq?sDN zPZ@fb`Wqrk##sh!mRJL9JTc)dlTYC;HQCf3Ki3)cH~T_DS~Wc&dNg?tA=`l$wmbxt z5y^iAGme_PX|IiUR~XlS#Zn3hVkDRkwKjvxJCngl^b$oTQX(Zoc-QU;=_jzfcNDKK z_1qtk#XW3mVfQe!WvtW7A^~ni&_R?qaNi2h_(s%4Y=%ZaaPj82L8tn#x zX~ka90Ps2Lx_mWa%L;wDV%m}`LV=iYj&qFCj?`8#6IwTx&F`mNr^!j##~fg%BfH&P z5goV00_+wK2f=vODxjhbsBv{Dv~)0l^ti4-?z?NI??k}N**{&WV_F?g`nBe3%xpfzH$O}aMIuf!T1%O&2|Rr%5n8Q^BaZ6$Ad0gKs?cMgHYZrUDD*tQW*AZM{Q ztkDBnVyNOpL;T{pvZo%Nfw+~p`3$DE+*K?KIx4kp969#s$T}tr0u`~Cb#PFX4ZN;* zyC4yXfjPQ781PAXa(dKN$IFpY%>LcVku>H_8F@9Gg&>_;vg%f5eQiW!O2o_ebwu~cH#F|+BVgv|47T9 zKMSXT60Ld{iL%oF)fIrbxK8=M+t#ZBML}51%}f6mvLpEkDwD&1{r*29bNUD9ZMWo6 zFmM@>-4J)XCsCf^{S~?1whmkA-mBs4@^$)kt-_IsT1=c>j3SwKtV6>4mwEyGl z?qWBm4n`JM>DV)vcQeJv$|_SXoJZyH^4$9;4Z%mvFI0lD*TZOvUcWXN%GdE8Ei5iJ zINV$J`E}sa^!S%TUeFV!^TV|sw;9h~hMqZdM&#q8&u?eGF3b2*F+(X%P`wgjj#k8d ze9klaDNV-M#3Uc+a&2#Yk_+OJI8tVjlK=4MhE>c3B}9oy*Ri9GeL+;+8$NoKA8`+%>NaucZP7t z?%p0n0RpbJgfdWtUQ1MZ`y%@qapBdYBa+fG&>=2hcQvtFDPTt!*f48u0@T?5>O@}* zi#@MMbIGKXw$y6gYqk~1%K+O1s9bmn+;Ljp5HFw!Ui)@4l}K~9H-oOh@B0N{Fc)dj zlZo@=-xdZh8mf3b3?jUwX{bo}~wWdYDdK|(@8;t%(`>l4)&<)DCVrc!(aU9tP1w!S`ajWYtce4J@zd$AiM zbtlrzCDemDc!s~%pM}g?W>hnDfo+UMK*MQs_N{{7M#kRvnJoSW=OM6sS*xhu#?(rJ zO?f2N`zVmLoe_gzcet4_1y>0$;v#Ey$N zfS94Bp7hlIaAki7Z;LMF5r(W7MWOYv;UYt; zOr@Pgi?=hiC>iTNlP}45F87$=JUswL=b633ti(F5;Dm^BStxtxT z#&nMYwJdi&GDZAwn$DWeYw}vuo*%+Y@hJM1D*Dd1$AJ4p7AOgvUJw4`CeJJdXp0S{ z4stE+PLUi%U(~De-?EdxIFg{BPRXsyo7`i{$n)9jAo-J=gjK_X0f5KTE}&$>1nJv& zC3n`yLbLd^L)*kYV)G|t`x!UDM<@kyneGD^326Wh@z;RF8wH=$MBtMP0CuhcG9!V^ zylfjf6twrv9NqOklF|EPK0Ix3;c6PwRHI*?@x^>rdxeir6o^46={suViGlJSfa3LR z+|`jYEx`p^6Jf@_n*C8qQx0t=bU3fwRpZ*8o##DYtL*&TED+zA%5~1;IC;XmovW+N z-)1}sejA>EB#)Ao_ts_dd)C(0e1MZP*-bTRXFt0#x9JAsJMGUry&c&6;6q&1uilv` z;8Fy>eQvUt|M(oZzxm5F)sg?l=br_BzXL^n$CJ}M8wo=nL@A&0j>(1&4jPDC)O<4b z*_bk)i#|DAep^M{3THVaROf?7o>3wu?L8lPmj25b;`N1HOF=2 zW!F2M=}k4h+Y6mfvo`NVxA^hhZ9SF&S~ctJ4r|KfHS3W=jq14qWumWP~0 zAIPQ|sh zL%eo=OC`|Vrcnsh$WW_{+ut_4SdbvjGv?f{f3LlEh8MXjyUFmc4eI|NDQ)|!gqux9 z`h=JE9Kxm#mng3mx3xU%cyuU#w07-x4{5CyMUT)+oUa@h@kec5Ue5?aiFQJUyHj}r~vsC{wlDWe=gi0>(2KHFK pkAL+?0&HZbZ{vY#MeiZ-! literal 55421 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 FicZNdOu{6!~x|$4e8^R-WH)b|ew`rf%5jbt;cg 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 literal 47228 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 diff --git a/doc/design/images/graph_construction_example_forward_only.png b/doc/design/images/graph_construction_example_forward_only.png index 14805df11fc09f64d6bc17f5e969f1400d615148..25d19088cbf0b5f68cf734f2ff21eba8af4a2860 100644 GIT binary patch literal 32270 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 Q61=0xNXbiR literal 29192 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.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
TSm zLNdI<6piIbR*v%*#)GWVA=JXt8WK&=Nf`bci6FsSXv2F!41wiKidXX9nj}6=!pOzd3*I4wRRa8akX~e*Xy^Vuo5o#gqG-t{$o%g9Tmnp>|{RG zS!2}jNMXor%cSC}Yyx@(Y&Xg2jXF0#E!jDnpDuKAMDvpPtpiG~sAj3ij)5EgYiK|k zC99dvL)kH)YMH8@bk*cwlTaE*GCv?Bnl<-cy{%?vUe8qdGv?&-5}=q{ z%=7Kl%-)r!uH6sAqmAk#8(%8P3;)b(GgAf7#zh!zfgMM!kdiGy?Uq_zuZ}644GCg{ zOSrWNpKP??(-nBM53&?>0lt9)F@Jp-ll!pl)daMLEg&<_rZ>MCGk*XCvUUpD)(6QL zn&dG149|JNAxJiY9T91o34}$K-^D&jP$juF;=gik=&)zu5aYWA#6FVXz7LUAFCTb_242XH!>k%{0qn+F(n!>^H*R3{yi$w; zYc4UaBxLmaaaw{+*iB=S9LW;ic-hCu4 zXKxNkLuPM{OZ#FHe&b^0?ZH-G5NwW5`wQOr3ne*^rO$dE>0x=e*aYlF!Z7d>v`8Ds z{^MZuVacxBJNd?cv%-Htl`&X1i_wee|NAWRkQD4NnP1X;^EWa3*OL+Su)c}tj^uy* z1`#Y9x9?M;{okzXU&P|P>!1YtMfW@ZRs&$#vE13zm;57CzthwrK?%bH%gvzq|GWmI zu^!A#i^5-C+~3JDjGzQe_E^Ag(r%U~XqH1pqrN7X9{;>pMe$_xq$;p29jJoTxj*<) zfU#sBh=G8E0k)#o8e;TVr)Si%u!O)Sxp_!4HS%)u9AlvqdyE`j9p}Wl+nO1=gnDrv zZ^=s#Jf`A58Gi)kPhOZZocLVstd`G2}s8oL<%soKAT;E&b* zjJ1E4gFiDAoQ?fiJispaXUYAuQT^)={n)>eq!pgCflshsj=PZ7y>(Pajr}HguZ^cYN2o{gD;rk%EZ%ATgt4*o zzq4g^p>pB58DsT#wzzn Date: Mon, 4 Sep 2017 15:05:21 -0700 Subject: [PATCH 33/62] Add initialization operators --- doc/design/graph.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/doc/design/graph.md b/doc/design/graph.md index e59d04e1f5..51b7f87638 100644 --- a/doc/design/graph.md +++ b/doc/design/graph.md @@ -1,4 +1,4 @@ -# Design Doc: Computations as Graphs +# Design Doc: Computations as a Graph A primary goal of the refactorization of PaddlePaddle is a more flexible representation of deep learning computation, in particular, a graph of operators and variables, instead of sequences of layers as before. @@ -8,6 +8,8 @@ This document explains that the construction of a graph as three steps: - construct the backward part - construct the optimization part +## The Construction of a Graph + Let us take the problem of image classification as a simple example. The application program that trains the model looks like: ```python @@ -51,3 +53,18 @@ According to the chain rule of gradient computation, `ConstructBackwardGraph` wo For each parameter, like W and b created by `layer.fc`, marked as double circles in above graphs, `ConstructOptimizationGraph` creates an optimization operator to apply its gradient. Here results in the complete graph: ![](images/graph_construction_example_all.png) + +## Block and Graph + +The word block and graph are interchangable in the desgin of PaddlePaddle. A [Block[(https://github.com/PaddlePaddle/Paddle/pull/3708) is a metaphore of the code and local variables in a pair of curly braces in programming languages, where operators are like statements or instructions. A graph of operators and variables is a representation of the block. + +A Block keeps operators in an array `BlockDesc::ops` + +```protobuf +message BlockDesc { + repeated OpDesc ops = 1; + repeated VarDesc vars = 2; +} +``` + +in the order that there appear in user programs, like the Python program at the beginning of this article. We can imagine that in `ops`, we have some forward operators, followed by some gradient operators, and then some optimization operators. From 3d9d32a1c1462780ea1a5682a27ce7da090a4b74 Mon Sep 17 00:00:00 2001 From: Yu Yang Date: Mon, 4 Sep 2017 16:20:27 -0700 Subject: [PATCH 34/62] Invoke check_grad many times for no_grad_set --- .../v2/framework/tests/gradient_checker.py | 23 +++------------- .../paddle/v2/framework/tests/test_mul_op.py | 27 +++++++++++++++---- .../v2/framework/tests/test_rowwise_add_op.py | 16 ++++++++--- 3 files changed, 37 insertions(+), 29 deletions(-) diff --git a/python/paddle/v2/framework/tests/gradient_checker.py b/python/paddle/v2/framework/tests/gradient_checker.py index 82ab7ad39b..b8d7e4ea43 100644 --- a/python/paddle/v2/framework/tests/gradient_checker.py +++ b/python/paddle/v2/framework/tests/gradient_checker.py @@ -286,7 +286,7 @@ class GradientChecker(unittest.TestCase): for no_grad in no_grad_set: if no_grad not in in_names: raise ValueError("no_grad should be in in_names") - if name in inputs_to_check: + if no_grad in inputs_to_check: raise ValueError("no_grad should not be in inputs_to_check") backward_op = core.Operator.backward(forward_op, no_grad_set) @@ -304,25 +304,8 @@ class GradientChecker(unittest.TestCase): check_names = [grad_var_name(name) for name in inputs_to_check] for place in places: - # analytic_grads = self.__get_gradient(forward_op, backward_op, - # input_vars, check_names, place) - # In fact, the above two lines can be used to replace following - # codes. But most of the gradient operators need to handle the case - # where one of more of the gradient of the input is not needed. - # We change the unit test framework to explicitly test whether - # the operator correctly handles this through follow codes. - # In addtion, if all the inputs have no gradients, the NOP operator - # will be returned by core.Operator.backward(). The following codes - # do not test this case. - analytic_grads = [] - for name in inputs_to_check: - no_grads = [name for name in no_grad_set] - no_grads.extend(filter(lambda x: x != name, inputs_to_check)) - backward_op = core.Operator.backward(forward_op, set(no_grads)) - # get analytical gradients according to different device - analytic_grads.extend( - self.__get_gradient(forward_op, backward_op, input_vars, - [grad_var_name(name)], place)) + analytic_grads = self.__get_gradient(forward_op, backward_op, + input_vars, check_names, place) self.__assert_is_close(numeric_grads, analytic_grads, check_names, max_relative_error, "Gradient Check On %s" % str(place)) diff --git a/python/paddle/v2/framework/tests/test_mul_op.py b/python/paddle/v2/framework/tests/test_mul_op.py index 81371b1d11..92d2b80e87 100644 --- a/python/paddle/v2/framework/tests/test_mul_op.py +++ b/python/paddle/v2/framework/tests/test_mul_op.py @@ -17,16 +17,33 @@ class TestMulOp(unittest.TestCase): class TestMulGradOp(GradientChecker): - def test_mul(self): - op = create_op("mul") - inputs = { + def setUp(self): + self.op = create_op("mul") + self.inputs = { 'X': np.random.random((32, 84)).astype("float32"), 'Y': np.random.random((84, 100)).astype("float32") } - self.compare_grad(op, inputs) + + def test_normal(self): # mul op will enlarge the relative error self.check_grad( - op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.5) + self.op, self.inputs, ["X", "Y"], "Out", max_relative_error=0.5) + + def test_ignore_x(self): + self.check_grad( + self.op, + self.inputs, ["Y"], + "Out", + max_relative_error=0.5, + no_grad_set={"X"}) + + def test_ignore_y(self): + self.check_grad( + self.op, + self.inputs, ["X"], + "Out", + max_relative_error=0.5, + no_grad_set={"Y"}) # TODO(dzh,qijun) : mulgrad test case need transpose feature of blas library diff --git a/python/paddle/v2/framework/tests/test_rowwise_add_op.py b/python/paddle/v2/framework/tests/test_rowwise_add_op.py index 45d569da29..403734e71a 100644 --- a/python/paddle/v2/framework/tests/test_rowwise_add_op.py +++ b/python/paddle/v2/framework/tests/test_rowwise_add_op.py @@ -17,13 +17,21 @@ class TestRowwiseAddOp(unittest.TestCase): class RowwiseAddGradOpTest(GradientChecker): - def test_rowwise_add(self): - op = create_op("rowwise_add") - inputs = { + def setUp(self): + self.op = create_op("rowwise_add") + self.inputs = { "X": np.random.uniform(0.1, 1, [5, 10]).astype("float32"), "b": np.random.uniform(0.1, 1, [10]).astype("float32") } - self.check_grad(op, inputs, set(["X", "b"]), "Out") + + def test_normal(self): + self.check_grad(self.op, self.inputs, ["X", "b"], "Out") + + def test_ignore_b(self): + self.check_grad(self.op, self.inputs, ["X"], "Out", no_grad_set={"b"}) + + def test_ignore_x(self): + self.check_grad(self.op, self.inputs, ["b"], "Out", no_grad_set={"X"}) if __name__ == '__main__': From beafabc73e929e3790ba93687917a002ae0f3da0 Mon Sep 17 00:00:00 2001 From: qijun Date: Tue, 5 Sep 2017 10:20:43 +0800 Subject: [PATCH 35/62] follow comments --- doc/howto/dev/use_eigen_cn.md | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/doc/howto/dev/use_eigen_cn.md b/doc/howto/dev/use_eigen_cn.md index 49a726959a..1367323b71 100644 --- a/doc/howto/dev/use_eigen_cn.md +++ b/doc/howto/dev/use_eigen_cn.md @@ -7,14 +7,14 @@ Eigen Tensor模块对element-wise计算提供了强大的支持，并且书写一份代码，可以同时在CPU、GPU执行。但Eigen Tensor是一个正在开发中的模块，因此可能测试不够完备，文档较少。 -关于Eigen Tensor模块的详细介绍请参考[文档](https://github.com/RLovelett/eigen/blob/master/unsupported/Eigen/CXX11/src/Tensor/README.md) +关于Eigen Tensor模块的详细介绍请参考[文档1](https://github.com/RLovelett/eigen/blob/master/unsupported/Eigen/CXX11/src/Tensor/README.md) 和[文档2](https://bitbucket.org/eigen/eigen/src/default/unsupported/Eigen/CXX11/src/Tensor/README.md) ### paddle::framework::Tensor Paddle Tensor定义在framework目录下，其主要接口如下： -``` +```cpp class Tensor { public: /*! Return a pointer to mutable memory block. */ @@ -54,9 +54,9 @@ class Tensor { }; ``` -`Placeholder`的作用的延迟分配内存，即我们可以先定义一个Tensor，然后使用Resize接口设置Tensor的大小，最后再调用mutable_data接口分配实际的内存。 +`Placeholder`的作用是延迟分配内存，即我们可以先定义一个Tensor，然后使用Resize接口设置Tensor的大小，最后再调用mutable_data接口分配实际的内存。 -``` +```cpp paddle::framework::Tensor t; paddle::platform::CPUPlace place; // set size first @@ -65,13 +65,14 @@ t.Resize({2, 3}); t.mutable_data(place); ``` +### paddle::framework::Tensor使用样例 下面以AddOp为例说明Tensor的使用过程： - InferShape 在运行神经网络计算图时，我们先调用每个`Operator`的`InferShape`接口，根据输入Tensor的大小来设置输出Tensor的大小，`Resize`接口会被调用。 -``` +```cpp void InferShape(const framework::InferShapeContext &ctx) const override { PADDLE_ENFORCE_EQ(ctx.Input("X")->dims(), ctx.Input("Y")->dims(), @@ -85,7 +86,7 @@ void InferShape(const framework::InferShapeContext &ctx) const override { `Operator`的`Run`接口最终会调用对应`OpKernel`的`Compute`接口，在这时真正的分配内存，`mutable_data`接口会被调用。 -``` +```cpp void Compute(const framework::ExecutionContext& context) const override { auto* input0 = context.Input("X"); auto* input1 = context.Input("Y"); @@ -93,13 +94,13 @@ void Compute(const framework::ExecutionContext& context) const override { output->mutable_data(context.GetPlace()); - auto X = EigenVector::Flatten(*input0); - auto Y = EigenVector::Flatten(*input1); - auto Z = EigenVector::Flatten(*output); + auto x = EigenVector::Flatten(*input0); + auto y = EigenVector::Flatten(*input1); + auto z = EigenVector::Flatten(*output); auto place = context.GetEigenDevice(); - Z.device(place) = X + Y; + z.device(place) = x + y; } ``` @@ -110,7 +111,7 @@ void Compute(const framework::ExecutionContext& context) const override { 以EigenTensor为例，做一个介绍 -``` +```cpp Tensor t; float* p = t.mutable_data(make_ddim({1, 2, 3}), platform::CPUPlace()); for (int i = 0; i < 1 * 2 * 3; i++) { @@ -122,7 +123,7 @@ EigenTensor::Type et = EigenTensor::From(t); From是EigenTensor模板提供的一个接口，可以实现从paddle::framework::Tensor到对EigenTensor的转换。由于Tensor的rank是模板参数，因此在转换时需要显示的指定。 -需要额外注意的是，EigenVector::From方法是把paddle中的一维Tensor转为Eigen的一维Tensor，在这里用EigenVector来表示；而EigenVector::Flatten方法是把paddle中的一个Tensor进行reshape操作，压扁成为Eigen的一维Tensor，类型仍然为EigenVector。 +在Eigen中，不同rank的Tensor是不同类型，Vector是rank为1的Tensor。需要额外注意的是，EigenVector::From方法是把paddle中的一维Tensor转为Eigen的一维Tensor，在这里用EigenVector来表示；而EigenVector::Flatten方法是把paddle中的一个Tensor进行reshape操作，压扁成为Eigen的一维Tensor，类型仍然为EigenVector。 更多的转换方法请参考eigen_test.cc中的[单元测试](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/eigen_test.cc)。 @@ -132,12 +133,12 @@ From是EigenTensor模板提供的一个接口，可以实现从paddle::framework 当需要完成计算时，我们需要等式左边的EigenTensor调用device接口。在这里需要注意的是，这里的EigenTensor之间的运算只是改变了原有Tensor中的数据，而不会改变原有Tensor的shape信息。 -``` -auto X = EigenVector::Flatten(*input0); -auto Y = EigenVector::Flatten(*input1); -auto Z = EigenVector::Flatten(*output); +```cpp +auto x = EigenVector::Flatten(*input0); +auto y = EigenVector::Flatten(*input1); +auto z = EigenVector::Flatten(*output); auto place = context.GetEigenDevice(); -Z.device(place) = X + Y; +z.device(place) = x + y; ``` 在这段代码中，input0/input1/output可以是任意维度的Tensor。我们调用了EigenVector的Flatten接口，把任意维度的Tensor转为了一维的EigenVector。而在计算结束之后，input0/input1/output的原有shape信息不变。如果想改变原有Tensor的shape信息，可以调用Resize接口进行改变。 From ab55d7933bd7efbdddebbcee237323505d80244a Mon Sep 17 00:00:00 2001 From: dangqingqing Date: Tue, 5 Sep 2017 10:36:46 +0800 Subject: [PATCH 36/62] revert scatter_op and other mirror changes. --- doc/howto/dev/new_op_cn.md | 48 ++++++++++++++----- paddle/operators/mul_op.h | 2 +- paddle/operators/scatter_op.cc | 4 +- paddle/operators/scatter_op.h | 10 ++-- .../paddle/v2/framework/tests/test_mul_op.py | 3 ++ .../v2/framework/tests/test_rowwise_add_op.py | 2 +- 6 files changed, 46 insertions(+), 23 deletions(-) diff --git a/doc/howto/dev/new_op_cn.md b/doc/howto/dev/new_op_cn.md index ec79b7f42b..5c523bf046 100644 --- a/doc/howto/dev/new_op_cn.md +++ b/doc/howto/dev/new_op_cn.md @@ -280,28 +280,50 @@ class TestMulOp(unittest.TestCase): 反向Op单测继承自`GradientChecker`，而`GradientChecker`集成自`unittest.TestCase`，所以反向单测函数需要`test_`开头。 - ``` - class MulGradOpTest(GradientChecker): - def test_mul(self): - op = create_op("mul") - inputs = { +``` +class TestMulGradOp(GradientChecker): + def setUp(self): + self.op = create_op("mul") + self.inputs = { 'X': np.random.random((32, 84)).astype("float32"), 'Y': np.random.random((84, 100)).astype("float32") } - self.compare_grad(op, inputs) + + def test_cpu_gpu_compare(self): + self.compare_grad(self.op, self.inputs) + + def test_normal(self): # mul op will enlarge the relative error self.check_grad( - op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.5) - ``` + self.op, self.inputs, ["X", "Y"], "Out", max_relative_error=0.5) + + def test_ignore_x(self): + self.check_grad( + self.op, + self.inputs, ["Y"], + "Out", + max_relative_error=0.5, + no_grad_set={"X"}) + + def test_ignore_y(self): + self.check_grad( + self.op, + self.inputs, ["X"], + "Out", + max_relative_error=0.5, + no_grad_set={"Y"}) +``` + +下面解释一些关键的地方: - 调用`create_op("mul")`创建反向Op对应的前向Op。 - - 定义输入`inputs`。 - 调用`compare_grad`函数对比CPU、GPU计算结果。 - - 调用`check_grad`检查梯度稳定性，这里采用数值法检测梯度正确性。 - - 第一个参数`op` : 前向op。 - - 第二个参数`inputs` : 输入词典，词典的Key和`ProtoMaker`定义保持一致。 - - 第三个参数`set(["X", "Y"])` : 指定对输入变量`X`、`Y`做梯度检测。 + - `test_normal`中调用`check_grad`检查梯度稳定性，这里采用数值法检测梯度正确性。 + - 第一个参数`self.op` : 前向Op。 + - 第二个参数`self.inputs` : 输入词典，词典的Key和`ProtoMaker`定义保持一致。 + - 第三个参数`["X", "Y"]` : 指定对输入变量`X`、`Y`做梯度检测。 - 第四个参数`"Out"` : 指定前向网络最终的输出目标变量`Out` + - `test_ignore_x`和`test_ignore_y`分支测试只需要计算一个输入梯度的情况。 ### 编译和执行 diff --git a/paddle/operators/mul_op.h b/paddle/operators/mul_op.h index 66ed2f81c7..05a79e13b3 100644 --- a/paddle/operators/mul_op.h +++ b/paddle/operators/mul_op.h @@ -54,8 +54,8 @@ class MulGradKernel : public framework::OpKernel { auto* device_context = const_cast(ctx.device_context_); if (dx) { - // dx = dout * y'. dx: M x K, dout : M x N, y : K x N dx->mutable_data(ctx.GetPlace()); + // dx = dout * y'. dx: M x K, dout : M x N, y : K x N math::matmul(*dout, false, *y, true, 1, dx, 0, device_context); } if (dy) { diff --git a/paddle/operators/scatter_op.cc b/paddle/operators/scatter_op.cc index 9b5068f07c..35c185ad80 100644 --- a/paddle/operators/scatter_op.cc +++ b/paddle/operators/scatter_op.cc @@ -50,8 +50,8 @@ class ScatterGradOp : public framework::OperatorWithKernel { auto *dRef = ctx.Output(framework::GradVarName("Ref")); auto *Ref = ctx.Input("Ref"); - if (dRef) dRef->Resize(Ref->dims()); - if (dUpdates) dUpdates->Resize(Updates->dims()); + dRef->Resize(Ref->dims()); + dUpdates->Resize(Updates->dims()); } }; diff --git a/paddle/operators/scatter_op.h b/paddle/operators/scatter_op.h index 7551480211..e9595638a8 100644 --- a/paddle/operators/scatter_op.h +++ b/paddle/operators/scatter_op.h @@ -49,12 +49,10 @@ class ScatterGradientOpKernel : public framework::OpKernel { auto *dOut = ctx.Input(framework::GradVarName("Out")); // In place gradient: dRef = dO - if (dRef) dRef->ShareDataWith(*dOut); - if (dUpdates) { - dUpdates->mutable_data(ctx.GetPlace()); - // Gradient by Gather: dUpdates += dO[Index] - Gather(ctx.GetPlace(), dOut, Index, dUpdates); - } + dRef->ShareDataWith(*dOut); + dUpdates->mutable_data(ctx.GetPlace()); + // Gradient by Gather: dUpdates += dO[Index] + Gather(ctx.GetPlace(), dOut, Index, dUpdates); } }; diff --git a/python/paddle/v2/framework/tests/test_mul_op.py b/python/paddle/v2/framework/tests/test_mul_op.py index 92d2b80e87..b58e4266d1 100644 --- a/python/paddle/v2/framework/tests/test_mul_op.py +++ b/python/paddle/v2/framework/tests/test_mul_op.py @@ -24,6 +24,9 @@ class TestMulGradOp(GradientChecker): 'Y': np.random.random((84, 100)).astype("float32") } + def test_cpu_gpu_compare(self): + self.compare_grad(self.op, self.inputs) + def test_normal(self): # mul op will enlarge the relative error self.check_grad( diff --git a/python/paddle/v2/framework/tests/test_rowwise_add_op.py b/python/paddle/v2/framework/tests/test_rowwise_add_op.py index 403734e71a..2ddb85e2e7 100644 --- a/python/paddle/v2/framework/tests/test_rowwise_add_op.py +++ b/python/paddle/v2/framework/tests/test_rowwise_add_op.py @@ -16,7 +16,7 @@ class TestRowwiseAddOp(unittest.TestCase): self.outputs = {'Out': np.add(self.inputs['X'], self.inputs['b'])} -class RowwiseAddGradOpTest(GradientChecker): +class TestRowwiseAddGradOp(GradientChecker): def setUp(self): self.op = create_op("rowwise_add") self.inputs = { From efd40b66cc4bb898fe152337aeda9f65ced33767 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Tue, 5 Sep 2017 14:17:13 +0800 Subject: [PATCH 37/62] update the doc for how to write the operators. --- doc/howto/dev/new_op_cn.md | 141 +++++++++++++++++-------------------- 1 file changed, 64 insertions(+), 77 deletions(-) diff --git a/doc/howto/dev/new_op_cn.md b/doc/howto/dev/new_op_cn.md index 3e71a0a592..6bd54137ba 100644 --- a/doc/howto/dev/new_op_cn.md +++ b/doc/howto/dev/new_op_cn.md @@ -23,19 +23,20 @@ - `framework::OperatorWithKernel`：继承自OperatorBase，Op有计算函数，称作有Kernel。 - `class OpProtoAndCheckerMaker`：描述该Op的输入、输出、属性、注释,主要用于Python API接口生成 -依据是否包含kernel，将Op分为两种：包含Kernel的Op和不包含kernel的Op，前者Op的定义继承自`OperatorBase`，后者继承自`OperatorWithKernel`。本教程主要介绍带Kernel的Op如何写，简单总结Op需要包含的内容如下： - - - 内容 | 定义位置 --------------- | :---------------------- -OpProtoMake定义 | `.cc`文件，Backward Op不需要定义OpProtoMake -Op定义 | `.cc`文件 -Kernel实现 | CPU、GPU共享Kernel在`.h`文件，否则，CPU可以在`.cc`文件，GPU可在`.cu`文件。 -注册Op | Op注册在`.cc`文件；Kernel注册CPU在`.cc`文件，GPU在`.cu`文件 - - -下面以矩阵乘操作，即[MulOp](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc)为例来介绍如何写带Kernel的Operator。 +依据是否包含kernel，可以将Op分为两种：包含Kernel的Op和不包含kernel的Op，前者Op的定义继承自`OperatorBase`，后者继承自`OperatorWithKernel`。本教程主要介绍带Kernel的Op如何写，简单总结Op需要包含的内容如下： + + + 内容 | 定义位置 +-------------- | :---------------------- +OpProtoMake定义 | `*_op.cc`文件，Backward Op不需要定义OpProtoMake +Op定义 | `*_op.cc`文件 +Kernel实现 | CPU、GPU共享Kernel在`*_op.h`文件，否则，CPU可以在`*_op.cc`文件，GPU可在`*_op.cu`文件。 +注册Op | Op注册在`*_op.cc`文件；Kernel注册CPU在`*_op.cc`文件，GPU在`*_op.cu`文件 +实现新的op都添加至目录[paddle/operators](https://github.com/PaddlePaddle/Paddle/tree/develop/paddle/operators)下，文件命名以`*_op.h`（如有） 、 `*_op.cc` 、`*_op.cu`（如有）结尾。 + + +下面以矩阵乘操作，即[MulOp](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc)为例来介绍如何写带Kernel的Operator。 ## 实现C++类 @@ -43,8 +44,8 @@ Kernel实现 | CPU、GPU共享Kernel在`.h`文件，否则，CPU可以在` ### 1. 定义ProtoMaker类 矩阵乘的公式：$Out = X * Y$, 可见该计算由两个输入，一个输出组成。首先定义`ProtoMaker`来描述该Op的输入、输出及注释： - -``` + +```cpp class MulOpMaker : public framework::OpProtoAndCheckerMaker { public: MulOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker) @@ -59,20 +60,20 @@ The equation is: Out = X * Y } }; ``` - -[`MulOpMaker`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc#L43)继承自`framework::OpProtoAndCheckerMaker`，构造函数包括2个： + +[`MulOpMaker`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc#L43)继承自`framework::OpProtoAndCheckerMaker`，构造函数包括2个参数： - `framework::OpProto` ： 前者存储Op的输入输出和参数属性，将用于Python API接口的生成。 - `framework::OpAttrChecker` ：后者用于检查参数属性的合法性。 - + 构造函数里通过`AddInput`添加输入参数，通过`AddOutput`添加输出参数，通过`AddComment`添加该Op的注释，这些函数会将对应内容添加到`OpProto`中。 -在`MulOp`中添加两个输入`X`和`Y`，添加了一个输出`Out`，并解释了各自含义，该命名尽可能的规范。 +在`MulOp`中添加两个输入`X`和`Y`，添加了一个输出`Out`，并解释了各自含义，命名请遵守命名规范。 + - 再举个[`ScaleOp`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/scale_op.cc#L37)的例子： - -``` + +```cpp template class ScaleOpMaker : public framework::OpProtoAndCheckerMaker { public: @@ -87,17 +88,17 @@ The equation is: Out = scale*X } }; ``` - - 在这个例子里，两处不同： - + + 这个例子有两处不同： + - `AddInput("X","...").NotInGradient()` : 表示`X`这个输入不参与`ScaleOp`对应的梯度Op计算之中。 - `AddAttr("scale", "...").SetDefault(1.0);` : 增加`scale`系数，作为参数属性，并且设置默认值为1.0。 - + ### 2. 定义Operator类 -```c++ +```cpp class MulOp : public framework::OperatorWithKernel { public: using framework::OperatorWithKernel::OperatorWithKernel; @@ -121,20 +122,20 @@ class MulOp : public framework::OperatorWithKernel { ``` [`MulOp`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc#L22)继承自`OperatorWithKernel`。`public`成员： - -```c++ + +```cpp using framework::OperatorWithKernel::OperatorWithKernel; ``` 这句表示使用基类`OperatorWithKernel`的构造函数，也可写成： - -```c++ + +```cpp MulOp(const std::string &type, const framework::VariableNameMap &inputs, const framework::VariableNameMap &outputs, const framework::AttributeMap &attrs) : OperatorWithKernel(type, inputs, outputs, attrs) {} -``` - +``` + 还需要重写`InferShape`接口。`InferShape`为const函数，不能修改Op的成员变量，参数为`const framework::InferShapeContext &ctx`，通过该参数可获取到输入输出以及属性。它的功能是： - 1). 做检查， 尽早报错：检查输入数据维度、类型等是否合法。 @@ -144,7 +145,7 @@ MulOp(const std::string &type, const framework::VariableNameMap &inputs, ### 3. 定义OpKernel类 -```C++ +```cpp template class MulKernel : public framework::OpKernel { public: @@ -163,34 +164,34 @@ class MulKernel : public framework::OpKernel { `MulKernel`继承自`framework::OpKernel`，带有模板参数: - `typename Place`: 表示设备类型，不同设备(CPU、GPU)共享同一个Kernel时，需加该模板参数，不共享则不加，一个不共享的例子是[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 - + - `typename T` : 表示数据类型，如`float`, `double`等。 - + `MulKernel`需要重写`Compute`接口，该接口参数为`const framework::ExecutionContext& context`, `ExecutionContext`相比`InferShapeContext`增加了设备类型，同样可获取到输入输出和属性参数，`Compute`函数里写具体实现时。 - -注意，不同设备(CPU、GPU)共享一个Op定义，是否则共享同一个`OpKernel`，取决于`Compute`调用的函数是否支持不同设备。`MulOp`的CPU、GPU实现共享同一个`Kernel`，`OpKernel`不共享的例子可以参考[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 - + +注意，不同设备(CPU、GPU)共享一个Op定义，是否则共享同一个`OpKernel`，取决于`Compute`调用的函数是否支持不同设备。`MulOp`的CPU、GPU实现共享同一个`Kernel`，`OpKernel`不共享的例子可以参考[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 + 到此前向Op实现完成，需要在`.cc`文件中注册该op和kernel。反向Op类的定义和Kernel定义与前向Op类似，这里不再重复。但注意，反向Op没有`ProtoMaker`。 - + ### 4. 注册Operator 在`.cc`文件中注册前向、反向Op类，注册CPU Kernel。 -```c++ +```cpp namespace ops = paddle::operators; REGISTER_OP(mul, ops::MulOp, ops::MulOpMaker, mul_grad, ops::MulOpGrad); REGISTER_OP_CPU_KERNEL(mul, ops::MulKernel); REGISTER_OP_CPU_KERNEL(mul_grad, ops::MulGradKernel); ``` - + - `REGISTER_OP` ： 注册`ops::MulOp`类，类型名为`mul`，该类的`ProtoMaker`为`ops::MulOpMaker`，注册`ops::MulOpGrad`，类型名为`mul_grad`， - `REGISTER_OP_WITHOUT_GRADIENT` ： 用于注册没有反向的Op。 - `REGISTER_OP_CPU_KERNEL` ：注册`ops::MulKernel`类，并特化模板参数为`paddle::platform::CPUPlace`和`float`类型，同理，注册`ops::MulKernel`类。 在 `.cu`文件中注册GPU Kernel。 - -```c++ + +```cpp namespace ops = paddle::operators; REGISTER_OP_GPU_KERNEL(mul, ops::MulKernel); REGISTER_OP_GPU_KERNEL(mul_grad, @@ -199,56 +200,42 @@ REGISTER_OP_GPU_KERNEL(mul_grad, ### 5. 编译 -在[paddle/operators/CMakeLists.txt](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/CMakeLists.txt)文件中添加编译。 - -``` -op_library(mul_op SRCS mul_op.cc mul_op.cu DEPS math_function) -``` - -下面命令可以编译： - +无需修改[paddle/operators/CMakeLists.txt](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/CMakeLists.txt)文件，`paddle/operators` 目录下新增的 `*_op.cc` 文件会被自动加入编译。 + +直接执行下面命令可进行编译： + ``` make mul_op ``` ## 绑定Python -- 绑定Python - - 在 [`paddle/pybind/pybind.cc +- 绑定Python + + 在 [`paddle/pybind/pybind.cc `](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/pybind.cc)文件中添加该类： ``` USE_OP(mul); ``` 如果只实现了CPU版本，则使用`USE_CPU_ONLY_OP`: - + ``` USE_CPU_ONLY_OP(gather); ``` - + 如果OP不带Kernel，则使用`USE_NO_KENREL_OP`: - + ``` USE_NO_KENREL_OP(recurrent); ``` - + 使用`USE_OP`告知编译器需要链接该Op的目标文件，具体解释参考[代码注释](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/op_registry.h#L81)。 - - + + - 生成库 - 在 [`paddle/pybind/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/CMakeLists.txt)文件添加类到`DEPS`中，使得该Op可以链接到生成的lib库中。 - - ``` - if(WITH_PYTHON) - cc_library(paddle_pybind SHARED - SRCS pybind.cc - DEPS pybind python backward - mul_op - minus_op) - endif(WITH_PYTHON) - ``` + 无需修改 [`paddle/pybind/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/CMakeLists.txt)文件，`paddle/operators` 目录下新增的 `*_op.cc` 文件会被自动被添加链接至生成的lib库中。 ## 实现单元测试 @@ -258,7 +245,7 @@ make mul_op 前向Op单测继承自`unittest.TestCase`，并定义元类`__metaclass__ = OpTestMeta`，具体单测流程在`OpTestMeta`里完成。需在`setUp`函数定义输入输出和属性参数，以及Python对比的输出值。 -``` +```python import unittest import numpy as np from gradient_checker import GradientChecker, create_op @@ -276,17 +263,17 @@ class TestMulOp(unittest.TestCase): self.outputs = {'Out': np.dot(self.inputs['X'], self.inputs['Y'])} ``` 首先需要`import`必要的包,下面详细解释其他值： - + - `self.type = "mul" ` : 定义类型，和注册的类型一致。 - `self.inputs` : 定义输入，类型为Numpy.array，并初始化。 - `self.outputs` : 定义输出，并得到Python结算结果。 - + ### 反向Operator单测 反向Op单测继承自`GradientChecker`，而`GradientChecker`集成自`unittest.TestCase`，所以反向单测函数需要`test_`开头。 - ``` + ```python class MulGradOpTest(GradientChecker): def test_mul(self): op = create_op("mul") @@ -294,7 +281,7 @@ class TestMulOp(unittest.TestCase): 'X': np.random.random((32, 84)).astype("float32"), 'Y': np.random.random((84, 100)).astype("float32") } - self.compare_grad(op, inputs) + self.compare_grad(op, inputs) # mul op will enlarge the relative error self.check_grad( op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.5) @@ -310,7 +297,7 @@ class TestMulOp(unittest.TestCase): - 第四个参数`"Out"` : 指定前向网络最终的输出目标变量`Out` -### 编译和执行 +### 编译和执行 单测完成之后，在[`python/paddle/v2/framework/tests/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/CMakeLists.txt)里添加编译： From cdae0c754ec2f218ad06589fe669ebb00fb52e07 Mon Sep 17 00:00:00 2001 From: chengduoZH Date: Tue, 5 Sep 2017 15:51:47 +0800 Subject: [PATCH 38/62] fix Conv3d, DeConv3d (bias shape) --- paddle/gserver/layers/Conv3DLayer.cpp | 23 +++++++++++++++++------ paddle/gserver/layers/DeConv3DLayer.cpp | 22 ++++++++++++++++------ 2 files changed, 33 insertions(+), 12 deletions(-) diff --git a/paddle/gserver/layers/Conv3DLayer.cpp b/paddle/gserver/layers/Conv3DLayer.cpp index 7cc9937cce..3887aa58b2 100644 --- a/paddle/gserver/layers/Conv3DLayer.cpp +++ b/paddle/gserver/layers/Conv3DLayer.cpp @@ -42,10 +42,10 @@ bool Conv3DLayer::init(const LayerMap &layerMap, if (sharedBiases_) { CHECK_EQ((size_t)numFilters_, biasParameter_->getSize()); biases_ = - std::unique_ptr(new Weight(1, numFilters_, biasParameter_)); + std::unique_ptr(new Weight(numFilters_, 1, biasParameter_)); } else { biases_ = - std::unique_ptr(new Weight(1, getSize(), biasParameter_)); + std::unique_ptr(new Weight(getSize(), 1, biasParameter_)); } } return true; @@ -224,20 +224,31 @@ void Conv3DLayer::bpropData(int i) { } void Conv3DLayer::bpropBiases() { + MatrixPtr biases = Matrix::create(biases_->getWGrad()->getData(), + 1, + biases_->getWGrad()->getElementCnt(), + false, + useGpu_); MatrixPtr outGradMat = getOutputGrad(); + if (this->sharedBiases_) { - biases_->getWGrad()->collectSharedBias(*outGradMat, 1.0f); + biases->collectSharedBias(*outGradMat, 1.0f); } else { - biases_->getWGrad()->collectBias(*outGradMat, 1.0f); + biases->collectBias(*outGradMat, 1.0f); } } void Conv3DLayer::addBias() { MatrixPtr outMat = getOutputValue(); + MatrixPtr bias = Matrix::create(biases_->getW()->getData(), + 1, + biases_->getW()->getElementCnt(), + false, + useGpu_); if (this->sharedBiases_) { - outMat->addSharedBias(*(biases_->getW()), 1.0f); + outMat->addSharedBias(*(bias), 1.0f); } else { - outMat->addBias(*(biases_->getW()), 1.0f); + outMat->addBias(*(bias), 1.0f); } } diff --git a/paddle/gserver/layers/DeConv3DLayer.cpp b/paddle/gserver/layers/DeConv3DLayer.cpp index 7d5c772c89..2838980a97 100644 --- a/paddle/gserver/layers/DeConv3DLayer.cpp +++ b/paddle/gserver/layers/DeConv3DLayer.cpp @@ -42,10 +42,10 @@ bool DeConv3DLayer::init(const LayerMap &layerMap, if (sharedBiases_) { CHECK_EQ((size_t)numFilters_, biasParameter_->getSize()); biases_ = - std::unique_ptr(new Weight(1, numFilters_, biasParameter_)); + std::unique_ptr(new Weight(numFilters_, 1, biasParameter_)); } else { biases_ = - std::unique_ptr(new Weight(1, getSize(), biasParameter_)); + std::unique_ptr(new Weight(getSize(), 1, biasParameter_)); } } return true; @@ -191,21 +191,31 @@ void DeConv3DLayer::bpropWeights(int i) {} void DeConv3DLayer::bpropData(int i) {} void DeConv3DLayer::bpropBiases() { + MatrixPtr biases = Matrix::create(biases_->getWGrad()->getData(), + 1, + biases_->getWGrad()->getElementCnt(), + false, + useGpu_); const MatrixPtr &outGradMat = getOutputGrad(); if (this->sharedBiases_) { - biases_->getWGrad()->collectSharedBias(*outGradMat, 1.0f); + biases->collectSharedBias(*outGradMat, 1.0f); } else { - biases_->getWGrad()->collectBias(*outGradMat, 1.0f); + biases->collectBias(*outGradMat, 1.0f); } } void DeConv3DLayer::addBias() { MatrixPtr outMat = getOutputValue(); + MatrixPtr bias = Matrix::create(biases_->getW()->getData(), + 1, + biases_->getW()->getElementCnt(), + false, + useGpu_); if (this->sharedBiases_) { - outMat->addSharedBias(*(biases_->getW()), 1.0f); + outMat->addSharedBias(*(bias), 1.0f); } else { - outMat->addBias(*(biases_->getW()), 1.0f); + outMat->addBias(*(bias), 1.0f); } } From b3ff125d5598da6e362f360220eef816cf0d7f42 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Tue, 5 Sep 2017 16:29:57 +0800 Subject: [PATCH 39/62] follow comments. --- doc/howto/dev/new_op_cn.md | 42 +++++++++++++++++++++++--------------- 1 file changed, 25 insertions(+), 17 deletions(-) diff --git a/doc/howto/dev/new_op_cn.md b/doc/howto/dev/new_op_cn.md index 6bd54137ba..85c222163c 100644 --- a/doc/howto/dev/new_op_cn.md +++ b/doc/howto/dev/new_op_cn.md @@ -28,16 +28,18 @@ 内容 | 定义位置 -------------- | :---------------------- -OpProtoMake定义 | `*_op.cc`文件，Backward Op不需要定义OpProtoMake -Op定义 | `*_op.cc`文件 -Kernel实现 | CPU、GPU共享Kernel在`*_op.h`文件，否则，CPU可以在`*_op.cc`文件，GPU可在`*_op.cu`文件。 -注册Op | Op注册在`*_op.cc`文件；Kernel注册CPU在`*_op.cc`文件，GPU在`*_op.cu`文件 +OpProtoMake定义 | `.cc`文件，Backward Op不需要定义OpProtoMake +Op定义 | `.cc`文件 +Kernel实现 | CPU、GPU共享Kernel在`.h`文件，否则，CPU可以在`.cc`文件，GPU可在`.cu`文件。 +注册Op | Op注册在`.cc`文件；Kernel注册CPU在`.cc`文件，GPU在`.cu`文件 + 实现新的op都添加至目录[paddle/operators](https://github.com/PaddlePaddle/Paddle/tree/develop/paddle/operators)下，文件命名以`*_op.h`（如有） 、 `*_op.cc` 、`*_op.cu`（如有）结尾。 下面以矩阵乘操作，即[MulOp](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc)为例来介绍如何写带Kernel的Operator。 + ## 实现C++类 @@ -200,13 +202,18 @@ REGISTER_OP_GPU_KERNEL(mul_grad, ### 5. 编译 -无需修改[paddle/operators/CMakeLists.txt](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/CMakeLists.txt)文件，`paddle/operators` 目录下新增的 `*_op.cc` 文件会被自动加入编译。 +- 简单**无特殊依赖**的OP无需修改CMakeList.txt文件。[paddle/operators/CMakeLists.txt](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/CMakeLists.txt) 会自动将 `paddle/operators` 目录下新增的 `*_op.cc` 文件加入编译。 +- 较为复杂、**有额外依赖** 的operator仍需要修改[paddle/operators/CMakeLists.txt](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/CMakeLists.txt)。如，`mul_op` 依赖 `math_function`，需要在`CMakeLists.txt`中添加如下内容： -直接执行下面命令可进行编译： + ``` + op_library(mul_op SRCS mul_op.cc mul_op.cu DEPS math_function) + + ``` -``` -make mul_op -``` +- 运行下面命令可以进行编译： + + ``` + make mul_op + ``` ## 绑定Python @@ -235,13 +242,13 @@ make mul_op - 生成库 - 无需修改 [`paddle/pybind/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/CMakeLists.txt)文件，`paddle/operators` 目录下新增的 `*_op.cc` 文件会被自动被添加链接至生成的lib库中。 + 无需修改 [`paddle/pybind/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/CMakeLists.txt)文件，`paddle/operators` 目录下新增的 `*_op.cc` 文件会自动被添加链接到生成的lib库中。 ## 实现单元测试 单测包括对比前向Op不同设备(CPU、GPU)的实现、对比反向OP不同设备(CPU、GPU)的实现、反向Op的梯度测试。下面介绍介绍[`MulOp`的单测](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/test_mul_op.py)。 -### 前向Operator单测 +### 前向Operator单元测试 前向Op单测继承自`unittest.TestCase`，并定义元类`__metaclass__ = OpTestMeta`，具体单测流程在`OpTestMeta`里完成。需在`setUp`函数定义输入输出和属性参数，以及Python对比的输出值。 @@ -269,7 +276,7 @@ class TestMulOp(unittest.TestCase): - `self.outputs` : 定义输出，并得到Python结算结果。 -### 反向Operator单测 +### 反向Operator单元测试 反向Op单测继承自`GradientChecker`，而`GradientChecker`集成自`unittest.TestCase`，所以反向单测函数需要`test_`开头。 @@ -297,21 +304,22 @@ class TestMulOp(unittest.TestCase): - 第四个参数`"Out"` : 指定前向网络最终的输出目标变量`Out` -### 编译和执行 +### 编译和执行单元测试 -单测完成之后，在[`python/paddle/v2/framework/tests/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/CMakeLists.txt)里添加编译： +单测完成之后，在[`python/paddle/v2/framework/tests/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/CMakeLists.txt)里添加以下内容将单测加入工程中： ``` py_test(test_mul_op SRCS test_mul_op.py) ``` -编译时需要打开`WITH_TESTING`, 即 `cmake paddle_dir -DWITH_TESTING=ON`，编译成功之后执行单测命令为： +请注意，**不同于Op的编译测试，运行单元测试测时需要编译整个工程**，并且编译时需要打开`WITH_TESTING`, 即`cmake paddle_dir -DWITH_TESTING=ON`。编译成功后，执行下面的命令来运行单测： -``` +```bash make test ARGS="-R test_mul_op -V" ``` + 或者: -``` +```bash ctest -R test_mul_op ``` From 020e45f715b1a1cea5dcbee10dacb055b3889523 Mon Sep 17 00:00:00 2001 From: Luo Tao Date: Tue, 5 Sep 2017 16:54:12 +0800 Subject: [PATCH 40/62] follow comments to revert add_two_op to add_op --- paddle/framework/CMakeLists.txt | 2 +- paddle/framework/grad_op_builder_test.cc | 4 ++-- paddle/operators/{add_two_op.cc => add_op.cc} | 7 +++---- paddle/operators/{add_two_op.cu => add_op.cu} | 5 ++--- paddle/operators/{add_two_op.h => add_op.h} | 0 paddle/pybind/pybind.cc | 2 +- python/paddle/v2/framework/tests/test_add_two_op.py | 2 +- python/paddle/v2/framework/tests/test_gradient_checker.py | 2 +- python/paddle/v2/framework/tests/test_net.py | 4 ++-- python/paddle/v2/framework/tests/test_operator.py | 4 ++-- python/paddle/v2/framework/tests/test_recurrent_op.py | 2 +- 11 files changed, 16 insertions(+), 18 deletions(-) rename paddle/operators/{add_two_op.cc => add_op.cc} (88%) rename paddle/operators/{add_two_op.cu => add_op.cu} (82%) rename paddle/operators/{add_two_op.h => add_op.h} (100%) diff --git a/paddle/framework/CMakeLists.txt b/paddle/framework/CMakeLists.txt index e138517b6b..c0838d9b75 100644 --- a/paddle/framework/CMakeLists.txt +++ b/paddle/framework/CMakeLists.txt @@ -25,7 +25,7 @@ cc_test(operator_test SRCS operator_test.cc DEPS operator op_registry) cc_library(grad_op_builder SRCS grad_op_builder.cc DEPS operator) cc_library(op_registry SRCS op_registry.cc DEPS grad_op_builder) cc_test(op_registry_test SRCS op_registry_test.cc DEPS op_registry) -cc_test(grad_op_builder_test SRCS grad_op_builder_test.cc DEPS grad_op_builder op_registry add_two_op) +cc_test(grad_op_builder_test SRCS grad_op_builder_test.cc DEPS grad_op_builder op_registry add_op) py_proto_compile(framework_py_proto SRCS framework.proto) # Generate an empty __init__.py to make framework_py_proto as a valid python module. diff --git a/paddle/framework/grad_op_builder_test.cc b/paddle/framework/grad_op_builder_test.cc index 902c2655e9..9e3ca563c6 100644 --- a/paddle/framework/grad_op_builder_test.cc +++ b/paddle/framework/grad_op_builder_test.cc @@ -3,7 +3,7 @@ #include "paddle/framework/op_registry.h" #include "paddle/framework/operator.h" -USE_OP(add_two); +USE_OP(add); namespace paddle { namespace framework { @@ -41,7 +41,7 @@ namespace f = paddle::framework; TEST(GradOpBuilder, AddTwo) { std::shared_ptr add_op(f::OpRegistry::CreateOp( - "add_two", {{"X", {"x"}}, {"Y", {"y"}}}, {{"Out", {"out"}}}, {})); + "add", {{"X", {"x"}}, {"Y", {"y"}}}, {{"Out", {"out"}}}, {})); std::shared_ptr grad_add_op = f::OpRegistry::CreateGradOp(*add_op); EXPECT_EQ(grad_add_op->Inputs().size(), 4UL); diff --git a/paddle/operators/add_two_op.cc b/paddle/operators/add_op.cc similarity index 88% rename from paddle/operators/add_two_op.cc rename to paddle/operators/add_op.cc index bc99e306e0..8dbd47cf0d 100644 --- a/paddle/operators/add_two_op.cc +++ b/paddle/operators/add_op.cc @@ -12,7 +12,7 @@ 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/add_two_op.h" +#include "paddle/operators/add_op.h" namespace paddle { namespace operators { @@ -57,7 +57,6 @@ class AddOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OP(add_two, ops::AddOp, ops::AddOpMaker, add_two_grad, ops::AddOpGrad); +REGISTER_OP(add, ops::AddOp, ops::AddOpMaker, add_grad, ops::AddOpGrad); -REGISTER_OP_CPU_KERNEL(add_two, - ops::AddKernel); +REGISTER_OP_CPU_KERNEL(add, ops::AddKernel); diff --git a/paddle/operators/add_two_op.cu b/paddle/operators/add_op.cu similarity index 82% rename from paddle/operators/add_two_op.cu rename to paddle/operators/add_op.cu index acc03b2c8b..fdf2c66c7c 100644 --- a/paddle/operators/add_two_op.cu +++ b/paddle/operators/add_op.cu @@ -14,8 +14,7 @@ #define EIGEN_USE_GPU #include "paddle/framework/op_registry.h" -#include "paddle/operators/add_two_op.h" +#include "paddle/operators/add_op.h" namespace ops = paddle::operators; -REGISTER_OP_GPU_KERNEL(add_two, - ops::AddKernel); +REGISTER_OP_GPU_KERNEL(add, ops::AddKernel); diff --git a/paddle/operators/add_two_op.h b/paddle/operators/add_op.h similarity index 100% rename from paddle/operators/add_two_op.h rename to paddle/operators/add_op.h diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc index 6896422617..dba3d8f285 100644 --- a/paddle/pybind/pybind.cc +++ b/paddle/pybind/pybind.cc @@ -30,7 +30,7 @@ limitations under the License. */ namespace py = pybind11; -USE_OP(add_two); +USE_OP(add); USE_OP(onehot_cross_entropy); USE_OP(sgd); USE_OP(mul); diff --git a/python/paddle/v2/framework/tests/test_add_two_op.py b/python/paddle/v2/framework/tests/test_add_two_op.py index 0def484edd..a578e74eca 100644 --- a/python/paddle/v2/framework/tests/test_add_two_op.py +++ b/python/paddle/v2/framework/tests/test_add_two_op.py @@ -11,7 +11,7 @@ class TestAddOp(unittest.TestCase): __metaclass__ = OpTestMeta def setUp(self): - self.type = "add_two" + self.type = "add" self.inputs = { 'X': numpy.random.random((102, 105)).astype("float32"), 'Y': numpy.random.random((102, 105)).astype("float32") diff --git a/python/paddle/v2/framework/tests/test_gradient_checker.py b/python/paddle/v2/framework/tests/test_gradient_checker.py index e0b3151208..857427cdfb 100644 --- a/python/paddle/v2/framework/tests/test_gradient_checker.py +++ b/python/paddle/v2/framework/tests/test_gradient_checker.py @@ -7,7 +7,7 @@ from gradient_checker import get_numeric_gradient class GetNumericGradientTest(unittest.TestCase): def test_add_op(self): - add_op = Operator('add_two', X="X", Y="Y", Out="Z") + add_op = Operator('add', X="X", Y="Y", Out="Z") x = numpy.random.random((10, 1)).astype("float32") y = numpy.random.random((10, 1)).astype("float32") diff --git a/python/paddle/v2/framework/tests/test_net.py b/python/paddle/v2/framework/tests/test_net.py index 9339cf28da..e4b7cd480c 100644 --- a/python/paddle/v2/framework/tests/test_net.py +++ b/python/paddle/v2/framework/tests/test_net.py @@ -15,7 +15,7 @@ def fc(X, W, Y): class TestNet(unittest.TestCase): def test_net_all(self): net = core.Net.create() - op1 = Operator("add_two", X="X", Y="Y", Out="Out") + op1 = Operator("add", X="X", Y="Y", Out="Out") net.append_op(op1) net2 = core.Net.create() @@ -26,7 +26,7 @@ class TestNet(unittest.TestCase): expected = ''' Op(plain_net), inputs:{all[W, X, Y]}, outputs:{all[Out, fc.out, pre_activation]}. - Op(add_two), inputs:{X[X], Y[Y]}, outputs:{Out[Out]}. + Op(add), inputs:{X[X], Y[Y]}, outputs:{Out[Out]}. Op(plain_net), inputs:{all[W, X]}, outputs:{all[fc.out, pre_activation]}. Op(plain_net), inputs:{all[W, X]}, outputs:{all[fc.out, pre_activation]}. Op(mul), inputs:{X[X], Y[W]}, outputs:{Out[pre_activation]}. diff --git a/python/paddle/v2/framework/tests/test_operator.py b/python/paddle/v2/framework/tests/test_operator.py index 1abc4eeb57..040556322d 100644 --- a/python/paddle/v2/framework/tests/test_operator.py +++ b/python/paddle/v2/framework/tests/test_operator.py @@ -193,10 +193,10 @@ class TestOpDescCreationMethod(unittest.TestCase): class TestOpCreations(unittest.TestCase): def test_all(self): - add_op = op.Operator("add_two", X="a", Y="b", Out="z") + add_op = op.Operator("add", X="a", Y="b", Out="z") self.assertIsNotNone(add_op) # Invoke C++ DebugString() - self.assertEqual('Op(add_two), inputs:{X[a], Y[b]}, outputs:{Out[z]}.', + self.assertEqual('Op(add), inputs:{X[a], Y[b]}, outputs:{Out[z]}.', str(add_op)) diff --git a/python/paddle/v2/framework/tests/test_recurrent_op.py b/python/paddle/v2/framework/tests/test_recurrent_op.py index d6000ab9f9..22e680fd78 100644 --- a/python/paddle/v2/framework/tests/test_recurrent_op.py +++ b/python/paddle/v2/framework/tests/test_recurrent_op.py @@ -146,7 +146,7 @@ class TestRecurrentOp(unittest.TestCase): stepnet = core.Net.create() x_fc_op = Operator("mul", X="x@alias", Y="W", Out="Wx") h_fc_op = Operator("mul", X="h@pre", Y="U", Out="Uh") - sum_op = Operator("add_two", X="Wx", Y="Uh", Out="sum") + sum_op = Operator("add", X="Wx", Y="Uh", Out="sum") sig_op = Operator("sigmoid", X="sum", Y="h@alias") for op in [x_fc_op, h_fc_op, sum_op, sig_op]: From e687f3f540d3a403ab376f6c533362a6e6c577ff Mon Sep 17 00:00:00 2001 From: wanghaoshuang Date: Tue, 5 Sep 2017 17:37:12 +0800 Subject: [PATCH 41/62] Make attribute support for std::vector> --- paddle/framework/attribute.cc | 12 ++++++++++++ paddle/framework/attribute.h | 3 ++- paddle/framework/framework.proto | 7 +++++++ python/paddle/v2/framework/op.py | 7 ++++++- 4 files changed, 27 insertions(+), 2 deletions(-) diff --git a/paddle/framework/attribute.cc b/paddle/framework/attribute.cc index 9eb07acdff..27132eaa0b 100644 --- a/paddle/framework/attribute.cc +++ b/paddle/framework/attribute.cc @@ -43,6 +43,10 @@ template <> AttrType AttrTypeID>() { return STRINGS; } +template <> +AttrType AttrTypeID>>() { + return INT_PAIRS; +} Attribute GetAttrValue(const OpDesc::Attr& attr_desc) { switch (attr_desc.type()) { @@ -76,6 +80,14 @@ Attribute GetAttrValue(const OpDesc::Attr& attr_desc) { } return val; } + case paddle::framework::AttrType::INT_PAIRS: { + std::vector> val(attr_desc.int_pairs_size()); + for (int i = 0; i < attr_desc.int_pairs_size(); ++i) { + val[i].first = attr_desc.int_pairs(i).first(); + val[i].second = attr_desc.int_pairs(i).second(); + } + return val; + } } PADDLE_ENFORCE(false, "Unknown OpDesc::AttrDesc::type !"); return boost::blank(); diff --git a/paddle/framework/attribute.h b/paddle/framework/attribute.h index 08b47cabd4..071879a9d4 100644 --- a/paddle/framework/attribute.h +++ b/paddle/framework/attribute.h @@ -28,7 +28,8 @@ namespace paddle { namespace framework { typedef boost::variant, - std::vector, std::vector> + std::vector, std::vector, + std::vector>> Attribute; typedef std::unordered_map AttributeMap; diff --git a/paddle/framework/framework.proto b/paddle/framework/framework.proto index ae44a1ffd4..368136a972 100644 --- a/paddle/framework/framework.proto +++ b/paddle/framework/framework.proto @@ -22,8 +22,14 @@ enum AttrType { INTS = 3; FLOATS = 4; STRINGS = 5; + INT_PAIRS = 6; } +message IntPair { + required int32 first = 1; + required int32 second = 2; +}; + // OpDesc describes an instance of a C++ framework::OperatorBase // derived class type. message OpDesc { @@ -37,6 +43,7 @@ message OpDesc { repeated int32 ints = 6; repeated float floats = 7; repeated string strings = 8; + repeated IntPair int_pairs = 9; }; message Var { diff --git a/python/paddle/v2/framework/op.py b/python/paddle/v2/framework/op.py index e7e932f6fe..0349407a85 100644 --- a/python/paddle/v2/framework/op.py +++ b/python/paddle/v2/framework/op.py @@ -94,9 +94,14 @@ class OpDescCreationMethod(object): new_attr.floats.extend(user_defined_attr) elif attr.type == framework_pb2.STRINGS: new_attr.strings.extend(user_defined_attr) + elif attr.type == framework_pb2.INT_PAIRS: + for p in user_defined_attr: + pair = new_attr.pairs.add() + pair.first = p[0] + pair.second = p[1] else: raise NotImplementedError("Not support attribute type " + - attr.type) + str(attr.type)) return op_desc From 2beaf3aa2a966980177ea0a0d309fd7a7a594a1c Mon Sep 17 00:00:00 2001 From: Luo Tao Date: Tue, 5 Sep 2017 18:12:42 +0800 Subject: [PATCH 42/62] auto find .cc or .cu in operator/CMakeLists.txt --- paddle/operators/CMakeLists.txt | 54 +++++++++++++++------------------ 1 file changed, 24 insertions(+), 30 deletions(-) diff --git a/paddle/operators/CMakeLists.txt b/paddle/operators/CMakeLists.txt index 90185101c4..99b8e1967f 100644 --- a/paddle/operators/CMakeLists.txt +++ b/paddle/operators/CMakeLists.txt @@ -14,27 +14,31 @@ function(op_library TARGET) cmake_parse_arguments(op_library "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - foreach(src ${op_library_SRCS}) - if (${src} MATCHES ".*\\.cu$") - list(APPEND cu_srcs ${src}) - elseif(${src} MATCHES ".*\\.cc$") - list(APPEND cc_srcs ${src}) - else() - message(FATAL_ERROR "${TARGET} Source file ${src} should only be .cc or .cu") + list(LENGTH op_library_SRCS op_library_SRCS_len) + if (${op_library_SRCS_len} EQUAL 0) + if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET}.cc) + list(APPEND cc_srcs ${TARGET}.cc) endif() - endforeach() + if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET}.cu) + list(APPEND cu_srcs ${TARGET}.cc) + endif() + else() + foreach(src ${op_library_SRCS}) + if (${src} MATCHES ".*\\.cu$") + list(APPEND cu_srcs ${src}) + elseif(${src} MATCHES ".*\\.cc$") + list(APPEND cc_srcs ${src}) + else() + message(FATAL_ERROR "${TARGET} Source file ${src} should only be .cc or .cu") + endif() + endforeach() + endif() list(LENGTH cc_srcs cc_srcs_len) if (${cc_srcs_len} EQUAL 0) message(FATAL_ERROR "The op library ${TARGET} should contains at least one .cc file") endif() - list(LENGTH cu_srcs cu_srcs_len) - list(LENGTH op_library_DEPS dep_len) - if (${cu_srcs_len} EQUAL 0 AND ${dep_len} EQUAL 0) - message(WARNING "The op library ${TARGET} not support GPU!") - endif() - if (WITH_GPU) nv_library(${TARGET} SRCS ${cc_srcs} ${cu_srcs} DEPS ${op_library_DEPS} ${op_common_deps}) @@ -46,32 +50,22 @@ endfunction() add_subdirectory(math) -set(ONLYCPU_OPS - net_op - gather_op - scatter_op) -foreach(src ${ONLYCPU_OPS}) - op_library(${src} SRCS ${src}.cc) -endforeach() - set(DEPS_OPS identity_op minus_op mul_op recurrent_op scale_op) -op_library(identity_op SRCS identity_op.cc DEPS scale_op) -op_library(minus_op SRCS minus_op.cc minus_op.cu DEPS scale_op) -op_library(mul_op SRCS mul_op.cc mul_op.cu DEPS math_function) +op_library(identity_op DEPS scale_op) +op_library(minus_op DEPS scale_op) +op_library(mul_op DEPS math_function) op_library(recurrent_op SRCS recurrent_op.cc rnn/recurrent_op_utils.cc DEPS framework_proto tensor operator net_op) -op_library(scale_op SRCS scale_op.cc scale_op.cu DEPS net_op) +op_library(scale_op DEPS net_op) -list(REMOVE_ITEM GENERAL_OPS - ${ONLYCPU_OPS} - ${DEPS_OPS}) +list(REMOVE_ITEM GENERAL_OPS ${DEPS_OPS}) foreach(src ${GENERAL_OPS}) - op_library(${src} SRCS ${src}.cc ${src}.cu) + op_library(${src}) endforeach() set(GLOB_OP_LIB ${OP_LIBRARY} CACHE INTERNAL "Global OP library") From 42513496f30c137e42b54fab6ce275845349bccf Mon Sep 17 00:00:00 2001 From: Luo Tao Date: Tue, 5 Sep 2017 22:17:24 +0800 Subject: [PATCH 43/62] fix a type error in operator/CMakeLists.txt --- paddle/operators/CMakeLists.txt | 2 +- paddle/operators/add_op.cu | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/paddle/operators/CMakeLists.txt b/paddle/operators/CMakeLists.txt index 99b8e1967f..8a0ff1eb53 100644 --- a/paddle/operators/CMakeLists.txt +++ b/paddle/operators/CMakeLists.txt @@ -20,7 +20,7 @@ function(op_library TARGET) list(APPEND cc_srcs ${TARGET}.cc) endif() if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET}.cu) - list(APPEND cu_srcs ${TARGET}.cc) + list(APPEND cu_srcs ${TARGET}.cu) endif() else() foreach(src ${op_library_SRCS}) diff --git a/paddle/operators/add_op.cu b/paddle/operators/add_op.cu index fdf2c66c7c..d9c6d20a6c 100644 --- a/paddle/operators/add_op.cu +++ b/paddle/operators/add_op.cu @@ -12,8 +12,6 @@ See the License for the specific language governing permissions and limitations under the License. */ -#define EIGEN_USE_GPU -#include "paddle/framework/op_registry.h" #include "paddle/operators/add_op.h" namespace ops = paddle::operators; From dc520da763f258e6ca1c79f79bb82bc55ec4cf14 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Tue, 5 Sep 2017 23:08:21 +0800 Subject: [PATCH 44/62] update doc of softmax_op. --- paddle/operators/softmax_op.cc | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/paddle/operators/softmax_op.cc b/paddle/operators/softmax_op.cc index 40c51a64c4..7d062ad67c 100644 --- a/paddle/operators/softmax_op.cc +++ b/paddle/operators/softmax_op.cc @@ -24,7 +24,7 @@ class SoftmaxOp : public framework::OperatorWithKernel { protected: void InferShape(const framework::InferShapeContext &ctx) const override { PADDLE_ENFORCE(ctx.Input("X")->dims().size() == 2UL, - "The input of softmax op must be matrix"); + "The input of softmax op must be a matrix."); ctx.Output("Y")->Resize(ctx.Input("X")->dims()); } }; @@ -34,9 +34,27 @@ class SoftmaxOpMaker : public framework::OpProtoAndCheckerMaker { SoftmaxOpMaker(framework::OpProto *proto, framework::OpAttrChecker *op_checker) : OpProtoAndCheckerMaker(proto, op_checker) { - AddInput("X", "input of softmax"); - AddOutput("Y", "output of softmax"); - AddComment("Softmax Op"); + AddInput("X", + "The input tensor of softmax. " + "2-D with shape [batch_size, input_feature_dimensions]."); + AddOutput("Y", "The normalized values with the same shape as X."); + AddComment(R"DOC( +The input of softmax operator is a 2-D tensor with shape N x K (N is the +batch_size, K is the dimension of input feature). The output tensor has the +same shape as the input tensor. + +For each row of the input tensor, the softmax operator squashes the +K-dimensional vector of arbitrary real values to a K-dimensional vector of real +values in the range [0, 1] that add up to 1. Specifically, it computes the +exponential of the given dimension and the sum of exponential values of all +the other dimensions in the K-dimensional vector input. Then the ratio of the +exponential of the given dimension and the sum of exponential values of all +the other dimensions is the output of the softmax operator. + +For each row `i` and each column `j` in X, we have: + Y[i, j] = exp(X[i, j]) / sum_j(exp(X[i, j])) + +)DOC"); } }; From bc0f9495f019d9f72bf9d6a82f97673c7dce0063 Mon Sep 17 00:00:00 2001 From: fengjiayi Date: Tue, 5 Sep 2017 13:43:51 -0700 Subject: [PATCH 45/62] Move two tests form `op_registry_test` to `operator_test` 1. TEST(ProtoMaker, DuplicatedAttr) 2. TEST(ProtoMaker, DuplicatedInOut) --- paddle/framework/op_registry_test.cc | 34 +--------------------------- paddle/framework/operator_test.cc | 34 ++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+), 33 deletions(-) diff --git a/paddle/framework/op_registry_test.cc b/paddle/framework/op_registry_test.cc index 50c45919c5..b43f6a8cc5 100644 --- a/paddle/framework/op_registry_test.cc +++ b/paddle/framework/op_registry_test.cc @@ -174,36 +174,4 @@ TEST(OpRegistry, CustomChecker) { op->Run(scope, dev_ctx); int test_attr = op->GetAttr("test_attr"); ASSERT_EQ(test_attr, 4); -} - -class TestAttrProtoMaker : public pd::OpProtoAndCheckerMaker { - public: - TestAttrProtoMaker(pd::OpProto* proto, pd::OpAttrChecker* op_checker) - : OpProtoAndCheckerMaker(proto, op_checker) { - AddAttr("scale", "scale of test op"); - AddAttr("scale", "scale of test op"); - } -}; - -TEST(ProtoMaker, DuplicatedAttr) { - pd::OpProto op_proto; - pd::OpAttrChecker op_checker; - auto proto_maker = TestAttrProtoMaker(&op_proto, &op_checker); - ASSERT_THROW(proto_maker.Validate(), paddle::platform::EnforceNotMet); -} - -class TestInOutProtoMaker : public pd::OpProtoAndCheckerMaker { - public: - TestInOutProtoMaker(pd::OpProto* proto, pd::OpAttrChecker* op_checker) - : OpProtoAndCheckerMaker(proto, op_checker) { - AddInput("input", "input of test op"); - AddInput("input", "input of test op"); - } -}; - -TEST(ProtoMaker, DuplicatedInOut) { - pd::OpProto op_proto; - pd::OpAttrChecker op_checker; - auto proto_maker = TestInOutProtoMaker(&op_proto, &op_checker); - ASSERT_THROW(proto_maker.Validate(), paddle::platform::EnforceNotMet); -} +} \ No newline at end of file diff --git a/paddle/framework/operator_test.cc b/paddle/framework/operator_test.cc index f7c9e6b196..8a1970c7a8 100644 --- a/paddle/framework/operator_test.cc +++ b/paddle/framework/operator_test.cc @@ -263,4 +263,38 @@ TEST(Operator, Clone) { OperatorClone a("ABC", {}, {}, {}); auto b = a.Clone(); ASSERT_EQ(a.Type(), b->Type()); +} + +class TestAttrProtoMaker : public paddle::framework::OpProtoAndCheckerMaker { + public: + TestAttrProtoMaker(paddle::framework::OpProto* proto, + paddle::framework::OpAttrChecker* op_checker) + : OpProtoAndCheckerMaker(proto, op_checker) { + AddAttr("scale", "scale of test op"); + AddAttr("scale", "scale of test op"); + } +}; + +TEST(ProtoMaker, DuplicatedAttr) { + paddle::framework::OpProto op_proto; + paddle::framework::OpAttrChecker op_checker; + auto proto_maker = TestAttrProtoMaker(&op_proto, &op_checker); + ASSERT_THROW(proto_maker.Validate(), paddle::platform::EnforceNotMet); +} + +class TestInOutProtoMaker : public paddle::framework::OpProtoAndCheckerMaker { + public: + TestInOutProtoMaker(paddle::framework::OpProto* proto, + paddle::framework::OpAttrChecker* op_checker) + : OpProtoAndCheckerMaker(proto, op_checker) { + AddInput("input", "input of test op"); + AddInput("input", "input of test op"); + } +}; + +TEST(ProtoMaker, DuplicatedInOut) { + paddle::framework::OpProto op_proto; + paddle::framework::OpAttrChecker op_checker; + auto proto_maker = TestInOutProtoMaker(&op_proto, &op_checker); + ASSERT_THROW(proto_maker.Validate(), paddle::platform::EnforceNotMet); } \ No newline at end of file From fd0e1e893f22e1ef27fb9f1e6d12c590d2fcdeea Mon Sep 17 00:00:00 2001 From: fengjiayi Date: Tue, 5 Sep 2017 17:42:14 -0700 Subject: [PATCH 46/62] Fix warnings in lookup_op --- paddle/operators/lookup_table_op.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/paddle/operators/lookup_table_op.h b/paddle/operators/lookup_table_op.h index 4da8079b91..877b36cef4 100644 --- a/paddle/operators/lookup_table_op.h +++ b/paddle/operators/lookup_table_op.h @@ -30,12 +30,12 @@ class LookupTableKernel : public framework::OpKernel { auto ids_t = context.Input("Ids"); // int tensor auto output_t = context.Output("Out"); // float tensor - size_t N = table_t->dims()[0]; - size_t D = table_t->dims()[1]; + int N = table_t->dims()[0]; + int D = table_t->dims()[1]; auto ids = ids_t->data(); auto table = table_t->data(); auto output = output_t->mutable_data(context.GetPlace()); - for (size_t i = 0; i < product(ids_t->dims()); ++i) { + for (ssize_t i = 0; i < product(ids_t->dims()); ++i) { PADDLE_ENFORCE_LT(ids[i], N); PADDLE_ENFORCE_GE(ids[i], 0); memcpy(output + i * D, table + ids[i] * D, D * sizeof(T)); @@ -51,8 +51,8 @@ class LookupTableGradKernel : public framework::OpKernel { auto d_output_t = context.Input(framework::GradVarName("Out")); auto d_table_t = context.Output(framework::GradVarName("W")); - size_t N = d_table_t->dims()[0]; - size_t D = d_table_t->dims()[1]; + int N = d_table_t->dims()[0]; + int D = d_table_t->dims()[1]; auto ids = ids_t->data(); const T* d_output = d_output_t->data(); T* d_table = d_table_t->mutable_data(context.GetPlace()); @@ -61,10 +61,10 @@ class LookupTableGradKernel : public framework::OpKernel { t.device(context.GetEigenDevice()) = t.constant(static_cast(0)); - for (size_t i = 0; i < product(ids_t->dims()); ++i) { + for (ssize_t i = 0; i < product(ids_t->dims()); ++i) { PADDLE_ENFORCE_LT(ids[i], N); PADDLE_ENFORCE_GE(ids[i], 0); - for (size_t j = 0; j < D; ++j) { + for (int j = 0; j < D; ++j) { d_table[ids[i] * D + j] += d_output[i * D + j]; } } From 5d9478094d8721f312d9fec323920e608ed23e66 Mon Sep 17 00:00:00 2001 From: lispc Date: Wed, 6 Sep 2017 11:33:16 +0800 Subject: [PATCH 47/62] PyDataProvider2.InputType repr refine style --- python/paddle/trainer/PyDataProvider2.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/paddle/trainer/PyDataProvider2.py b/python/paddle/trainer/PyDataProvider2.py index 033c71cf8f..248da4ae8d 100644 --- a/python/paddle/trainer/PyDataProvider2.py +++ b/python/paddle/trainer/PyDataProvider2.py @@ -87,7 +87,8 @@ class InputType(object): def __repr__(self): """ - Return a human readable representation like 'InputType(dim=25921, seq_type=SequenceType.NO_SEQUENCE, type=DataType.Dense)' + Return a human readable representation like 'InputType(dim=25921, + seq_type=SequenceType.NO_SEQUENCE, type=DataType.Dense)' """ repr_str = type(self).__name__ repr_str += '(' From 11163dfc7a6c1504c42acf77bd48d677d7167941 Mon Sep 17 00:00:00 2001 From: qijun Date: Wed, 6 Sep 2017 11:54:33 +0800 Subject: [PATCH 48/62] make dim int to int64_t --- paddle/framework/ddim.cc | 64 ++++++++++----------- paddle/framework/ddim.h | 20 +++---- paddle/framework/ddim_test.cc | 4 +- paddle/framework/dim.h | 67 +++++++++++----------- paddle/framework/dim_test.cu | 4 +- paddle/framework/eigen.h | 2 +- paddle/framework/tensor_impl.h | 4 +- paddle/operators/gaussian_random_op.cc | 10 +++- paddle/operators/rnn/recurrent_op_utils.cc | 2 +- paddle/operators/uniform_random_op.cc | 10 +++- paddle/pybind/pybind.cc | 2 +- paddle/pybind/tensor_py.h | 4 +- 12 files changed, 102 insertions(+), 91 deletions(-) diff --git a/paddle/framework/ddim.cc b/paddle/framework/ddim.cc index cfd3e8dfde..85b7de7974 100644 --- a/paddle/framework/ddim.cc +++ b/paddle/framework/ddim.cc @@ -21,16 +21,16 @@ namespace framework { /// @cond HIDDEN template -Dim make_dim(const int* d) { +Dim make_dim(const int64_t* d) { return Dim(*d, make_dim(d + 1)); } template <> -Dim<1> make_dim<1>(const int* d) { +Dim<1> make_dim<1>(const int64_t* d) { return Dim<1>(*d); } -void make_ddim(DDim& ddim, const int* dims, int n) { +void make_ddim(DDim& ddim, const int64_t* dims, int n) { switch (n) { case 1: ddim = make_dim<1>(dims); @@ -67,13 +67,13 @@ void make_ddim(DDim& ddim, const int* dims, int n) { /// @endcond -DDim make_ddim(std::initializer_list dims) { +DDim make_ddim(std::initializer_list dims) { DDim result(make_dim(0)); make_ddim(result, dims.begin(), dims.size()); return result; } -DDim make_ddim(const std::vector& dims) { +DDim make_ddim(const std::vector& dims) { DDim result(make_dim(0)); make_ddim(result, &dims[0], dims.size()); return result; @@ -81,12 +81,12 @@ DDim make_ddim(const std::vector& dims) { /// @cond HIDDEN // XXX For some reason, putting this in an anonymous namespace causes errors -class DynamicMutableIndexer : public boost::static_visitor { +class DynamicMutableIndexer : public boost::static_visitor { public: explicit DynamicMutableIndexer(int idx) : idx_(idx) {} template - int& operator()(Dim& dim) const { + int64_t& operator()(Dim& dim) const { return dim[idx_]; } @@ -94,12 +94,12 @@ class DynamicMutableIndexer : public boost::static_visitor { int idx_; }; -class DynamicConstIndexer : public boost::static_visitor { +class DynamicConstIndexer : public boost::static_visitor { public: explicit DynamicConstIndexer(int idx) : idx_(idx) {} template - int operator()(const Dim& dim) const { + int64_t operator()(const Dim& dim) const { return dim[idx_]; } @@ -109,22 +109,22 @@ class DynamicConstIndexer : public boost::static_visitor { /// @endcond -int& DDim::operator[](int idx) { +int64_t& DDim::operator[](int idx) { return boost::apply_visitor(DynamicMutableIndexer(idx), var); } -int DDim::operator[](int idx) const { +int64_t DDim::operator[](int idx) const { return boost::apply_visitor(DynamicConstIndexer(idx), var); } -ssize_t DDim::size() const { return arity(*this); } +int64_t DDim::size() const { return arity(*this); } bool DDim::operator==(DDim d) const { if (var.which() != d.getVar().which()) { return false; } else { - std::vector v1 = vectorize(*this); - std::vector v2 = vectorize(d); + std::vector v1 = vectorize(*this); + std::vector v2 = vectorize(d); for (unsigned int i = 0; i < v1.size(); i++) { if (v1[i] != v2[i]) { @@ -139,10 +139,10 @@ bool DDim::operator==(DDim d) const { bool DDim::operator!=(DDim d) const { return !(*this == d); } DDim DDim::operator+(DDim d) const { - std::vector v1 = vectorize(*this); - std::vector v2 = vectorize(d); + std::vector v1 = vectorize(*this); + std::vector v2 = vectorize(d); - std::vector v3; + std::vector v3; assert(v1.size() == v2.size()); @@ -154,10 +154,10 @@ DDim DDim::operator+(DDim d) const { } DDim DDim::operator*(DDim d) const { - std::vector v1 = vectorize(*this); - std::vector v2 = vectorize(d); + std::vector v1 = vectorize(*this); + std::vector v2 = vectorize(d); - std::vector v3; + std::vector v3; assert(v1.size() == v2.size()); @@ -168,15 +168,15 @@ DDim DDim::operator*(DDim d) const { return make_ddim(v3); } -int get(const DDim& ddim, int idx) { return ddim[idx]; } +int64_t get(const DDim& ddim, int idx) { return ddim[idx]; } void set(DDim& ddim, int idx, int value) { ddim[idx] = value; } /// @cond HIDDEN struct VectorizeVisitor : public boost::static_visitor<> { - std::vector& vector; + std::vector& vector; - explicit VectorizeVisitor(std::vector& v) : vector(v) {} + explicit VectorizeVisitor(std::vector& v) : vector(v) {} template void operator()(const T& t) { @@ -188,31 +188,31 @@ struct VectorizeVisitor : public boost::static_visitor<> { }; /// @endcond -std::vector vectorize(const DDim& ddim) { - std::vector result; +std::vector vectorize(const DDim& ddim) { + std::vector result; VectorizeVisitor visitor(result); boost::apply_visitor(visitor, ddim); return result; } -struct ProductVisitor : public boost::static_visitor { +struct ProductVisitor : public boost::static_visitor { template - ssize_t operator()(const Dim& dim) { + int64_t operator()(const Dim& dim) { return product(dim); } }; -ssize_t product(const DDim& ddim) { +int64_t product(const DDim& ddim) { ProductVisitor visitor; return boost::apply_visitor(visitor, ddim); } struct SliceVectorizeVisitor : public boost::static_visitor<> { - std::vector& vector; + std::vector& vector; int begin; int end; - SliceVectorizeVisitor(std::vector& v, int b, int e) + SliceVectorizeVisitor(std::vector& v, int b, int e) : vector(v), begin(b), end(e) { PADDLE_ENFORCE(begin < end, "Begin index must be less than end index in ddim slice."); @@ -240,7 +240,7 @@ struct SliceVectorizeVisitor : public boost::static_visitor<> { }; DDim slice_ddim(const DDim& dim, int begin, int end) { - std::vector vec; + std::vector vec; vec.reserve(end - begin); SliceVectorizeVisitor visitor(vec, begin, end); boost::apply_visitor(visitor, dim); @@ -280,7 +280,7 @@ std::ostream& operator<<(std::ostream& os, const DDim& ddim) { return os; } -DDim::DDim(std::initializer_list init_list) { +DDim::DDim(std::initializer_list init_list) { *this = make_ddim(init_list); } } // namespace framework diff --git a/paddle/framework/ddim.h b/paddle/framework/ddim.h index 95f294b627..db30c52394 100644 --- a/paddle/framework/ddim.h +++ b/paddle/framework/ddim.h @@ -40,7 +40,7 @@ struct DDim { template explicit DDim(const Dim& in) : var(in) {} - /*implicit*/ DDim(std::initializer_list init_list); + /*implicit*/ DDim(std::initializer_list init_list); template DDim& operator=(const Dim& in) { @@ -48,8 +48,8 @@ struct DDim { return *this; } - int& operator[](int idx); - int operator[](int idx) const; + int64_t& operator[](int idx); + int64_t operator[](int idx) const; template typename Visitor::result_type apply_visitor(Visitor& visitor) { @@ -71,15 +71,15 @@ struct DDim { DDim operator*(DDim d) const; - ssize_t size() const; + int64_t size() const; }; /** - * \brief Make a DDim from std::vector + * \brief Make a DDim from std::vector * * \param dims An vector of ints. Must be sized between [1, 9] */ -DDim make_ddim(const std::vector& dims); +DDim make_ddim(const std::vector& dims); /** * \brief Make a DDim from an initializer list @@ -87,14 +87,14 @@ DDim make_ddim(const std::vector& dims); * \param dims An initializer list of ints. Must be sized between [1, 9] * */ -DDim make_ddim(std::initializer_list dims); +DDim make_ddim(std::initializer_list dims); -int get(const DDim& dim, int idx); +int64_t get(const DDim& dim, int idx); void set(DDim& dim, int idx, int val); -std::vector vectorize(const DDim& ddim); +std::vector vectorize(const DDim& ddim); -ssize_t product(const DDim& ddim); +int64_t product(const DDim& ddim); /** * \brief Slice a ddim diff --git a/paddle/framework/ddim_test.cc b/paddle/framework/ddim_test.cc index 9d18a2972c..756232b1b5 100644 --- a/paddle/framework/ddim_test.cc +++ b/paddle/framework/ddim_test.cc @@ -12,7 +12,7 @@ TEST(DDim, Equality) { EXPECT_EQ(ddim[2], 5); // construct a DDim from a vector - std::vector vec({9, 1, 5}); + std::vector vec({9, 1, 5}); paddle::framework::DDim vddim = paddle::framework::make_ddim(vec); EXPECT_EQ(ddim[0], 9); EXPECT_EQ(ddim[1], 1); @@ -25,7 +25,7 @@ TEST(DDim, Equality) { EXPECT_EQ(paddle::framework::get(ddim, 0), 6); // vectorize a DDim - std::vector res_vec = paddle::framework::vectorize(vddim); + std::vector res_vec = paddle::framework::vectorize(vddim); EXPECT_EQ(res_vec[0], 9); EXPECT_EQ(res_vec[1], 1); EXPECT_EQ(res_vec[2], 5); diff --git a/paddle/framework/dim.h b/paddle/framework/dim.h index 883fdc55eb..04d4b0e604 100644 --- a/paddle/framework/dim.h +++ b/paddle/framework/dim.h @@ -17,13 +17,13 @@ struct Dim { static constexpr int dimensions = i; template - HOSTDEVICE Dim(int _head, Args... _tail) : head(_head), tail(_tail...) { + HOSTDEVICE Dim(int64_t _head, Args... _tail) : head(_head), tail(_tail...) { static_assert(sizeof...(_tail) == i - 1, "Dim initialized with the wrong number of parameters"); } HOSTDEVICE - Dim(int _head, const Dim& _tail) : head(_head), tail(_tail) {} + Dim(int64_t _head, const Dim& _tail) : head(_head), tail(_tail) {} HOSTDEVICE Dim() : head(0), tail() {} @@ -31,12 +31,12 @@ struct Dim { /** Construct a Dim from a linear index and size. Uses Fortran order * indexing. */ HOSTDEVICE - Dim(int idx, const Dim& size) + Dim(int64_t idx, const Dim& size) : head(idx % size.head), tail(idx / size.head, size.tail) {} /** Construct a Dim with each dimension set to the given index */ HOSTDEVICE - Dim(int idx) : head(idx), tail(idx) {} + Dim(int64_t idx) : head(idx), tail(idx) {} HOSTDEVICE bool operator==(const Dim& o) const { @@ -47,13 +47,13 @@ struct Dim { bool operator!=(const Dim& o) const { return !(*this == o); } HOSTDEVICE - int& operator[](int idx); + int64_t& operator[](int idx); HOSTDEVICE - int operator[](int idx) const; + int64_t operator[](int idx) const; HOST std::string to_string() const; - int head; + int64_t head; Dim tail; }; @@ -63,7 +63,7 @@ struct Dim<1> { static constexpr int dimensions = 1; HOSTDEVICE - Dim(int _head) : head(_head) {} + Dim(int64_t _head) : head(_head) {} HOSTDEVICE Dim() : head(0) {} @@ -86,11 +86,11 @@ struct Dim<1> { bool operator!=(const Dim<1>& o) const { return !(*this == o); } HOSTDEVICE - int& operator[](int idx); + int64_t& operator[](int idx); HOSTDEVICE - int operator[](int idx) const; + int64_t operator[](int idx) const; - int head; + int64_t head; }; namespace { @@ -100,12 +100,12 @@ template struct DimGetter { // Return a copy if Dim is const template - HOSTDEVICE static int impl(const D& d) { + HOSTDEVICE static int64_t impl(const D& d) { return DimGetter::impl(d.tail); } // Return a reference if Dim is mutable template - HOSTDEVICE static int& impl(D& d) { + HOSTDEVICE static int64_t& impl(D& d) { return DimGetter::impl(d.tail); } }; @@ -115,18 +115,18 @@ template <> struct DimGetter<0> { // Return a copy if Dim is const template - HOSTDEVICE static int impl(const D& d) { + HOSTDEVICE static int64_t impl(const D& d) { return d.head; } // Return a reference if Dim is mutable template - HOSTDEVICE static int& impl(D& d) { + HOSTDEVICE static int64_t& impl(D& d) { return d.head; } }; template -HOSTDEVICE int& indexer(Dim& dim, int idx) { +HOSTDEVICE int64_t& indexer(Dim& dim, int idx) { #ifndef __CUDA_ARCH__ if (idx < 0) { throw std::invalid_argument("Tried to access a negative dimension"); @@ -141,7 +141,7 @@ HOSTDEVICE int& indexer(Dim& dim, int idx) { } template <> -HOSTDEVICE int& indexer<1>(Dim<1>& dim, int idx) { +HOSTDEVICE int64_t& indexer<1>(Dim<1>& dim, int idx) { #ifndef __CUDA_ARCH__ if (idx != 0) { throw std::invalid_argument("Invalid index"); @@ -153,7 +153,7 @@ HOSTDEVICE int& indexer<1>(Dim<1>& dim, int idx) { } template -HOSTDEVICE int indexer(const Dim& dim, int idx) { +HOSTDEVICE int64_t indexer(const Dim& dim, int idx) { #ifndef __CUDA_ARCH__ if (idx < 0) { throw std::invalid_argument("Tried to access a negative dimension"); @@ -168,7 +168,7 @@ HOSTDEVICE int indexer(const Dim& dim, int idx) { } template <> -HOSTDEVICE int indexer<1>(const Dim<1>& dim, int idx) { +HOSTDEVICE int64_t indexer<1>(const Dim<1>& dim, int idx) { #ifndef __CUDA_ARCH__ if (idx != 0) { throw std::invalid_argument("Invalid index"); @@ -182,73 +182,76 @@ HOSTDEVICE int indexer<1>(const Dim<1>& dim, int idx) { } // namespace // Static access to constant Dim template -HOSTDEVICE int get(const Dim& d) { +HOSTDEVICE int64_t get(const Dim& d) { return DimGetter::impl(d); } // Static access to mutable Dim template -HOSTDEVICE int& get(Dim& d) { +HOSTDEVICE int64_t& get(Dim& d) { return DimGetter::impl(d); } // Dynamic access to constant Dim template -HOSTDEVICE int Dim::operator[](int i) const { +HOSTDEVICE int64_t Dim::operator[](int i) const { return indexer(*this, i); } // Dynamic access to mutable Dim template -HOSTDEVICE int& Dim::operator[](int i) { +HOSTDEVICE int64_t& Dim::operator[](int i) { return indexer(*this, i); } // Dynamic access to constant Dim -inline HOSTDEVICE int Dim<1>::operator[](int i) const { +inline HOSTDEVICE int64_t Dim<1>::operator[](int i) const { return indexer(*this, i); } // Dynamic access to mutable Dim -inline HOSTDEVICE int& Dim<1>::operator[](int i) { return indexer(*this, i); } +inline HOSTDEVICE int64_t& Dim<1>::operator[](int i) { + return indexer(*this, i); +} // Dynamic access to constant Dim // without std::enable_if will try to instantiate this on get<0>(d) template -HOSTDEVICE typename std::enable_if<(l > 0), int>::type get(const Dim& d, - int i) { +HOSTDEVICE typename std::enable_if<(l > 0), int64_t>::type get(const Dim& d, + int i) { return d[i]; } // Dynamic access to mutable Dim template -HOSTDEVICE typename std::enable_if<(l > 0), int&>::type get(Dim& d, int i) { +HOSTDEVICE typename std::enable_if<(l > 0), int64_t&>::type get(Dim& d, + int i) { return d[i]; } // Dot product of two dims template -HOSTDEVICE int linearize(const Dim& a, const Dim& b) { +HOSTDEVICE int64_t linearize(const Dim& a, const Dim& b) { return a.head * b.head + linearize(a.tail, b.tail); } // Base case dot product of two Dims // Notice it is inline because it is no longer a template template <> -HOSTDEVICE inline int linearize(const Dim<1>& a, const Dim<1>& b) { +HOSTDEVICE inline int64_t linearize(const Dim<1>& a, const Dim<1>& b) { return a.head * b.head; } // Product of a Dim template -HOSTDEVICE int product(const Dim& a, int prod = 1) { +HOSTDEVICE int64_t product(const Dim& a, int prod = 1) { return prod * a.head * product(a.tail); } // Base case product of a Dim // Notice it is inline because it is no longer a template template <> -HOSTDEVICE inline int product(const Dim<1>& a, int prod) { +HOSTDEVICE inline int64_t product(const Dim<1>& a, int prod) { return prod * a.head; } diff --git a/paddle/framework/dim_test.cu b/paddle/framework/dim_test.cu index 3898d0a447..f42b1eeadf 100644 --- a/paddle/framework/dim_test.cu +++ b/paddle/framework/dim_test.cu @@ -47,9 +47,9 @@ TEST(Dim, Equality) { EXPECT_EQ(b[1], 11); // dynamic access on GPU - thrust::device_vector r(1); + thrust::device_vector r(1); dyn_idx_gpu<<<1, 1>>>(thrust::raw_pointer_cast(r.data())); - int res = r[0]; + int64_t res = r[0]; EXPECT_EQ(res, 6); // ex_prefix_mul diff --git a/paddle/framework/eigen.h b/paddle/framework/eigen.h index a4667cc51f..2d8d9ae10c 100644 --- a/paddle/framework/eigen.h +++ b/paddle/framework/eigen.h @@ -28,7 +28,7 @@ struct EigenDim { static Type From(const DDim& dims) { PADDLE_ENFORCE(arity(dims) == D, "D must match arity(DDim)"); Type ret; - for (int d = 0; d < arity(dims); d++) { + for (int64_t d = 0; d < arity(dims); d++) { ret[d] = dims[d]; } return ret; diff --git a/paddle/framework/tensor_impl.h b/paddle/framework/tensor_impl.h index 7893e233b7..94f436294f 100644 --- a/paddle/framework/tensor_impl.h +++ b/paddle/framework/tensor_impl.h @@ -58,7 +58,7 @@ inline T* Tensor::mutable_data(platform::Place place) { "Tensor's numel must be larger than zero to call " "Tensor::mutable_data. Call Tensor::set_dim first."); /* some versions of boost::variant don't have operator!= */ - size_t size = product(dims_) * sizeof(T); + int64_t size = product(dims_) * sizeof(T); if (holder_ == nullptr || !(holder_->place() == place) || holder_->size() < size + offset_) { if (platform::is_cpu_place(place)) { @@ -131,7 +131,7 @@ inline Tensor Tensor::Slice(const int& begin_idx, const int& end_idx) const { PADDLE_ENFORCE_LT(begin_idx, end_idx, "Begin index must be less than end index."); PADDLE_ENFORCE_NE(dims_[0], 1, "Can not slice a tensor with dims_[0] = 1."); - int base = product(dims_) / dims_[0]; + size_t base = product(dims_) / dims_[0]; Tensor dst; dst.holder_ = holder_; DDim dst_dims = dims_; diff --git a/paddle/operators/gaussian_random_op.cc b/paddle/operators/gaussian_random_op.cc index 056447901d..583c9e5774 100644 --- a/paddle/operators/gaussian_random_op.cc +++ b/paddle/operators/gaussian_random_op.cc @@ -31,8 +31,8 @@ class CPUGaussianRandomKernel : public framework::OpKernel { } engine.seed(seed); std::normal_distribution dist(mean, std); - ssize_t size = framework::product(tensor->dims()); - for (ssize_t i = 0; i < size; ++i) { + int64_t size = framework::product(tensor->dims()); + for (int64_t i = 0; i < size; ++i) { data[i] = dist(engine); } } @@ -46,9 +46,13 @@ class GaussianRandomOp : public framework::OperatorWithKernel { void InferShape(const framework::InferShapeContext& context) const override { auto* tensor = context.Output("Out"); auto dims = GetAttr>("dims"); + std::vector temp(dims.size()); + for (auto dim : dims) { + temp.push_back(static_cast(dim)); + } PADDLE_ENFORCE(dims.size() > 0UL, "dims can be one int or array. dims must be set."); - tensor->Resize(framework::make_ddim(dims)); + tensor->Resize(framework::make_ddim(temp)); } }; diff --git a/paddle/operators/rnn/recurrent_op_utils.cc b/paddle/operators/rnn/recurrent_op_utils.cc index a9b65c30f2..69e723b401 100644 --- a/paddle/operators/rnn/recurrent_op_utils.cc +++ b/paddle/operators/rnn/recurrent_op_utils.cc @@ -61,7 +61,7 @@ void ConcatOutputs(const std::vector& step_scopes, PADDLE_ENFORCE(step_scope_var != nullptr, "%s not in scope", outlinks[i].internal); f::DDim step_dims = step_scope_var->template GetMutable()->dims(); - std::vector dims_vec = vectorize(step_dims); + std::vector dims_vec = vectorize(step_dims); dims_vec.insert(dims_vec.begin(), seq_len); output->Resize(f::make_ddim(dims_vec)); } else { diff --git a/paddle/operators/uniform_random_op.cc b/paddle/operators/uniform_random_op.cc index 2d943c4508..3241d4289a 100644 --- a/paddle/operators/uniform_random_op.cc +++ b/paddle/operators/uniform_random_op.cc @@ -35,8 +35,8 @@ class CPUUniformRandomKernel : public framework::OpKernel { std::uniform_real_distribution dist( static_cast(context.GetAttr("min")), static_cast(context.GetAttr("max"))); - ssize_t size = framework::product(tensor->dims()); - for (ssize_t i = 0; i < size; ++i) { + int64_t size = framework::product(tensor->dims()); + for (int64_t i = 0; i < size; ++i) { data[i] = dist(engine); } } @@ -52,7 +52,11 @@ class UniformRandomOp : public framework::OperatorWithKernel { "uniform_random's min must less then max"); auto* tensor = ctx.Output("Out"); auto dims = GetAttr>("dims"); - tensor->Resize(framework::make_ddim(dims)); + std::vector temp(dims.size()); + for (auto dim : dims) { + temp.push_back(static_cast(dim)); + } + tensor->Resize(framework::make_ddim(temp)); } }; diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc index 6896422617..7db629a68f 100644 --- a/paddle/pybind/pybind.cc +++ b/paddle/pybind/pybind.cc @@ -76,7 +76,7 @@ PYBIND11_PLUGIN(core) { .def("get_dims", [](const Tensor &self) { return vectorize(self.dims()); }) .def("set_dims", - [](Tensor &self, const std::vector &dim) { + [](Tensor &self, const std::vector &dim) { self.Resize(make_ddim(dim)); }) .def("alloc_float", diff --git a/paddle/pybind/tensor_py.h b/paddle/pybind/tensor_py.h index 39ba60b4dc..95171acf72 100644 --- a/paddle/pybind/tensor_py.h +++ b/paddle/pybind/tensor_py.h @@ -85,7 +85,7 @@ void PyCPUTensorSetFromArray( framework::Tensor &self, py::array_t array, paddle::platform::CPUPlace &place) { - std::vector dims; + std::vector dims; dims.reserve(array.ndim()); for (size_t i = 0; i < array.ndim(); ++i) { dims.push_back((int)array.shape()[i]); @@ -102,7 +102,7 @@ void PyCUDATensorSetFromArray( framework::Tensor &self, py::array_t array, paddle::platform::GPUPlace &place) { - std::vector dims; + std::vector dims; dims.reserve(array.ndim()); for (size_t i = 0; i < array.ndim(); ++i) { dims.push_back((int)array.shape()[i]); From 857cd24a35bef9c182292ca709fe1dd9d0e52e19 Mon Sep 17 00:00:00 2001 From: qijun Date: Wed, 6 Sep 2017 12:18:23 +0800 Subject: [PATCH 49/62] fix dim_test.cu bug --- paddle/framework/dim_test.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paddle/framework/dim_test.cu b/paddle/framework/dim_test.cu index f42b1eeadf..0a6a87669c 100644 --- a/paddle/framework/dim_test.cu +++ b/paddle/framework/dim_test.cu @@ -8,7 +8,7 @@ __global__ void test(paddle::framework::Dim<2>* o) { o[0] = paddle::framework::make_dim(5, 6); } -__global__ void dyn_idx_gpu(int* o) { +__global__ void dyn_idx_gpu(int64_t* o) { auto d = paddle::framework::make_dim(5, 6); o[0] = d[1]; } From a5f1e6d6bdd094253cd6f47bc7bbefb1fbc3b1e4 Mon Sep 17 00:00:00 2001 From: Xinghai Sun Date: Wed, 6 Sep 2017 12:58:00 +0800 Subject: [PATCH 50/62] Update cos_sim operator by following reviewer's comments. --- paddle/operators/cos_sim_op.cc | 4 +- paddle/operators/cos_sim_op.h | 97 ++++++++++--------- .../v2/framework/tests/test_cos_sim_op.py | 38 +++++--- 3 files changed, 76 insertions(+), 63 deletions(-) diff --git a/paddle/operators/cos_sim_op.cc b/paddle/operators/cos_sim_op.cc index 3760d0b161..c033af3b74 100644 --- a/paddle/operators/cos_sim_op.cc +++ b/paddle/operators/cos_sim_op.cc @@ -90,8 +90,8 @@ class CosSimOpGrad : public framework::OperatorWithKernel { auto *x_grad = ctx.Output(framework::GradVarName("X")); auto *y_grad = ctx.Output(framework::GradVarName("Y")); - x_grad->Resize(x_dims); - y_grad->Resize(y_dims); + if (x_grad) x_grad->Resize(x_dims); + if (y_grad) y_grad->Resize(y_dims); } }; diff --git a/paddle/operators/cos_sim_op.h b/paddle/operators/cos_sim_op.h index 69d35d8bc2..9e3ff26815 100644 --- a/paddle/operators/cos_sim_op.h +++ b/paddle/operators/cos_sim_op.h @@ -28,30 +28,30 @@ template class CosSimKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - auto* x = context.Input("X"); - auto* y = context.Input("Y"); - auto* z = context.Output("Out"); - auto* x_norm = context.Output("XNorm"); - auto* y_norm = context.Output("YNorm"); + auto* input_x = context.Input("X"); + auto* input_y = context.Input("Y"); + auto* output_z = context.Output("Out"); + auto* output_x_norm = context.Output("XNorm"); + auto* output_y_norm = context.Output("YNorm"); - z->mutable_data(context.GetPlace()); - x_norm->mutable_data(context.GetPlace()); - y_norm->mutable_data(context.GetPlace()); + output_z->mutable_data(context.GetPlace()); + output_x_norm->mutable_data(context.GetPlace()); + output_y_norm->mutable_data(context.GetPlace()); - auto dims = x->dims(); + auto dims = input_x->dims(); int size = static_cast(framework::product(dims)); auto new_dims = framework::make_ddim({dims[0], size / dims[0]}); - auto X = EigenMatrix::From(*x, new_dims); - auto Y = EigenMatrix::From(*y, new_dims); - auto Z = EigenMatrix::From(*z); - auto XNorm = EigenMatrix::From(*x_norm); - auto YNorm = EigenMatrix::From(*y_norm); + auto x = EigenMatrix::From(*input_x, new_dims); + auto y = EigenMatrix::From(*input_y, new_dims); + auto z = EigenMatrix::From(*output_z); + auto x_norm = EigenMatrix::From(*output_x_norm); + auto y_norm = EigenMatrix::From(*output_y_norm); auto place = context.GetEigenDevice(); - auto XY = (X * Y).sum(Eigen::array({1})); - XNorm.device(place) = (X * X).sum(Eigen::array({1})).sqrt(); - YNorm.device(place) = (Y * Y).sum(Eigen::array({1})).sqrt(); - Z.device(place) = XY / XNorm / YNorm; + auto xy = (x * y).sum(Eigen::array({1})); + x_norm.device(place) = x.square().sum(Eigen::array({1})).sqrt(); + y_norm.device(place) = y.square().sum(Eigen::array({1})).sqrt(); + z.device(place) = xy / x_norm / y_norm; } }; @@ -59,41 +59,44 @@ template class CosSimGradKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - auto* x = context.Input("X"); - auto* y = context.Input("Y"); - auto* z = context.Input("Out"); - auto* x_norm = context.Input("XNorm"); - auto* y_norm = context.Input("YNorm"); - auto* grad_x = context.Output(framework::GradVarName("X")); - auto* grad_y = context.Output(framework::GradVarName("Y")); - auto* grad_z = context.Input(framework::GradVarName("Out")); + auto* input_x = context.Input("X"); + auto* input_y = context.Input("Y"); + auto* input_z = context.Input("Out"); + auto* input_x_norm = context.Input("XNorm"); + auto* input_y_norm = context.Input("YNorm"); + auto* output_grad_x = context.Output(framework::GradVarName("X")); + auto* output_grad_y = context.Output(framework::GradVarName("Y")); + auto* input_grad_z = context.Input(framework::GradVarName("Out")); - grad_x->mutable_data(context.GetPlace()); - grad_y->mutable_data(context.GetPlace()); - - auto dims = x->dims(); + auto dims = input_x->dims(); int size = static_cast(framework::product(dims)); auto new_dims = framework::make_ddim({dims[0], size / dims[0]}); - auto X = EigenMatrix::From(*x, new_dims); - auto Y = EigenMatrix::From(*y, new_dims); - auto Z = EigenMatrix::From(*z); - auto X_norm = EigenMatrix::From(*x_norm); - auto Y_norm = EigenMatrix::From(*y_norm); - auto dX = EigenMatrix::From(*grad_x, new_dims); - auto dY = EigenMatrix::From(*grad_y, new_dims); - auto dZ = EigenMatrix::From(*grad_z); + auto x = EigenMatrix::From(*input_x, new_dims); + auto y = EigenMatrix::From(*input_y, new_dims); + auto z = EigenMatrix::From(*input_z); + auto x_norm = EigenMatrix::From(*input_x_norm); + auto y_norm = EigenMatrix::From(*input_y_norm); + auto dz = EigenMatrix::From(*input_grad_z); Eigen::DSizes bcast(1, new_dims[1]); - auto Z_bcast = Z.broadcast(bcast); - auto dZ_bcast = dZ.broadcast(bcast); + auto z_bcast = z.broadcast(bcast); + auto dz_bcast = dz.broadcast(bcast); auto place = context.GetEigenDevice(); - auto X_snorm_bcast = X_norm.square().eval().broadcast(bcast); - auto Y_snorm_bcast = Y_norm.square().eval().broadcast(bcast); - auto norm_prod_bcast = (X_norm * Y_norm).eval().broadcast(bcast); - dX.device(place) = - dZ_bcast * (Y / norm_prod_bcast - Z_bcast * X / X_snorm_bcast); - dY.device(place) = - dZ_bcast * (X / norm_prod_bcast - Z_bcast * Y / Y_snorm_bcast); + auto x_snorm_bcast = x_norm.square().eval().broadcast(bcast); + auto y_snorm_bcast = y_norm.square().eval().broadcast(bcast); + auto norm_prod_bcast = (x_norm * y_norm).eval().broadcast(bcast); + if (output_grad_x) { + output_grad_x->mutable_data(context.GetPlace()); + auto dx = EigenMatrix::From(*output_grad_x, new_dims); + dx.device(place) = + dz_bcast * (y / norm_prod_bcast - z_bcast * x / x_snorm_bcast); + } + if (output_grad_y) { + output_grad_y->mutable_data(context.GetPlace()); + auto dy = EigenMatrix::From(*output_grad_y, new_dims); + dy.device(place) = + dz_bcast * (x / norm_prod_bcast - z_bcast * y / y_snorm_bcast); + } } }; diff --git a/python/paddle/v2/framework/tests/test_cos_sim_op.py b/python/paddle/v2/framework/tests/test_cos_sim_op.py index a19be47f76..32013a7999 100644 --- a/python/paddle/v2/framework/tests/test_cos_sim_op.py +++ b/python/paddle/v2/framework/tests/test_cos_sim_op.py @@ -24,26 +24,36 @@ class TestCosSimOp(unittest.TestCase): } -class CosSimGradOpTest(GradientChecker): - def test_cos_sim_2d(self): - op = create_op("cos_sim") - inputs = { +class TestCosSimGradOp(GradientChecker): + def setUp(self): + self.op = create_op("cos_sim") + self.inputs = { 'X': np.random.random((10, 5)).astype("float32"), 'Y': np.random.random((10, 5)).astype("float32") } - self.compare_grad(op, inputs) + + def test_cpu_gpu_compare(self): + self.compare_grad(self.op, self.inputs) + + def test_normal(self): self.check_grad( - op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.05) + self.op, self.inputs, ["X", "Y"], "Out", max_relative_error=0.05) - def test_cos_sim_3d(self): - op = create_op("cos_sim") - inputs = { - 'X': np.random.random((10, 5, 2)).astype("float32"), - 'Y': np.random.random((10, 5, 2)).astype("float32") - } - self.compare_grad(op, inputs) + def test_ignore_x(self): + self.check_grad( + self.op, + self.inputs, ["Y"], + "Out", + max_relative_error=0.05, + no_grad_set={"X"}) + + def test_ignore_y(self): self.check_grad( - op, inputs, set(["X", "Y"]), "Out", max_relative_error=0.05) + self.op, + self.inputs, ["X"], + "Out", + max_relative_error=0.05, + no_grad_set={"Y"}) if __name__ == '__main__': From 9de6a4b375270f2e066147bfa92c84b84916ea56 Mon Sep 17 00:00:00 2001 From: Yu Yang Date: Tue, 5 Sep 2017 22:03:51 -0700 Subject: [PATCH 51/62] Change `Op::GetAttr` to `Op::Attr` Fix #3902 --- paddle/framework/op_registry_test.cc | 6 +++--- paddle/framework/operator.h | 6 +++--- paddle/operators/gaussian_random_op.cc | 8 ++++---- paddle/operators/gaussian_random_op.cu | 4 ++-- paddle/operators/rnn/recurrent_op_utils.cc | 8 ++++---- paddle/operators/scale_op.cc | 2 +- paddle/operators/scale_op.h | 2 +- paddle/operators/sgd_op.h | 2 +- paddle/operators/uniform_random_op.cc | 10 +++++----- paddle/operators/uniform_random_op.cu | 4 ++-- 10 files changed, 26 insertions(+), 26 deletions(-) diff --git a/paddle/framework/op_registry_test.cc b/paddle/framework/op_registry_test.cc index b43f6a8cc5..0e2fb27b65 100644 --- a/paddle/framework/op_registry_test.cc +++ b/paddle/framework/op_registry_test.cc @@ -80,7 +80,7 @@ TEST(OpRegistry, CreateOp) { paddle::framework::Scope scope; paddle::platform::CPUDeviceContext dev_ctx; op->Run(scope, dev_ctx); - float scale_get = op->GetAttr("scale"); + float scale_get = op->Attr("scale"); ASSERT_EQ(scale_get, scale); } @@ -121,7 +121,7 @@ TEST(OpRegistry, DefaultValue) { paddle::framework::Scope scope; paddle::platform::CPUDeviceContext dev_ctx; op->Run(scope, dev_ctx); - ASSERT_EQ(op->GetAttr("scale"), 1.0); + ASSERT_EQ(op->Attr("scale"), 1.0); } TEST(OpRegistry, CustomChecker) { @@ -172,6 +172,6 @@ TEST(OpRegistry, CustomChecker) { paddle::platform::CPUDeviceContext dev_ctx; paddle::framework::Scope scope; op->Run(scope, dev_ctx); - int test_attr = op->GetAttr("test_attr"); + int test_attr = op->Attr("test_attr"); ASSERT_EQ(test_attr, 4); } \ No newline at end of file diff --git a/paddle/framework/operator.h b/paddle/framework/operator.h index da92220b04..9a98d4d3be 100644 --- a/paddle/framework/operator.h +++ b/paddle/framework/operator.h @@ -69,7 +69,7 @@ class OperatorBase { virtual ~OperatorBase() {} template - inline const T& GetAttr(const std::string& name) const { + inline const T& Attr(const std::string& name) const { PADDLE_ENFORCE(attrs_.count(name) != 0, "%s should be in AttributeMap", name); return boost::get(attrs_.at(name)); @@ -238,8 +238,8 @@ class InferShapeContext { const Scope& scope() const { return scope_; } template - inline const T& GetAttr(const std::string& name) const { - return op_.GetAttr(name); + inline const T& Attr(const std::string& name) const { + return op_.Attr(name); } size_t InputSize(const std::string& name) const { diff --git a/paddle/operators/gaussian_random_op.cc b/paddle/operators/gaussian_random_op.cc index 056447901d..193b176c69 100644 --- a/paddle/operators/gaussian_random_op.cc +++ b/paddle/operators/gaussian_random_op.cc @@ -19,12 +19,12 @@ template class CPUGaussianRandomKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& context) const override { - float mean = context.GetAttr("mean"); - float std = context.GetAttr("std"); + float mean = context.Attr("mean"); + float std = context.Attr("std"); auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = static_cast(context.GetAttr("seed")); + unsigned int seed = static_cast(context.Attr("seed")); std::minstd_rand engine; if (seed == 0) { seed = std::random_device()(); @@ -45,7 +45,7 @@ class GaussianRandomOp : public framework::OperatorWithKernel { protected: void InferShape(const framework::InferShapeContext& context) const override { auto* tensor = context.Output("Out"); - auto dims = GetAttr>("dims"); + auto dims = Attr>("dims"); PADDLE_ENFORCE(dims.size() > 0UL, "dims can be one int or array. dims must be set."); tensor->Resize(framework::make_ddim(dims)); diff --git a/paddle/operators/gaussian_random_op.cu b/paddle/operators/gaussian_random_op.cu index 833a82bbf2..9788d89408 100644 --- a/paddle/operators/gaussian_random_op.cu +++ b/paddle/operators/gaussian_random_op.cu @@ -47,8 +47,8 @@ class GPUGaussianRandomKernel : public framework::OpKernel { std::random_device rd; seed = rd(); } - T mean = static_cast(context.GetAttr("mean")); - T std = static_cast(context.GetAttr("std")); + T mean = static_cast(context.Attr("mean")); + T std = static_cast(context.Attr("std")); thrust::counting_iterator index_sequence_begin(0); ssize_t N = framework::product(tensor->dims()); thrust::transform(index_sequence_begin, index_sequence_begin + N, diff --git a/paddle/operators/rnn/recurrent_op_utils.cc b/paddle/operators/rnn/recurrent_op_utils.cc index a9b65c30f2..ddc963faa5 100644 --- a/paddle/operators/rnn/recurrent_op_utils.cc +++ b/paddle/operators/rnn/recurrent_op_utils.cc @@ -109,7 +109,7 @@ void InitArgument(const ArgumentName& name, Argument* arg, arg->step_scopes = op.Output(name.step_scopes); auto inlinks = op.Inputs(name.inlinks); - auto inlink_alias = op.GetAttr>(name.inlink_alias); + auto inlink_alias = op.Attr>(name.inlink_alias); PADDLE_ENFORCE(inlinks.size() == inlink_alias.size(), "the size of inlinks and inlink_alias don't match:%d,%d", inlinks.size(), inlink_alias.size()); @@ -121,7 +121,7 @@ void InitArgument(const ArgumentName& name, Argument* arg, } auto outlinks = op.Outputs(name.outlinks); - auto outlink_alias = op.GetAttr>(name.outlink_alias); + auto outlink_alias = op.Attr>(name.outlink_alias); PADDLE_ENFORCE(outlinks.size() == outlink_alias.size(), "the size of outlinks and outlink_alias don't match:%d,%d", outlinks.size(), outlink_alias.size()); @@ -135,8 +135,8 @@ void InitArgument(const ArgumentName& name, Argument* arg, auto boot_memories = op.Inputs(name.boot_memories); // attributes - auto memories = op.GetAttr>(name.memories); - auto pre_memories = op.GetAttr>(name.pre_memories); + auto memories = op.Attr>(name.memories); + auto pre_memories = op.Attr>(name.pre_memories); PADDLE_ENFORCE(memories.size() == boot_memories.size(), "the size of memories, boot_memories don't match:%d,%d", diff --git a/paddle/operators/scale_op.cc b/paddle/operators/scale_op.cc index 8e96a74c94..8d65e2754c 100644 --- a/paddle/operators/scale_op.cc +++ b/paddle/operators/scale_op.cc @@ -60,7 +60,7 @@ class ScaleGradOp : public NetOp { AppendOp(framework::OpRegistry::CreateOp( "scale", {{"X", {Input(framework::GradVarName("Out"))}}}, {{"Out", {Output(framework::GradVarName("X"))}}}, - {{"scale", GetAttr("scale")}})); + {{"scale", Attr("scale")}})); CompleteAddOp(false); } }; diff --git a/paddle/operators/scale_op.h b/paddle/operators/scale_op.h index 65fb77eefa..02fbdc52bb 100644 --- a/paddle/operators/scale_op.h +++ b/paddle/operators/scale_op.h @@ -27,7 +27,7 @@ class ScaleKernel : public framework::OpKernel { auto* in = context.Input("X"); tensor->mutable_data(in->place()); - auto scale = static_cast(context.GetAttr("scale")); + auto scale = static_cast(context.Attr("scale")); auto eigen_out = framework::EigenVector::Flatten(*tensor); auto eigen_in = framework::EigenVector::Flatten(*in); diff --git a/paddle/operators/sgd_op.h b/paddle/operators/sgd_op.h index 8422b622ee..f8888f9c36 100644 --- a/paddle/operators/sgd_op.h +++ b/paddle/operators/sgd_op.h @@ -31,7 +31,7 @@ class SGDOpKernel : public framework::OpKernel { auto param = ctx.Input("param"); auto grad = ctx.Input("grad"); auto param_out = ctx.Output("param_out"); - float lr = ctx.GetAttr("learning_rate"); + float lr = ctx.Attr("learning_rate"); param_out->mutable_data(ctx.GetPlace()); diff --git a/paddle/operators/uniform_random_op.cc b/paddle/operators/uniform_random_op.cc index 2d943c4508..8dbc8b064c 100644 --- a/paddle/operators/uniform_random_op.cc +++ b/paddle/operators/uniform_random_op.cc @@ -26,15 +26,15 @@ class CPUUniformRandomKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext& context) const override { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = static_cast(context.GetAttr("seed")); + unsigned int seed = static_cast(context.Attr("seed")); std::minstd_rand engine; if (seed == 0) { seed = std::random_device()(); } engine.seed(seed); std::uniform_real_distribution dist( - static_cast(context.GetAttr("min")), - static_cast(context.GetAttr("max"))); + static_cast(context.Attr("min")), + static_cast(context.Attr("max"))); ssize_t size = framework::product(tensor->dims()); for (ssize_t i = 0; i < size; ++i) { data[i] = dist(engine); @@ -48,10 +48,10 @@ class UniformRandomOp : public framework::OperatorWithKernel { protected: void InferShape(const framework::InferShapeContext& ctx) const override { - PADDLE_ENFORCE(GetAttr("min") < GetAttr("max"), + PADDLE_ENFORCE(Attr("min") < Attr("max"), "uniform_random's min must less then max"); auto* tensor = ctx.Output("Out"); - auto dims = GetAttr>("dims"); + auto dims = Attr>("dims"); tensor->Resize(framework::make_ddim(dims)); } }; diff --git a/paddle/operators/uniform_random_op.cu b/paddle/operators/uniform_random_op.cu index df993c0779..fc6f856fa3 100644 --- a/paddle/operators/uniform_random_op.cu +++ b/paddle/operators/uniform_random_op.cu @@ -50,8 +50,8 @@ class GPUUniformRandomKernel : public framework::OpKernel { std::random_device rd; seed = rd(); } - T min = static_cast(context.GetAttr("min")); - T max = static_cast(context.GetAttr("max")); + T min = static_cast(context.Attr("min")); + T max = static_cast(context.Attr("max")); thrust::counting_iterator index_sequence_begin(0); ssize_t N = framework::product(tensor->dims()); thrust::transform(index_sequence_begin, index_sequence_begin + N, From 52f2bc1f9d84a05f1c73428124a1235fb141f193 Mon Sep 17 00:00:00 2001 From: qijun Date: Wed, 6 Sep 2017 13:34:01 +0800 Subject: [PATCH 52/62] fix vector size error --- paddle/operators/gaussian_random_op.cc | 3 ++- paddle/operators/uniform_random_op.cc | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/paddle/operators/gaussian_random_op.cc b/paddle/operators/gaussian_random_op.cc index 583c9e5774..8bb61275ba 100644 --- a/paddle/operators/gaussian_random_op.cc +++ b/paddle/operators/gaussian_random_op.cc @@ -46,7 +46,8 @@ class GaussianRandomOp : public framework::OperatorWithKernel { void InferShape(const framework::InferShapeContext& context) const override { auto* tensor = context.Output("Out"); auto dims = GetAttr>("dims"); - std::vector temp(dims.size()); + std::vector temp; + temp.reserve(dims.size()); for (auto dim : dims) { temp.push_back(static_cast(dim)); } diff --git a/paddle/operators/uniform_random_op.cc b/paddle/operators/uniform_random_op.cc index 3241d4289a..40cef8942a 100644 --- a/paddle/operators/uniform_random_op.cc +++ b/paddle/operators/uniform_random_op.cc @@ -52,7 +52,8 @@ class UniformRandomOp : public framework::OperatorWithKernel { "uniform_random's min must less then max"); auto* tensor = ctx.Output("Out"); auto dims = GetAttr>("dims"); - std::vector temp(dims.size()); + std::vector temp; + temp.reserve(dims.size()); for (auto dim : dims) { temp.push_back(static_cast(dim)); } From 1e419d9ed3610c95b518982a026666ea3f699f27 Mon Sep 17 00:00:00 2001 From: qijun Date: Wed, 6 Sep 2017 17:24:47 +0800 Subject: [PATCH 53/62] fix clang build and run error --- paddle/operators/cos_sim_op.h | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/paddle/operators/cos_sim_op.h b/paddle/operators/cos_sim_op.h index 9e3ff26815..9e2bcebe3b 100644 --- a/paddle/operators/cos_sim_op.h +++ b/paddle/operators/cos_sim_op.h @@ -23,6 +23,9 @@ using Tensor = framework::Tensor; template using EigenMatrix = framework::EigenMatrix; +template +using EigenVector = framework::EigenVector; template class CosSimKernel : public framework::OpKernel { @@ -43,14 +46,14 @@ class CosSimKernel : public framework::OpKernel { auto new_dims = framework::make_ddim({dims[0], size / dims[0]}); auto x = EigenMatrix::From(*input_x, new_dims); auto y = EigenMatrix::From(*input_y, new_dims); - auto z = EigenMatrix::From(*output_z); - auto x_norm = EigenMatrix::From(*output_x_norm); - auto y_norm = EigenMatrix::From(*output_y_norm); + auto z = EigenVector::Flatten(*output_z); + auto x_norm = EigenVector::Flatten(*output_x_norm); + auto y_norm = EigenVector::Flatten(*output_y_norm); auto place = context.GetEigenDevice(); - auto xy = (x * y).sum(Eigen::array({1})); - x_norm.device(place) = x.square().sum(Eigen::array({1})).sqrt(); - y_norm.device(place) = y.square().sum(Eigen::array({1})).sqrt(); + auto xy = (x * y).sum(Eigen::array({{1}})); + x_norm.device(place) = x.square().sum(Eigen::array({{1}})).sqrt(); + y_norm.device(place) = y.square().sum(Eigen::array({{1}})).sqrt(); z.device(place) = xy / x_norm / y_norm; } }; From a377b4197cf7e5f3b7f8edb271eb67039ede16eb Mon Sep 17 00:00:00 2001 From: yangyaming Date: Wed, 6 Sep 2017 17:41:03 +0800 Subject: [PATCH 54/62] Follow GLOG enforcing style. --- paddle/operators/squared_l2_distance_op.cc | 3 +-- paddle/operators/squared_l2_distance_op.h | 6 +++--- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/paddle/operators/squared_l2_distance_op.cc b/paddle/operators/squared_l2_distance_op.cc index 694b00e493..dc30644a5e 100644 --- a/paddle/operators/squared_l2_distance_op.cc +++ b/paddle/operators/squared_l2_distance_op.cc @@ -40,7 +40,7 @@ class SquaredL2DistanceOp : public framework::OperatorWithKernel { "inputs must be same."); int rank = framework::arity(x_dims); - PADDLE_ENFORCE(rank >= 2, "Tensor rank should be at least equal to 2."); + PADDLE_ENFORCE_GE(rank, 2, "Tensor rank should be at least equal to 2."); PADDLE_ENFORCE_EQ(framework::product(x_dims) / x_dims[0], framework::product(y_dims) / y_dims[0], "Product of dimensions expcet the first dimension of " @@ -87,7 +87,6 @@ class SquaredL2DistanceGradOp : public framework::OperatorWithKernel { void InferShape(const framework::InferShapeContext& ctx) const override { PADDLE_ENFORCE_NOT_NULL(ctx.InputVar(framework::GradVarName("Out")), "Gradient of Out should not be null"); - // check out grad dimensions auto out_dims = ctx.Input(framework::GradVarName("Out"))->dims(); auto x_dims = ctx.Input("X")->dims(); auto y_dims = ctx.Input("Y")->dims(); diff --git a/paddle/operators/squared_l2_distance_op.h b/paddle/operators/squared_l2_distance_op.h index 1015513bdf..77c5a0a5c9 100644 --- a/paddle/operators/squared_l2_distance_op.h +++ b/paddle/operators/squared_l2_distance_op.h @@ -101,9 +101,9 @@ class SquaredL2DistanceGradKernel : public framework::OpKernel { auto y_grad = EigenMatrix::From(*y_g, framework::make_ddim({y_dims[0], cols})); - PADDLE_ENFORCE(sub_result.dimensions()[0] >= y_dims[0], - "First dimension of gradient must be greater or " - "equal than first dimension of target"); + PADDLE_ENFORCE_GE(sub_result.dimensions()[0], y_dims[0], + "First dimension of gradient must be greater or " + "equal than first dimension of target."); if (sub_result.dimensions()[0] == y_dims[0]) { y_grad.device(eigen_place) = -1 * grad_mat; From 4373a4a74d0d30c2980752b10e7bce336d434f74 Mon Sep 17 00:00:00 2001 From: chengduoZH Date: Wed, 6 Sep 2017 18:24:08 +0800 Subject: [PATCH 55/62] fix redeclaration of 'paddle::StatPtr __stat' --- paddle/gserver/layers/Conv3DLayer.cpp | 6 ++---- paddle/gserver/layers/DeConv3DLayer.cpp | 6 ++---- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/paddle/gserver/layers/Conv3DLayer.cpp b/paddle/gserver/layers/Conv3DLayer.cpp index 3887aa58b2..9deda2de98 100644 --- a/paddle/gserver/layers/Conv3DLayer.cpp +++ b/paddle/gserver/layers/Conv3DLayer.cpp @@ -83,8 +83,8 @@ void Conv3DLayer::forward(PassType passType) { int outWidth = getSize(); resetOutput(batchSize, outWidth); + REGISTER_TIMER_INFO("FwdConv3D", getName().c_str()); for (size_t i = 0; i != inputLayers_.size(); ++i) { - REGISTER_TIMER_INFO("FwdConv3D", getName().c_str()); const MatrixPtr &inMat = getInputValue(i); const MatrixPtr &outMat = getOutputValue(); int M = M_[i]; @@ -120,7 +120,6 @@ void Conv3DLayer::forward(PassType passType) { } } if (nullptr != this->biasParameter_) { - REGISTER_TIMER_INFO("FwBiasTimer", getName().c_str()); this->addBias(); } forwardActivation(); @@ -134,15 +133,14 @@ void Conv3DLayer::backward(const UpdateCallback &callback) { biases_->getParameterPtr()->incUpdate(callback); } + REGISTER_TIMER_INFO("BwdConv3D", getName().c_str()); for (size_t i = 0; i != inputLayers_.size(); ++i) { - REGISTER_TIMER_INFO("BwdConv3D", getName().c_str()); if (weights_[i]->getWGrad()) { bpropWeights(i); } if (getInputGrad(i)) { bpropData(i); } - REGISTER_TIMER_INFO("WeightUpdate", getName().c_str()); weights_[i]->getParameterPtr()->incUpdate(callback); } } diff --git a/paddle/gserver/layers/DeConv3DLayer.cpp b/paddle/gserver/layers/DeConv3DLayer.cpp index 2838980a97..1b59ed60c5 100644 --- a/paddle/gserver/layers/DeConv3DLayer.cpp +++ b/paddle/gserver/layers/DeConv3DLayer.cpp @@ -84,8 +84,8 @@ void DeConv3DLayer::forward(PassType passType) { resetOutput(batchSize, outWidth); const MatrixPtr outMat = getOutputValue(); + REGISTER_TIMER_INFO("FwdDeConv3D", getName().c_str()); for (size_t i = 0; i != inputLayers_.size(); ++i) { - REGISTER_TIMER_INFO("FwdDeConv3D", getName().c_str()); const MatrixPtr &inMat = getInputValue(i); int M = M_[i]; int N = N_[i]; @@ -120,7 +120,6 @@ void DeConv3DLayer::forward(PassType passType) { } } if (nullptr != this->biasParameter_) { - REGISTER_TIMER_INFO("FwBiasTimer", getName().c_str()); this->addBias(); } forwardActivation(); @@ -133,12 +132,12 @@ void DeConv3DLayer::backward(const UpdateCallback &callback) { bpropBiases(); biases_->getParameterPtr()->incUpdate(callback); } + REGISTER_TIMER_INFO("BwdDeConv3D", getName().c_str()); for (size_t i = 0; i < inputLayers_.size(); ++i) { if (weights_[i]->getWGrad() || this->needGradient_) { int M = M_[i]; int N = N_[i]; int K = K_[i]; - REGISTER_TIMER_INFO("BwdDeConv3D", getName().c_str()); Matrix::resizeOrCreate(colBuf_, K * groups_[i], N, false, useGpu_); const MatrixPtr &inMat = getInputValue(i); for (int n = 0; n < batchSize; ++n) { @@ -182,7 +181,6 @@ void DeConv3DLayer::backward(const UpdateCallback &callback) { } } } - REGISTER_TIMER_INFO("WeightUpdate", getName().c_str()); weights_[i]->getParameterPtr()->incUpdate(callback); } } From 57f9723d36f1740bc306a8e5022ac3cf01595c2f Mon Sep 17 00:00:00 2001 From: yangyaming Date: Wed, 6 Sep 2017 18:43:33 +0800 Subject: [PATCH 56/62] Using EigenVector to replace EigenMatrix for some variables. --- paddle/operators/squared_l2_distance_op.h | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/paddle/operators/squared_l2_distance_op.h b/paddle/operators/squared_l2_distance_op.h index 77c5a0a5c9..ad3347a0b3 100644 --- a/paddle/operators/squared_l2_distance_op.h +++ b/paddle/operators/squared_l2_distance_op.h @@ -20,6 +20,9 @@ namespace paddle { namespace operators { using Tensor = framework::Tensor; +template +using EigenVector = framework::EigenVector; template using EigenMatrix = framework::EigenMatrix; @@ -46,7 +49,7 @@ class SquaredL2DistanceKernel : public framework::OpKernel { out0->mutable_data(context.GetPlace()); out1->mutable_data(context.GetPlace()); auto sub_result = EigenMatrix::From(*out0); - auto z = EigenMatrix::From(*out1); + auto z = EigenVector::Flatten(*out1); auto place = context.GetEigenDevice(); auto x_dims = x.dimensions(); @@ -55,13 +58,12 @@ class SquaredL2DistanceKernel : public framework::OpKernel { if (y_dims[0] == 1 && x_dims[0] > y_dims[0]) { sub_result.device(place) = x - - y.broadcast(Eigen::array({static_cast(x_dims[0]), 1})); + y.broadcast(Eigen::array({{static_cast(x_dims[0]), 1}})); } else { sub_result.device(place) = x - y; } auto sub_res_pow2 = sub_result * sub_result; - // z is TensorMap, no need reshape - z.device(place) = sub_res_pow2.sum(Eigen::array({1})); + z.device(place) = sub_res_pow2.sum(Eigen::array({{1}})); } }; @@ -82,8 +84,9 @@ class SquaredL2DistanceGradKernel : public framework::OpKernel { int cols = framework::product(x_dims) / x_dims[0]; // calculate gradient - auto grad_mat = - 2 * (out_grad.broadcast(Eigen::array({1, cols}))) * sub_result; + auto grad_mat = 2 * + (out_grad.broadcast(Eigen::array({{1, cols}}))) * + sub_result; // propagate back to input auto eigen_place = context.GetEigenDevice(); @@ -98,18 +101,18 @@ class SquaredL2DistanceGradKernel : public framework::OpKernel { if (y_g) { y_g->mutable_data(context.GetPlace()); - auto y_grad = - EigenMatrix::From(*y_g, framework::make_ddim({y_dims[0], cols})); PADDLE_ENFORCE_GE(sub_result.dimensions()[0], y_dims[0], "First dimension of gradient must be greater or " "equal than first dimension of target."); if (sub_result.dimensions()[0] == y_dims[0]) { + auto y_grad = + EigenMatrix::From(*y_g, framework::make_ddim({y_dims[0], cols})); y_grad.device(eigen_place) = -1 * grad_mat; } else { - auto col_sum_res = -1 * (grad_mat.sum(Eigen::array({0}))); - // y_grad is TensorMap, no need reshape + auto col_sum_res = -1 * (grad_mat.sum(Eigen::array({{0}}))); + auto y_grad = EigenVector::Flatten(*y_g); y_grad.device(eigen_place) = col_sum_res; } } From db5e726d160789f05fb8323c6915991e5a276339 Mon Sep 17 00:00:00 2001 From: caoying03 Date: Wed, 6 Sep 2017 18:14:27 +0800 Subject: [PATCH 57/62] update the how to write op doc. --- doc/howto/dev/new_op_cn.md | 183 +++++++++++++++++++++---------------- 1 file changed, 102 insertions(+), 81 deletions(-) diff --git a/doc/howto/dev/new_op_cn.md b/doc/howto/dev/new_op_cn.md index 0d29865447..58665e9f2b 100644 --- a/doc/howto/dev/new_op_cn.md +++ b/doc/howto/dev/new_op_cn.md @@ -45,7 +45,9 @@ Kernel实现 | CPU、GPU共享Kernel实现在`.h`文件中，否则，CPU ### 1. 定义ProtoMaker类 -矩阵乘的公式：$Out = X * Y$, 可见该计算由两个输入，一个输出组成。首先定义`ProtoMaker`来描述该Op的输入、输出及注释： +矩阵乘法的公式：$Out = X * Y$, 可见该计算由两个输入，一个输出组成。 + +首先定义`ProtoMaker`来描述该Op的输入、输出，并添加注释： ```cpp class MulOpMaker : public framework::OpProtoAndCheckerMaker { @@ -63,17 +65,17 @@ The equation is: Out = X * Y }; ``` -[`MulOpMaker`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc#L43)继承自`framework::OpProtoAndCheckerMaker`，构造函数包括2个参数： +[`MulOpMaker`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/mul_op.cc#L43)继承自`framework::OpProtoAndCheckerMaker`，构造函数含有2个参数： - `framework::OpProto` ： 前者存储Op的输入输出和参数属性，将用于Python API接口的生成。 - `framework::OpAttrChecker` ：后者用于检查参数属性的合法性。 -构造函数里通过`AddInput`添加输入参数，通过`AddOutput`添加输出参数，通过`AddComment`添加该Op的注释，这些函数会将对应内容添加到`OpProto`中。 +构造函数里通过`AddInput`添加输入参数，通过`AddOutput`添加输出参数，通过`AddComment`添加Op的注释。这些函数会将对应内容添加到`OpProto`中。 -在`MulOp`中添加两个输入`X`和`Y`，添加了一个输出`Out`，并解释了各自含义，命名请遵守命名规范。 +上面的代码在`MulOp`中添加两个输入`X`和`Y`，添加了一个输出`Out`，并解释了各自含义，命名请遵守命名规范。 -再举个[`ScaleOp`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/scale_op.cc#L37)的例子： +再以[`ScaleOp`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/scale_op.cc#L37)为例： ```cpp template @@ -91,14 +93,16 @@ The equation is: Out = scale*X }; ``` - 这个例子有两处不同： +这个例子有两处不同： + +- `AddInput("X","...").NotInGradient()` : 表示`X`这个输入不参与`ScaleOp`对应的梯度Op计算之中，如果Op的某个输入不参与反向梯度的计算，请显示地调用`.NotInGradient()`进行设置。 - - `AddInput("X","...").NotInGradient()` : 表示`X`这个输入不参与`ScaleOp`对应的梯度Op计算之中。 - - `AddAttr("scale", "...").SetDefault(1.0);` : 增加`scale`系数，作为参数属性，并且设置默认值为1.0。 +- `AddAttr("scale", "...").SetDefault(1.0);` : 增加`scale`系数，作为参数属性，并且设置默认值为1.0。 ### 2. 定义Operator类 +下面的点实现了MulOp的定义： ```cpp class MulOp : public framework::OperatorWithKernel { @@ -143,14 +147,27 @@ MulOp(const std::string &type, const framework::VariableNameMap &inputs, - 1). 做检查， 尽早报错：检查输入数据维度、类型等是否合法。 - 2). 设置输出Tensor的形状。 -通常`OpProtoMaker`和`Op`类的定义写在`.cc`文件中，和要讲到的注册函数一起放在`.cc`中 +通常`OpProtoMaker`和`Op`类的定义写在`.cc`文件中，和下面将要介绍的注册函数一起放在`.cc`中 ### 3. 定义OpKernel类 -```cpp -template -class MulKernel : public framework::OpKernel { - public: +`MulKernel`继承自`framework::OpKernel`，带有下面两个模板参数: + +- `typename Place`: 表示设备类型，不同设备(CPU、GPU)共享同一个Kernel时，需加该模板参数，不共享则不加，一个不共享的例子是[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 + +- `typename T` : 表示数据类型，如`float`, `double`等。 + +需要为`MulKernel`类重写`Compute`接口。 +- `Compute`接受一个输入参数：`const framework::ExecutionContext& context`。 +- 与`InferShapeContext`相比，`ExecutionContext`增加了设备类型，同样可获取到输入输出和属性参数。 +- `Compute`函数里实现`OpKernel`的具体计算逻辑。 + +下面是 `MulKernel` `Compute`的实现： + + ```cpp + template + class MulKernel : public framework::OpKernel { + public: void Compute(const framework::ExecutionContext& context) const override { auto* X = context.Input("X"); auto* Y = context.Input("Y"); @@ -160,50 +177,50 @@ class MulKernel : public framework::OpKernel { const_cast(context.device_context_); math::matmul(*X, false, *Y, false, 1, Z, 0, device_context); } -}; -``` + }; + ``` -`MulKernel`继承自`framework::OpKernel`，带有模板参数: +需要注意：**不同设备(CPU、GPU)共享一个Op定义，是否则共享同一个`OpKernel`，取决于`Compute`调用的函数是否支持不同设备。** - - `typename Place`: 表示设备类型，不同设备(CPU、GPU)共享同一个Kernel时，需加该模板参数，不共享则不加，一个不共享的例子是[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 +`MulOp`的CPU、GPU实现共享同一个`Kernel`。`OpKernel`不共享的例子可以参考：[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 - - `typename T` : 表示数据类型，如`float`, `double`等。 +为了使`OpKernel`的计算过程书写更加简单，并且CPU、GPU的代码可以复用，我们通常借助 Eigen unsupported Tensor模块来实现`Compute`接口。关于在PaddlePaddle中如何使用Eigen库，请参考[使用文档](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/howto/dev/use_eigen_cn.md)。 -`MulKernel`需要重写`Compute`接口，该接口参数为`const framework::ExecutionContext& context`, `ExecutionContext`相比`InferShapeContext`增加了设备类型，同样可获取到输入输出和属性参数，`Compute`函数里写具体实现时。 -注意，不同设备(CPU、GPU)共享一个Op定义，是否则共享同一个`OpKernel`，取决于`Compute`调用的函数是否支持不同设备。`MulOp`的CPU、GPU实现共享同一个`Kernel`，`OpKernel`不共享的例子可以参考[`OnehotCrossEntropyOpKernel`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/operators/cross_entropy_op.h#L43)。 +到此，前向Op实现完成。接下来，需要在`.cc`文件中注册该op和kernel。 +反向Op类的定义，反向OpKernel的定义与前向Op类似，这里不再赘述。**但需注意反向Op没有`ProtoMaker`**。 -为了使得`OpKernel`的计算过程书写较为简单，CPU、GPU的代码可以复用，我们通常借助Eigen unsupported Tensor模块来实现。关于在paddle中如何使用Eigen库，请参考对应的使用[文档](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/howto/dev/use_eigen_cn.md) +### 4. 注册Operator -到此前向Op实现完成，需要在`.cc`文件中注册该op和kernel。反向Op类的定义和Kernel定义与前向Op类似，这里不再重复。但注意，反向Op没有`ProtoMaker`。 +- 在`.cc`文件中注册前向、反向Op类，注册CPU Kernel。 -### 4. 注册Operator + ```cpp + namespace ops = paddle::operators; + REGISTER_OP(mul, ops::MulOp, ops::MulOpMaker, mul_grad, ops::MulOpGrad); + REGISTER_OP_CPU_KERNEL(mul, ops::MulKernel); + REGISTER_OP_CPU_KERNEL(mul_grad, + ops::MulGradKernel); + ``` -在`.cc`文件中注册前向、反向Op类，注册CPU Kernel。 + 在上面的代码中： -```cpp -namespace ops = paddle::operators; -REGISTER_OP(mul, ops::MulOp, ops::MulOpMaker, mul_grad, ops::MulOpGrad); -REGISTER_OP_CPU_KERNEL(mul, ops::MulKernel); -REGISTER_OP_CPU_KERNEL(mul_grad, - ops::MulGradKernel); -``` + - `REGISTER_OP` ： 注册`ops::MulOp`类，类型名为`mul`，该类的`ProtoMaker`为`ops::MulOpMaker`，注册`ops::MulOpGrad`，类型名为`mul_grad`。 + - `REGISTER_OP_WITHOUT_GRADIENT` ： 用于注册没有反向的Op。 + - `REGISTER_OP_CPU_KERNEL` ：注册`ops::MulKernel`类，并特化模板参数为`paddle::platform::CPUPlace`和`float`类型，同理，注册`ops::MulKernel`类。 - - `REGISTER_OP` ： 注册`ops::MulOp`类，类型名为`mul`，该类的`ProtoMaker`为`ops::MulOpMaker`，注册`ops::MulOpGrad`，类型名为`mul_grad`， - - `REGISTER_OP_WITHOUT_GRADIENT` ： 用于注册没有反向的Op。 - - `REGISTER_OP_CPU_KERNEL` ：注册`ops::MulKernel`类，并特化模板参数为`paddle::platform::CPUPlace`和`float`类型，同理，注册`ops::MulKernel`类。 -在 `.cu`文件中注册GPU Kernel。请注意，如果GPU Kernel的实现是基于Eigen unsupported模块，那么在 `.cu`的最前面请加上宏定义 `#define EIGEN_USE_GPU` +- 在 `.cu`文件中注册GPU Kernel。 + - 请注意，如果GPU Kernel的实现基于Eigen unsupported模块，那么在 `.cu`的开始请加上宏定义 `#define EIGEN_USE_GPU`，代码示例如下： -```cpp -// if use Eigen unsupported module before include head files -#define EIGEN_USE_GPU + ```cpp + // if use Eigen unsupported module before include head files + #define EIGEN_USE_GPU -namespace ops = paddle::operators; -REGISTER_OP_GPU_KERNEL(mul, ops::MulKernel); -REGISTER_OP_GPU_KERNEL(mul_grad, - ops::MulGradKernel); -``` + namespace ops = paddle::operators; + REGISTER_OP_GPU_KERNEL(mul, ops::MulKernel); + REGISTER_OP_GPU_KERNEL(mul_grad, + ops::MulGradKernel); + ``` ### 5. 编译 @@ -225,7 +242,7 @@ REGISTER_OP_GPU_KERNEL(mul_grad, - 绑定Python 在 [`paddle/pybind/pybind.cc -`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/pybind.cc)文件中添加该类： +`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/pybind.cc) 使用`USE_OP`告知编译器需要链接的Op，具体解释参考[代码注释](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/op_registry.h#L81)。 ``` USE_OP(mul); @@ -242,50 +259,54 @@ REGISTER_OP_GPU_KERNEL(mul_grad, USE_NO_KENREL_OP(recurrent); ``` - 使用`USE_OP`告知编译器需要链接该Op的目标文件，具体解释参考[代码注释](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/op_registry.h#L81)。 - - 生成库 - 无需修改 [`paddle/pybind/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/CMakeLists.txt)文件，`paddle/operators` 目录下新增的 `*_op.cc` 文件会自动被添加链接到生成的lib库中。 + 无需修改 [`paddle/pybind/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/pybind/CMakeLists.txt)文件，`paddle/operators` 目录下新增的 `*_op.cc` 文件会被自动添加链接到生成的lib库中。 ## 实现单元测试 -单测包括对比前向Op不同设备(CPU、GPU)的实现、对比反向OP不同设备(CPU、GPU)的实现、反向Op的梯度测试。下面介绍介绍[`MulOp`的单测](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/test_mul_op.py)。 +单测包括对比前向Op不同设备(CPU、GPU)的实现、对比反向OP不同设备(CPU、GPU)的实现、反向Op的梯度测试。下面介绍介绍[`MulOp`的单元测试](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/test_mul_op.py)。 ### 前向Operator单元测试 -前向Op单测继承自`unittest.TestCase`，并定义元类`__metaclass__ = OpTestMeta`，具体单测流程在`OpTestMeta`里完成。需在`setUp`函数定义输入输出和属性参数，以及Python对比的输出值。 +前向Op单元测试继承自`unittest.TestCase`，并定义元类`__metaclass__ = OpTestMeta`。各项更加具体的单元测试在`OpTestMeta`里完成。测试前向Operator，需要： -```python -import unittest -import numpy as np -from gradient_checker import GradientChecker, create_op -from op_test_util import OpTestMeta +1. 在`setUp`函数定义输入、输出，以及相关的属性参数。 +2. 生成随机的输入数据。 +3. 在Python脚本中实现与前向operator相同的计算逻辑，得到输出值，与operator前向计算的输出进行对比。 -class TestMulOp(unittest.TestCase): - __metaclass__ = OpTestMeta - def setUp(self): - self.type = "mul" - self.inputs = { - 'X': np.random.random((32, 84)).astype("float32"), - 'Y': np.random.random((84, 100)).astype("float32") - } - self.outputs = {'Out': np.dot(self.inputs['X'], self.inputs['Y'])} -``` - 首先需要`import`必要的包,下面详细解释其他值： + ```python + import unittest + import numpy as np + from gradient_checker import GradientChecker, create_op + from op_test_util import OpTestMeta + + class TestMulOp(unittest.TestCase): + __metaclass__ = OpTestMeta - - `self.type = "mul" ` : 定义类型，和注册的类型一致。 - - `self.inputs` : 定义输入，类型为Numpy.array，并初始化。 - - `self.outputs` : 定义输出，并得到Python结算结果。 + def setUp(self): + self.type = "mul" + self.inputs = { + 'X': np.random.random((32, 84)).astype("float32"), + 'Y': np.random.random((84, 100)).astype("float32") + } + self.outputs = {'Out': np.dot(self.inputs['X'], self.inputs['Y'])} + ``` + +上面的代码首先导入依赖的包，下面是对`setUp`函数中操作的重要变量的详细解释： + +- `self.type = "mul" ` : 定义类型，与operator注册时注册的类型一致。 +- `self.inputs` : 定义输入，类型为`numpy.array`，并初始化。 +- `self.outputs` : 定义输出，并在Python脚本中完成与operator同样的计算逻辑，返回Python端的计算结果。 ### 反向Operator单元测试 -反向Op单测继承自`GradientChecker`，而`GradientChecker`集成自`unittest.TestCase`，所以反向单测函数需要`test_`开头。 +反向Op单元测试继承自`GradientChecker`，而`GradientChecker`继承自`unittest.TestCase`，因此，**反向单元测试函数需要以`test_`开头**。 -```cpp +```python class TestMulGradOp(GradientChecker): def setUp(self): self.op = create_op("mul") @@ -319,27 +340,27 @@ class TestMulGradOp(GradientChecker): no_grad_set={"Y"}) ``` -下面解释一些关键的地方: +下面解释代码中一些关键的地方: - - 调用`create_op("mul")`创建反向Op对应的前向Op。 - - 调用`compare_grad`函数对比CPU、GPU计算结果。 - - `test_normal`中调用`check_grad`检查梯度稳定性，这里采用数值法检测梯度正确性。 - - 第一个参数`self.op` : 前向Op。 - - 第二个参数`self.inputs` : 输入词典，词典的Key和`ProtoMaker`定义保持一致。 - - 第三个参数`["X", "Y"]` : 指定对输入变量`X`、`Y`做梯度检测。 - - 第四个参数`"Out"` : 指定前向网络最终的输出目标变量`Out` - - `test_ignore_x`和`test_ignore_y`分支测试只需要计算一个输入梯度的情况。 +- 调用`create_op("mul")`创建反向Op对应的前向Op。 +- 调用`compare_grad`函数对比CPU、GPU计算结果。 +- `test_normal`中调用`check_grad`使用数值法检测梯度正确性和稳定性。 + - 第一个参数`self.op` : 前向Op。 + - 第二个参数`self.inputs` : 输入词典，词典的Key和`ProtoMaker`定义保持一致。 + - 第三个参数`["X", "Y"]` : 指定对输入变量`X`、`Y`做梯度检测。 + - 第四个参数`"Out"` : 指定前向网络最终的输出目标变量`Out` +- `test_ignore_x`和`test_ignore_y`分支用来测试只需要计算一个输入梯度的情况。 ### 编译和执行单元测试 -单测完成之后，在[`python/paddle/v2/framework/tests/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/CMakeLists.txt)里添加以下内容将单测加入工程中： +单元测试编写完成之后，在[`python/paddle/v2/framework/tests/CMakeLists.txt`](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/tests/CMakeLists.txt)中添加以下内容，将单元测试加入工程： ``` py_test(test_mul_op SRCS test_mul_op.py) ``` -请注意，**不同于Op的编译测试，运行单元测试测时需要编译整个工程**，并且编译时需要打开`WITH_TESTING`, 即`cmake paddle_dir -DWITH_TESTING=ON`。编译成功后，执行下面的命令来运行单测： +请注意，**不同于Op的编译测试，运行单元测试测时需要编译整个工程**，并且编译时需要打开`WITH_TESTING`, 即`cmake paddle_dir -DWITH_TESTING=ON`。编译成功后，执行下面的命令来运行单元测试： ```bash make test ARGS="-R test_mul_op -V" From ed346f1dcd831fa76f69e680264b727b1a9df148 Mon Sep 17 00:00:00 2001 From: Yu Yang Date: Wed, 6 Sep 2017 11:24:44 -0700 Subject: [PATCH 58/62] Pass CI --- paddle/operators/gaussian_random_op.cu | 2 +- paddle/operators/uniform_random_op.cu | 2 +- paddle/platform/cudnn_helper.h | 1 + 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/paddle/operators/gaussian_random_op.cu b/paddle/operators/gaussian_random_op.cu index 9788d89408..d9dbc1dcfe 100644 --- a/paddle/operators/gaussian_random_op.cu +++ b/paddle/operators/gaussian_random_op.cu @@ -42,7 +42,7 @@ class GPUGaussianRandomKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext& context) const override { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = static_cast(context.GetAttr("seed")); + unsigned int seed = static_cast(context.Attr("seed")); if (seed == 0) { std::random_device rd; seed = rd(); diff --git a/paddle/operators/uniform_random_op.cu b/paddle/operators/uniform_random_op.cu index fc6f856fa3..c2c041b144 100644 --- a/paddle/operators/uniform_random_op.cu +++ b/paddle/operators/uniform_random_op.cu @@ -45,7 +45,7 @@ class GPUUniformRandomKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext& context) const override { auto* tensor = context.Output("Out"); T* data = tensor->mutable_data(context.GetPlace()); - unsigned int seed = static_cast(context.GetAttr("seed")); + unsigned int seed = static_cast(context.Attr("seed")); if (seed == 0) { std::random_device rd; seed = rd(); diff --git a/paddle/platform/cudnn_helper.h b/paddle/platform/cudnn_helper.h index 24ddf3441c..2841d2a2db 100644 --- a/paddle/platform/cudnn_helper.h +++ b/paddle/platform/cudnn_helper.h @@ -14,6 +14,7 @@ limitations under the License. */ #pragma once +#include #include "paddle/platform/dynload/cudnn.h" #include "paddle/platform/enforce.h" #include "paddle/platform/macros.h" From d578b25db8ab9afe7720ca3a2863de91bf069a5a Mon Sep 17 00:00:00 2001 From: qiaolongfei Date: Wed, 6 Sep 2017 12:09:17 -0700 Subject: [PATCH 59/62] add var desc proto --- paddle/framework/framework.proto | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/paddle/framework/framework.proto b/paddle/framework/framework.proto index 368136a972..dfcb5fb621 100644 --- a/paddle/framework/framework.proto +++ b/paddle/framework/framework.proto @@ -87,3 +87,24 @@ message OpProto { repeated Attr attrs = 4; required string comment = 5; } + +enum DataType { + BOOL = 0; + INT16 = 1; + INT32 = 2; + INT64 = 3; + FP16 = 4; + FP32 = 5; + FP64 = 6; +} + +message LoDTensorDesc { + required DataType data_type = 1; + repeated int32 dims = 2; // [UNK, 640, 480] is saved as [-1, 640, 480] + optional int32 lod_level = 3 [ default = 0 ]; +} + +message VarDesc { + required string name = 1; + optional LoDTensorDesc lod_tensor = 2; +} From 2282624223af05c686cfce472abee1c5447ff6ae Mon Sep 17 00:00:00 2001 From: Yan Chunwei Date: Wed, 6 Sep 2017 18:16:36 -0400 Subject: [PATCH 60/62] add offset implementation to lod tensor design (#3934) * add offset implementation to lod tensor design --- paddle/framework/lod_tensor.md | 40 +++++++++++++++++++++++++++------- 1 file changed, 32 insertions(+), 8 deletions(-) diff --git a/paddle/framework/lod_tensor.md b/paddle/framework/lod_tensor.md index 8dfe3ee823..769b61f175 100644 --- a/paddle/framework/lod_tensor.md +++ b/paddle/framework/lod_tensor.md @@ -94,7 +94,7 @@ Let's go on slicing this slice. Its <1,1>-slice is ||| ``` -### The General Slicing Algorithm +### The Slicing Algorithm The algorithm, with over-simplified data structure, is defined as @@ -106,17 +106,41 @@ struct LoDTensor { float* tensor_; }; -LoDTensor Slice(const LoDTensor& lodt, int level, int sequence) { +LoDTensor Slice(const LoDTensor& lodt, int level, int sequence); +``` + +Let us revisit the example above -} +``` + 3 +3 1 2 +3 2 4 1 2 3 +||| || |||| | || ||| ``` -### Slicing the Top Level +Suppose that we want to retrieve the <1,2>-slice -Please be aware that an RNN operator only slices the top level of a LoD Tensor to get the step inputs. +``` +2 +2 3 +|| ||| +``` -```c++ -LoDTensor Slice(const LoDTensor& lodt, int sequence) { +we will need to find out the starting position of this slice by summing over all leaf nodes in `LoD` to the left of the slice, i.e., 3 + 2 + 4 + 1 = 10. + +To avoid the traversal of the LoD tree at slcing time, we can do it at the construction time -- instead of saving the lengths of the next level in the LoD tree, we can save the starting offset of the next level. For example, above LoD Tensor can be transformed into + +``` + 0 +0 9 10 +0 3 5 9 10 12 +||| || |||| | || ||| +``` + +We don't really need the 0 on top, so the LoD Tensor could be -} +``` +0 9 10 +0 3 5 9 10 12 +||| || |||| | || ||| ``` From 1f0341e19edcaf5a86908b8707901b17052797a1 Mon Sep 17 00:00:00 2001 From: fengjiayi Date: Wed, 6 Sep 2017 16:25:15 -0700 Subject: [PATCH 61/62] Rename `LargerThan` to `GreaterThan` --- doc/design/simple_op_design.md | 2 +- paddle/framework/attribute.h | 8 ++++---- paddle/framework/op_registry_test.cc | 2 +- paddle/framework/operator_test.cc | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/design/simple_op_design.md b/doc/design/simple_op_design.md index 5e07c29c56..fded4a6861 100644 --- a/doc/design/simple_op_design.md +++ b/doc/design/simple_op_design.md @@ -147,7 +147,7 @@ class CosineOp { struct CosineOpProtoMaker : public OpProtoMaker { CosineOpProtoMaker(OpProto* proto) : OpProtoMaker(proto) { AddInput("input", "input of cosine op"); - AddAttr("scale", "scale of cosine op", float).Default(1.0).LargerThan(0.0); + AddAttr("scale", "scale of cosine op", float).Default(1.0).GreaterThan(0.0); AddType("cos"); AddComment("This is cos op"); } diff --git a/paddle/framework/attribute.h b/paddle/framework/attribute.h index 071879a9d4..cde3dfa1d3 100644 --- a/paddle/framework/attribute.h +++ b/paddle/framework/attribute.h @@ -41,9 +41,9 @@ Attribute GetAttrValue(const OpDesc::Attr& attr_desc); // check whether a value(attribute) fit a certain limit template -class LargerThanChecker { +class GreaterThanChecker { public: - explicit LargerThanChecker(T lower_bound) : lower_bound_(lower_bound) {} + explicit GreaterThanChecker(T lower_bound) : lower_bound_(lower_bound) {} void operator()(T& value) const { PADDLE_ENFORCE(value > lower_bound_, "larger_than check fail"); } @@ -110,8 +110,8 @@ class TypedAttrChecker { return *this; } - TypedAttrChecker& LargerThan(const T& lower_bound) { - value_checkers_.push_back(LargerThanChecker(lower_bound)); + TypedAttrChecker& GreaterThan(const T& lower_bound) { + value_checkers_.push_back(GreaterThanChecker(lower_bound)); return *this; } diff --git a/paddle/framework/op_registry_test.cc b/paddle/framework/op_registry_test.cc index 0e2fb27b65..e00c6e8d90 100644 --- a/paddle/framework/op_registry_test.cc +++ b/paddle/framework/op_registry_test.cc @@ -21,7 +21,7 @@ class CosineOpProtoAndCheckerMaker : public OpProtoAndCheckerMaker { AddOutput("output", "output of cosine op"); AddAttr("scale", "scale of cosine op") .SetDefault(1.0) - .LargerThan(0.0); + .GreaterThan(0.0); AddComment("This is cos op"); } }; diff --git a/paddle/framework/operator_test.cc b/paddle/framework/operator_test.cc index 8a1970c7a8..20bbb11896 100644 --- a/paddle/framework/operator_test.cc +++ b/paddle/framework/operator_test.cc @@ -102,7 +102,7 @@ class OpKernelTestProtoAndCheckerMaker : public OpProtoAndCheckerMaker { AddOutput("y", "output of test op"); AddAttr("scale", "scale of cosine op") .SetDefault(1.0) - .LargerThan(0.0); + .GreaterThan(0.0); AddComment("This is test op"); } }; @@ -140,7 +140,7 @@ class OpKernelTestMultiInputsProtoAndCheckerMaker AddOutput("ys", "outputs of test op").AsDuplicable(); AddAttr("scale", "scale of cosine op") .SetDefault(1.0) - .LargerThan(0.0); + .GreaterThan(0.0); AddComment("This is test op"); } }; From c0523f24b0a9b9b70a728eb76fa72c4d0f56f194 Mon Sep 17 00:00:00 2001 From: Yan Chunwei Date: Wed, 6 Sep 2017 19:34:40 -0400 Subject: [PATCH 62/62] rename LOD to LoD for short of "Level of Details" (#3936) --- paddle/framework/lod_tensor.cc | 16 ++++++++-------- paddle/framework/lod_tensor.h | 26 +++++++++++++------------- paddle/framework/lod_tensor_test.cc | 20 ++++++++++---------- 3 files changed, 31 insertions(+), 31 deletions(-) diff --git a/paddle/framework/lod_tensor.cc b/paddle/framework/lod_tensor.cc index 71eac4a10b..908a1f2fd0 100644 --- a/paddle/framework/lod_tensor.cc +++ b/paddle/framework/lod_tensor.cc @@ -19,8 +19,8 @@ namespace paddle { namespace framework { -LOD SliceLevels(const LOD& in, size_t level_begin, size_t level_end) { - LOD new_lod; +LoD SliceLevels(const LoD& in, size_t level_begin, size_t level_end) { + LoD new_lod; new_lod.reserve(level_end - level_begin); for (size_t i = level_begin; i < level_end; i++) { new_lod.emplace_back(in.at(i)); @@ -28,10 +28,10 @@ LOD SliceLevels(const LOD& in, size_t level_begin, size_t level_end) { return new_lod; } -LOD SliceInLevel(const LOD& in, size_t level, size_t elem_begin, +LoD SliceInLevel(const LoD& in, size_t level, size_t elem_begin, size_t elem_end) { // slice the lod. - LOD new_lod; + LoD new_lod; new_lod.reserve(in.size() - level); auto start = in.at(level)[elem_begin]; auto end = in.at(level)[elem_end]; @@ -46,13 +46,13 @@ LOD SliceInLevel(const LOD& in, size_t level, size_t elem_begin, std::transform(new_lod.back().begin(), new_lod.back().end(), new_lod.back().begin(), [start](int v) { return v - start; }); - PADDLE_ENFORCE_EQ(new_lod.back().front(), 0, "error in slice LOD"); + PADDLE_ENFORCE_EQ(new_lod.back().front(), 0, "error in slice LoD"); } PADDLE_ENFORCE_LE(new_lod.size(), in.size()); return new_lod; } -bool operator==(const LOD& a, const LOD& b) { +bool operator==(const LoD& a, const LoD& b) { if (a.size() != b.size()) { return false; } @@ -72,12 +72,12 @@ bool operator==(const LOD& a, const LOD& b) { return true; } -void LODTensor::SliceLevels(size_t level_begin, size_t level_end) { +void LoDTensor::SliceLevels(size_t level_begin, size_t level_end) { auto new_lod = framework::SliceLevels(lod_, level_begin, level_end); lod_ = new_lod; } -void LODTensor::SliceInLevel(size_t level, size_t elem_begin, size_t elem_end) { +void LoDTensor::SliceInLevel(size_t level, size_t elem_begin, size_t elem_end) { PADDLE_ENFORCE(level < NumLevels(), "level [%d] out of range [%d]", level, NumLevels()); PADDLE_ENFORCE(elem_begin < NumElements(level), diff --git a/paddle/framework/lod_tensor.h b/paddle/framework/lod_tensor.h index 9e6b6b4aca..154068fef6 100644 --- a/paddle/framework/lod_tensor.h +++ b/paddle/framework/lod_tensor.h @@ -35,34 +35,34 @@ template using Vector = thrust::host_vector; #endif -using LOD = std::vector>; +using LoD = std::vector>; -LOD SliceLevels(const LOD& in, size_t level_begin, size_t level_end); +LoD SliceLevels(const LoD& in, size_t level_begin, size_t level_end); -LOD SliceInLevel(const LOD& in, size_t level, size_t elem_begin, +LoD SliceInLevel(const LoD& in, size_t level, size_t elem_begin, size_t elem_end); -bool operator==(const LOD& a, const LOD& b); +bool operator==(const LoD& a, const LoD& b); /* - * LODTensor (Level of details Tensor) + * LoDTensor (Level of details Tensor) * see https://en.wikipedia.org/wiki/Level_of_details for reference. */ -class LODTensor { +class LoDTensor { public: - LODTensor() {} - LODTensor(const LOD& lod, Tensor* t) : lod_(lod), tensor_(t) {} + LoDTensor() {} + LoDTensor(const LoD& lod, Tensor* t) : lod_(lod), tensor_(t) {} - void set_lod(const LOD& lod) { lod_ = lod; } + void set_lod(const LoD& lod) { lod_ = lod; } void set_tensor(Tensor* tensor) { tensor_ = tensor; } Tensor& tensor() { return *tensor_; } - LOD lod() { return lod_; } + LoD lod() { return lod_; } /* - * Get a element from LOD. + * Get a element from LoD. */ size_t lod_element(size_t level, size_t elem) const { PADDLE_ENFORCE(level < NumLevels(), "level [%d] out of range [%d]", level, @@ -74,7 +74,7 @@ class LODTensor { } /* - * Number of LODTensor's levels, each level has units of data, for example, + * Number of LoDTensor's levels, each level has units of data, for example, * in the sentence's view, article, paragraph, sentence are 3 levels. */ size_t NumLevels() const { return lod_.size(); } @@ -100,7 +100,7 @@ class LODTensor { void SliceInLevel(size_t level, size_t elem_begin, size_t elem_end); private: - LOD lod_; + LoD lod_; Tensor* tensor_; // not owned }; } // namespace framework diff --git a/paddle/framework/lod_tensor_test.cc b/paddle/framework/lod_tensor_test.cc index 9a351605ed..1da8553134 100644 --- a/paddle/framework/lod_tensor_test.cc +++ b/paddle/framework/lod_tensor_test.cc @@ -21,7 +21,7 @@ namespace paddle { namespace framework { -class LODTensorTester : public ::testing::Test { +class LoDTensorTester : public ::testing::Test { public: virtual void SetUp() override { // tensor's batch_size: 30 @@ -29,7 +29,7 @@ class LODTensorTester : public ::testing::Test { // 0 10 20 // 0 5 10 15 20 // 0 2 5 7 10 12 15 20 - LOD lod; + LoD lod; lod.push_back(std::vector{0, 10, 20}); lod.push_back(std::vector{0, 5, 10, 15, 20}); lod.push_back(std::vector{0, 2, 5, 7, 10, 12, 15, 17, 20}); @@ -47,21 +47,21 @@ class LODTensorTester : public ::testing::Test { protected: platform::CPUPlace place; Tensor tensor; - LODTensor lod_tensor; + LoDTensor lod_tensor; }; -TEST_F(LODTensorTester, NumLevels) { ASSERT_EQ(lod_tensor.NumLevels(), 3UL); } +TEST_F(LoDTensorTester, NumLevels) { ASSERT_EQ(lod_tensor.NumLevels(), 3UL); } -TEST_F(LODTensorTester, NumElements) { +TEST_F(LoDTensorTester, NumElements) { ASSERT_EQ(lod_tensor.NumElements(0), 2UL); ASSERT_EQ(lod_tensor.NumElements(1), 4UL); ASSERT_EQ(lod_tensor.NumElements(2), 8UL); } -TEST_F(LODTensorTester, SliceLevels) { +TEST_F(LoDTensorTester, SliceLevels) { // slice 1 level for (size_t level = 0; level < 3UL; ++level) { - LODTensor new_lod_tensor = lod_tensor; + LoDTensor new_lod_tensor = lod_tensor; new_lod_tensor.SliceLevels(level, level + 1); ASSERT_EQ(new_lod_tensor.NumLevels(), 1UL); ASSERT_EQ(new_lod_tensor.NumElements(0), lod_tensor.NumElements(level)); @@ -70,7 +70,7 @@ TEST_F(LODTensorTester, SliceLevels) { } // slice 2 level for (size_t level = 0; level < 2UL; ++level) { - LODTensor new_lod_tensor = lod_tensor; + LoDTensor new_lod_tensor = lod_tensor; new_lod_tensor.SliceLevels(level, level + 2); ASSERT_EQ(new_lod_tensor.NumLevels(), 2UL); ASSERT_EQ(new_lod_tensor.NumElements(0), lod_tensor.NumElements(level)); @@ -80,9 +80,9 @@ TEST_F(LODTensorTester, SliceLevels) { } } -TEST_F(LODTensorTester, SliceInLevel) { +TEST_F(LoDTensorTester, SliceInLevel) { size_t level = 0; - LODTensor new_lod_tensor = lod_tensor; + LoDTensor new_lod_tensor = lod_tensor; new_lod_tensor.SliceInLevel(level, 0, 2); EXPECT_EQ(new_lod_tensor.NumLevels(), 3UL); EXPECT_EQ(new_lod_tensor.NumElements(0), 2UL);