m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Modify the argument type of ContextProjectionFunc

Browse Source
avx_docs
hedaoyuan 8 years ago
parent 68156c88c5
commit 41c52d3b0c
8 changed files with 2048 additions and 156 deletions
Show Stats Download Patch File Download Diff File

12
paddle/function/CMakeLists.txt
Unescape View File

@ -3,6 +3,7 @@ file(GLOB cpp_files . *Op.cpp)
list(APPEND h_files Function.h) list(APPEND h_files Function.h)
list(APPEND cpp_files Function.cpp) list(APPEND cpp_files Function.cpp)
list(APPEND cpp_files BufferArg.cpp)
if(WITH_GPU) if(WITH_GPU)
file(GLOB cu_files . *OpGpu.cu) file(GLOB cu_files . *OpGpu.cu)
@ -16,10 +17,13 @@ if(WITH_TESTING)
# TODO: # TODO:
# file(GLOB test_files . *OpTest.cpp) # file(GLOB test_files . *OpTest.cpp)
# add_executable(${test_bin} EXCLUDE_FROM_ALL ${test_files}) # add_executable(${test_bin} EXCLUDE_FROM_ALL ${test_files})
add_simple_unittest(CrossMapNormalOpTest) # add_simple_unittest(CrossMapNormalOpTest)
add_unittest(ContextProjectionOpTest add_simple_unittest(TensorShapeTest)
ContextProjectionOpTest.cpp add_simple_unittest(TensorTypeTest)
../gserver/tests/TestUtil.cpp) add_simple_unittest(BufferArgTest)
# add_unittest(ContextProjectionOpTest
# ContextProjectionOpTest.cpp
# ../gserver/tests/TestUtil.cpp)
endif() endif()
endif() endif()

161
paddle/function/ContextProjectionOp.cpp
View File

File diff suppressed because it is too large Load Diff

38
paddle/function/ContextProjectionOp.h
Unescape View File

