提交 ce233796 编写于 作者: X xuwei06

assign_value operator

We need this operator to assign value to a tensor and the values are stored in the program so that they can be used independent of python.
上级 ea782e38
/* Copyright (c) 2018 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/assign_value_op.h"
namespace paddle {
namespace operators {
class AssignValueOp : public framework::OperatorWithKernel {
public:
AssignValueOp(const std::string &type,
const framework::VariableNameMap &inputs,
const framework::VariableNameMap &outputs,
const framework::AttributeMap &attrs)
: OperatorWithKernel(type, inputs, outputs, attrs) {}
void InferShape(framework::InferShapeContext *ctx) const override {
PADDLE_ENFORCE(ctx->HasOutput("Out"),
"Output(Out) of AssignValueOp should not be null.");
auto shape = ctx->Attrs().Get<std::vector<int>>("shape");
ctx->SetOutputDim("Out", framework::make_ddim(shape));
}
protected:
framework::OpKernelType GetActualKernelType(
const framework::ExecutionContext &ctx) const override {
return framework::OpKernelType(
framework::proto::DataType(ctx.Attr<int>("dtype")), ctx.GetPlace());
}
};
class AssignValueOpMaker : public framework::OpProtoAndCheckerMaker {
public:
AssignValueOpMaker(OpProto *proto, OpAttrChecker *op_checker)
: OpProtoAndCheckerMaker(proto, op_checker) {
AddOutput("Out", "(Tensor) Output tensor of assign_value operator.");
AddAttr<std::vector<int>>("shape",
"(vector<int>) "
"Shape of values.");
AddAttr<int>("dtype", "data type of values")
.InEnum({framework::proto::DataType::INT32,
framework::proto::DataType::FP32});
AddAttr<std::vector<float>>("fp32_values", "store the float values")
.SetDefault({});
AddAttr<std::vector<int>>("int32_values", "store the int values")
.SetDefault({});
AddComment(R"DOC(
AssignValue operator
$$Out = values$$
)DOC");
}
};
template <typename T>
class AssignValueCPUKernel : public AssignValueKernel<T> {
protected:
virtual void Copy(void *dst, const void *src, size_t size,
const framework::ExecutionContext &ctx) const {
std::memcpy(dst, src, size);
}
};
} // namespace operators
} // namespace paddle
namespace ops = paddle::operators;
REGISTER_OPERATOR(assign_value, ops::AssignValueOp, ops::AssignValueOpMaker);
REGISTER_OP_CPU_KERNEL(assign_value, ops::AssignValueCPUKernel<int>,
ops::AssignValueCPUKernel<float>)
/* 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.
Indicesou 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/assign_value_op.h"
namespace paddle {
namespace operators {
template <typename T>
class AssignValueGPUKernel : public AssignValueKernel<T> {
protected:
virtual void Copy(void* dst, const void* src, size_t size,
const framework::ExecutionContext& ctx) const {
auto& dev_ctx = ctx.template device_context<platform::CUDADeviceContext>();
paddle::platform::GpuMemcpyAsync(dst, src, size, cudaMemcpyHostToDevice,
dev_ctx.stream());
}
};
} // namespace operators
} // namespace paddle
namespace ops = paddle::operators;
REGISTER_OP_CUDA_KERNEL(assign_value, ops::AssignValueGPUKernel<int>,
ops::AssignValueGPUKernel<float>);
/* Copyright (c) 2018 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"
#include "paddle/platform/enforce.h"
namespace paddle {
namespace operators {
template <typename T>
class AssignValueKernel : public framework::OpKernel<T> {
public:
virtual void Compute(const framework::ExecutionContext& ctx) const {
auto shape = ctx.Attr<std::vector<int>>("shape");
auto* out = ctx.Output<framework::Tensor>("Out");
out->Resize(framework::make_ddim(shape));
auto* dst = out->mutable_data<T>(ctx.GetPlace());
int dtype = ctx.Attr<int>("dtype");
const char* value_name = nullptr;
switch (dtype) {
case framework::proto::DataType::INT32:
value_name = "int32_values";
break;
case framework::proto::DataType::FP32:
value_name = "fp32_values";
break;
default:
PADDLE_THROW("Unsupported dtype for assign_value_op: %d", dtype);
break;
}
auto values = ctx.Attr<std::vector<T>>(value_name);
Copy(dst, values.data(), sizeof(T) * values.size(), ctx);
}
protected:
virtual void Copy(void* dst, const void* src, size_t size,
const framework::ExecutionContext& ctx) const = 0;
};
} // namespace operators
} // namespace paddle
from ..layer_helper import LayerHelper
from ..param_attr import ParamAttr
from ..framework import convert_np_dtype_to_dtype_
from ..framework import Variable
from ..core import DataType
import numpy
__all__ = [
'create_tensor', 'create_parameter', 'cast', 'concat', 'sums', 'assign',
......@@ -121,7 +125,7 @@ def assign(input, output):
This function copies the *input* Variable to the *output* Variable.
Args:
input(Variable): The source variable
input(Variable|numpy.ndarray): The source variable
output(Variable): The destination variable
Returns:
......@@ -134,11 +138,32 @@ def assign(input, output):
fluid.layers.assign(hidden, out)
"""
helper = LayerHelper('assign', **locals())
if isinstance(input, Variable):
helper.append_op(
type='scale',
inputs={'X': [input]},
outputs={'Out': [output]},
attrs={'scale': 1.0})
elif isinstance(input, numpy.ndarray):
dtype = convert_np_dtype_to_dtype_(input.dtype)
if dtype == DataType.FP32:
value_name = "fp32_values"
elif dtype == DataType.INT32:
value_name = "int32_values"
else:
raise ValueError("Unsupported dtype %s", input.dtype)
helper.append_op(
type='assign_value',
outputs={'Out': [output]},
attrs={
'dtype': dtype,
'shape': list(input.shape),
value_name: [float(v) for v in input.flat]
})
else:
raise ValueError("Wrong type for assign input: %s" % type(input))
return output
......
import paddle.v2.fluid as fluid
import paddle.v2.fluid.layers as layers
import op_test
import numpy
import unittest
import paddle.v2.fluid.framework as framework
class TestAssignValueOp(op_test.OpTest):
def setUp(self):
self.op_type = "assign_value"
x = numpy.random.random(size=(2, 5)).astype(numpy.float32)
self.inputs = {}
self.outputs = {'Out': x}
self.attrs = {
'shape': x.shape,
'dtype': framework.convert_np_dtype_to_dtype_(x.dtype),
'fp32_values': [float(v) for v in x.flat]
}
def test_forward(self):
self.check_output()
def test_assign(self):
val = numpy.random.random(size=(2, 5)).astype(numpy.float32)
x = layers.create_tensor(dtype="float32")
layers.assign(input=val, output=x)
exe = fluid.Executor(fluid.CPUPlace())
fetched_x = exe.run(fluid.default_main_program(),
feed={},
fetch_list=[x])
self.assertTrue(
numpy.allclose(fetched_x, val),
"fetch_x=%s val=%s" % (fetched_x, val))
if __name__ == '__main__':
unittest.main()
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册