@ -31,11 +31,12 @@ namespace paddle {
* \param[in] is_padding whether padding 0 or not. * \param[in] is_padding whether padding 0 or not.
* *
*/ */
template <DeviceType Device> template <DeviceType DType>
void ContextProjectionForward(typename MatrixT<Device>::type* output, void ContextProjectionForward(
const typename MatrixT<Device>::type* input, typename Tensor<real, DType>::Matrix& output,
const typename MatrixT<Device>::type* weight, const typename Tensor<real, DType>::Matrix& input,
const typename SequenceT<Device>::type& sequence, const typename Tensor<real, DType>::Matrix& weight,
const typename Tensor<int, DType>::Vector& sequence,
size_t context_length, size_t context_length,
int context_start, int context_start,
size_t begin_pad); size_t begin_pad);
@ -53,30 +54,31 @@ void ContextProjectionForward(typename MatrixT<Device>::type* output,
* \param[in] is_padding whether padding 0 or not. * \param[in] is_padding whether padding 0 or not.
* *
*/ */
template <DeviceType Device> template <DeviceType DType>
void ContextProjectionBackward(typename MatrixT<Device>::type* out_grad, void ContextProjectionBackward(
typename MatrixT<Device>::type* in_grad, typename Tensor<real, DType>::Matrix& out_grad,
typename MatrixT<Device>::type* w_grad, typename Tensor<real, DType>::Matrix& in_grad,
const typename SequenceT<Device>::type& seq_vec, typename Tensor<real, DType>::Matrix& w_grad,
const typename Tensor<int, DType>::Vector& seq_vec,
size_t context_length, size_t context_length,
int context_start, int context_start,
size_t begin_pad, size_t begin_pad,
bool is_padding, bool is_padding,
size_t total_pad); size_t total_pad);
template <DeviceType Device> template <DeviceType DType>
void ContextProjectionBackwardData( void ContextProjectionBackwardData(
typename MatrixT<Device>::type* out_grad, typename Tensor<real, DType>::Matrix& out_grad,
typename MatrixT<Device>::type* in_grad, typename Tensor<real, DType>::Matrix& in_grad,
const typename SequenceT<Device>::type& sequence, const typename Tensor<int, DType>::Vector& sequence,
size_t context_length, size_t context_length,
int context_start); int context_start);
template <DeviceType Device> template <DeviceType DType>
void ContextProjectionBackwardWeight( void ContextProjectionBackwardWeight(
typename MatrixT<Device>::type* out_grad, typename Tensor<real, DType>::Matrix& out_grad,
typename MatrixT<Device>::type* w_grad, typename Tensor<real, DType>::Matrix& w_grad,
const typename SequenceT<Device>::type& seq_vec, const typename Tensor<int, DType>::Vector& seq_vec,
size_t context_length, size_t context_length,
int context_start, int context_start,
size_t total_pad, size_t total_pad,

44
paddle/function/ContextProjectionOpGpu.cu
Unescape View File

@ -120,20 +120,19 @@ void hl_context_projection_forward(const real* input,
} }
template <> template <>
void ContextProjectionForward<DEVICE_TYPE_GPU>(GpuMatrix* output, void ContextProjectionForward<DEVICE_TYPE_GPU>(GpuMatrix& output,
const GpuMatrix* input, const GpuMatrix& input,
const GpuMatrix* weight, const GpuMatrix& weight,
const GpuIVector& sequence, const GpuIVector& sequence,
size_t context_length, size_t context_length,
int context_start, int context_start,
size_t begin_pad) { size_t begin_pad) {
CHECK(input && output); hl_context_projection_forward(input.getData(),
hl_context_projection_forward(input->getData(),
sequence.getData(), sequence.getData(),
weight ? weight->getData() : nullptr, weight ? weight.getData() : nullptr,
output->getData(), output.getData(),
sequence.getSize() - 1, sequence.getSize() - 1,
input->getWidth(), input.getWidth(),
context_length, context_length,
context_start, context_start,
begin_pad); begin_pad);
@ -217,17 +216,16 @@ void hl_context_projection_backward_data(real* out_grad,
} }
template <> template <>
void ContextProjectionBackwardData<DEVICE_TYPE_GPU>(GpuMatrix* out_grad, void ContextProjectionBackwardData<DEVICE_TYPE_GPU>(GpuMatrix& out_grad,
GpuMatrix* in_grad, GpuMatrix& in_grad,
const GpuIVector& sequence, const GpuIVector& sequence,
size_t context_length, size_t context_length,
int context_start) { int context_start) {
CHECK(in_grad && out_grad); hl_context_projection_backward_data(out_grad.getData(),
hl_context_projection_backward_data(out_grad->getData(),
sequence.getData(), sequence.getData(),
in_grad->getData(), in_grad.getData(),
sequence.getSize() - 1, sequence.getSize() - 1,
in_grad->getWidth(), in_grad.getWidth(),
context_length, context_length,
context_start); context_start);
} }
@ -348,19 +346,18 @@ void hl_context_projection_backward_weight(real* out_grad,
template <> template <>
void ContextProjectionBackwardWeight<DEVICE_TYPE_GPU>( void ContextProjectionBackwardWeight<DEVICE_TYPE_GPU>(
GpuMatrix* out_grad, GpuMatrix& out_grad,
GpuMatrix* w_grad, GpuMatrix& w_grad,
const GpuIVector& seq_vec, const GpuIVector& seq_vec,
size_t context_length, size_t context_length,
int context_start, int context_start,
size_t total_pad, size_t total_pad,
size_t begin_pad) { size_t begin_pad) {
CHECK(out_grad && w_grad); hl_context_projection_backward_weight(out_grad.getData(),
hl_context_projection_backward_weight(out_grad->getData(),
seq_vec.getData(), seq_vec.getData(),
w_grad->getData(), w_grad.getData(),
seq_vec.getSize() - 1, seq_vec.getSize() - 1,
w_grad->getWidth(), w_grad.getWidth(),
total_pad, total_pad,
context_length, context_length,
context_start, context_start,
@ -368,16 +365,15 @@ void ContextProjectionBackwardWeight<DEVICE_TYPE_GPU>(
} }
template <> template <>
void ContextProjectionBackward<DEVICE_TYPE_GPU>(GpuMatrix* out_grad, void ContextProjectionBackward<DEVICE_TYPE_GPU>(GpuMatrix& out_grad,
GpuMatrix* in_grad, GpuMatrix& in_grad,
GpuMatrix* w_grad, GpuMatrix& w_grad,
const GpuIVector& sequence, const GpuIVector& sequence,
size_t context_length, size_t context_length,
int context_start, int context_start,
size_t begin_pad, size_t begin_pad,
bool is_padding, bool is_padding,
size_t total_pad) { size_t total_pad) {
CHECK(out_grad);
if (in_grad) { if (in_grad) {
ContextProjectionBackwardData<DEVICE_TYPE_GPU>( ContextProjectionBackwardData<DEVICE_TYPE_GPU>(
out_grad, out_grad,

17
paddle/function/TensorTypeTest.cpp
Unescape View File

@ -44,4 +44,21 @@ TEST(TensorType, Vector) {
EXPECT_EQ(gpuIVector.getSize(), 100); EXPECT_EQ(gpuIVector.getSize(), 100);
} }
TEST(TensorType, EmptyMatrix) {
CpuMatrix empty(nullptr, 0, 0);
CpuMatrix nonEmpty(10, 10);
EXPECT_EQ(empty.isEmpty(), true);
EXPECT_EQ(nonEmpty.isEmpty(), false);
CHECK(nonEmpty);
auto function = [](const CpuMatrix& matrix) {
if (matrix) {
EXPECT_NE(matrix.getData(), nullptr);
} else {
EXPECT_EQ(matrix.getData(), nullptr);
}
};
function(empty);
function(nonEmpty);
}
} // namespace paddle } // namespace paddle

42
paddle/gserver/layers/ContextProjection.cpp
Unescape View File

@ -110,7 +110,7 @@ void ContextProjection::forward() {
size_t input_dim = in_->value->getWidth(); size_t input_dim = in_->value->getWidth();
size_t dim = out_->value->getWidth(); size_t dim = out_->value->getWidth();
CHECK_EQ(dim, input_dim * config_.context_length()); CHECK_EQ(dim, input_dim * config_.context_length());
size_t batch_size = in_->value->getHeight(); // size_t batch_size = in_->value->getHeight();
CHECK_EQ(forward_.size(), 1) << "Only one forward function here"; CHECK_EQ(forward_.size(), 1) << "Only one forward function here";
REGISTER_TIMER_INFO("ContextProjectionForward", getName().c_str()); REGISTER_TIMER_INFO("ContextProjectionForward", getName().c_str());
@ -119,14 +119,17 @@ void ContextProjection::forward() {
auto w_ptr = auto w_ptr =
state_ ? state_.get() : is_padding ? weight_->getW().get() : nullptr; state_ ? state_.get() : is_padding ? weight_->getW().get() : nullptr;
auto start_pos = in_->sequenceStartPositions; auto start_pos = in_->sequenceStartPositions;
forward_[0]->calc({Tensor(in_->value->getData(), Dims{batch_size, input_dim}),
Tensor(w_ptr ? w_ptr->getData() : nullptr, BufferArgs inputs;
Dims{w_ptr ? w_ptr->getHeight() : 0, input_dim}), BufferArgs outputs;
Tensor(reinterpret_cast<real*>( BufferArgs inouts;
const_cast<int*>(start_pos->getData(useGpu_))), inputs.addArg(*in_->value);
Dims{start_pos->getSize()})}, inputs.addArg(CpuMatrix(w_ptr ? w_ptr->getData() : nullptr,
{Tensor(out_->value->getData(), Dims{batch_size, dim})}, w_ptr ? w_ptr->getHeight() : 0,
{}); input_dim));
inputs.addArg(*in_->sequenceStartPositions->getVector(useGpu_));
outputs.addArg(*out_->value);
forward_[0]->calc(inputs, outputs, inouts);
if (state_ && config_.context_start() < 0) { if (state_ && config_.context_start() < 0) {
CHECK_EQ(1, in_->getNumSequences()); CHECK_EQ(1, in_->getNumSequences());
@ -160,15 +163,18 @@ void ContextProjection::backward(const UpdateCallback& callback) {
bool is_padding = config_.trainable_padding(); bool is_padding = config_.trainable_padding();
auto start_pos = in_->sequenceStartPositions; auto start_pos = in_->sequenceStartPositions;
auto w_ptr = is_padding ? weight_->getWGrad() : nullptr; auto w_ptr = is_padding ? weight_->getWGrad() : nullptr;
backward_[0]->calc({Tensor(in_->grad ? in_->grad->getData() : nullptr,
Dims{batch_size, input_dim}), BufferArgs inputs;
Tensor(w_ptr ? w_ptr->getData() : nullptr, BufferArgs outputs;
Dims{w_ptr ? w_ptr->getHeight() : 0, input_dim}), BufferArgs inouts;
Tensor(reinterpret_cast<real*>( inputs.addArg(CpuMatrix(
const_cast<int*>(start_pos->getData(useGpu_))), in_->grad ? in_->grad->getData() : nullptr, batch_size, input_dim));
Dims{start_pos->getSize()})}, inputs.addArg(CpuMatrix(w_ptr ? w_ptr->getData() : nullptr,
{Tensor(out_->grad->getData(), Dims{batch_size, dim})}, w_ptr ? w_ptr->getHeight() : 0,
{}); input_dim));
inputs.addArg(*in_->sequenceStartPositions->getVector(useGpu_));
outputs.addArg(*out_->grad);
backward_[0]->calc(inputs, outputs, inouts);
if (config_.trainable_padding()) { if (config_.trainable_padding()) {
weight_->getParameterPtr()->incUpdate(callback); weight_->getParameterPtr()->incUpdate(callback);

4
paddle/math/Matrix.h
Unescape View File

@ -1091,6 +1091,10 @@ public:
TensorCpuApply<real>(*this, expr); TensorCpuApply<real>(*this, expr);
} }
} }
bool isEmpty() const { return data_ == nullptr; }
explicit operator bool() const { return !isEmpty(); }
}; };
inline std::ostream& operator<<(std::ostream& os, const Matrix& mat) { inline std::ostream& operator<<(std::ostream& os, const Matrix& mat) {

1870
paddle/math/Matrix.h~RFbb8b484f.TMP
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save