Yu Yang
7 years ago
committed by
GitHub
commit
ef84ff8657
@ -0,0 +1,36 @@
|
|||||||
|
=====================
|
||||||
|
Data Reader Interface
|
||||||
|
=====================
|
||||||
|
|
||||||
|
|
||||||
|
DataTypes
|
||||||
|
=========
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.data_type
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
DataFeeder
|
||||||
|
==========
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.data_feeder
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
Reader
|
||||||
|
======
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.reader
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.reader.creator
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
minibatch
|
||||||
|
=========
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.minibatch
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
@ -0,0 +1,75 @@
|
|||||||
|
Dataset
|
||||||
|
=======
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
mnist
|
||||||
|
+++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.mnist
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
cifar
|
||||||
|
+++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.cifar
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
conll05
|
||||||
|
+++++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.conll05
|
||||||
|
:members: get_dict,get_embedding,test
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
imdb
|
||||||
|
++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.imdb
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
imikolov
|
||||||
|
++++++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.imikolov
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
movielens
|
||||||
|
+++++++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.movielens
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
.. autoclass:: paddle.v2.dataset.movielens.MovieInfo
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
.. autoclass:: paddle.v2.dataset.movielens.UserInfo
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
sentiment
|
||||||
|
+++++++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.sentiment
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
uci_housing
|
||||||
|
+++++++++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.uci_housing
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
|
|
||||||
|
wmt14
|
||||||
|
+++++
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.dataset.wmt14
|
||||||
|
:members:
|
||||||
|
:noindex:
|
||||||
@ -0,0 +1,5 @@
|
|||||||
|
Image Interface
|
||||||
|
===============
|
||||||
|
|
||||||
|
.. automodule:: paddle.v2.image
|
||||||
|
:members:
|
||||||
|
After Width: | Height: | Size: 61 KiB |
@ -0,0 +1,245 @@
|
|||||||
|
# Design: Sequence Decoder Generating LoDTensors
|
||||||
|
In tasks such as machine translation and image to text,
|
||||||
|
a [sequence decoder](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.md) is necessary to generate sequences.
|
||||||
|
|
||||||
|
This documentation describes how to implement the sequence decoder as an operator.
|
||||||
|
|
||||||
|
## Beam Search based Decoder
|
||||||
|
The [beam search algorithm](https://en.wikipedia.org/wiki/Beam_search) is necessary when generating sequences,
|
||||||
|
it is a heuristic search algorithm that explores the paths by expanding the most promising node in a limited set.
|
||||||
|
|
||||||
|
In the old version of PaddlePaddle, a C++ class `RecurrentGradientMachine` implements the general sequence decoder based on beam search,
|
||||||
|
due to the complexity, the implementation relays on a lot of special data structures,
|
||||||
|
quite trivial and hard to be customized by users.
|
||||||
|
|
||||||
|
There are a lot of heuristic tricks in the sequence generation tasks,
|
||||||
|
so the flexibility of sequence decoder is very important to users.
|
||||||
|
|
||||||
|
During PaddlePaddle's refactoring work,
|
||||||
|
some new concept is proposed such as [LoDTensor](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/lod_tensor.md) and [TensorArray](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/tensor_array.md) that can better support sequence usage,
|
||||||
|
and they can help to make the implementation of beam search based sequence decoder **more transparent and modular** .
|
||||||
|
|
||||||
|
For example, the RNN sates, candidates IDs and probabilities of beam search can be represented as `LoDTensors`;
|
||||||
|
the selected candidate's IDs in each time step can be stored in a `TensorArray`, and `Packed` to the sentences translated.
|
||||||
|
|
||||||
|
## Changing LoD's absolute offset to relative offsets
|
||||||
|
The current `LoDTensor` is designed to store levels of variable-length sequences,
|
||||||
|
it stores several arrays of integers each represents a level.
|
||||||
|
|
||||||
|
The integers in each level represents the begin and end (not inclusive) offset of a sequence **in the underlying tensor**,
|
||||||
|
let's call this format the **absolute-offset LoD** for clear.
|
||||||
|
|
||||||
|
The relative-offset LoD can fast retrieve any sequence but fails to represent empty sequences, for example, a two-level LoD is as follows
|
||||||
|
```python
|
||||||
|
[[0, 3, 9]
|
||||||
|
[0, 2, 3, 3, 3, 9]]
|
||||||
|
```
|
||||||
|
The first level tells that there are two sequences:
|
||||||
|
- the first's offset is `[0, 3)`
|
||||||
|
- the second's offset is `[3, 9)`
|
||||||
|
|
||||||
|
while on the second level, there are several empty sequences that both begin and end at `3`.
|
||||||
|
It is impossible to tell how many empty second-level sequences exist in the first-level sequences.
|
||||||
|
|
||||||
|
There are many scenarios that relay on empty sequence representation,
|
||||||
|
such as machine translation or image to text, one instance has no translations or the empty candidate set for a prefix.
|
||||||
|
|
||||||
|
So let's introduce another format of LoD,
|
||||||
|
it stores **the offsets of the lower level sequences** and is called **relative-offset** LoD.
|
||||||
|
|
||||||
|
For example, to represent the same sequences of the above data
|
||||||
|
|
||||||
|
```python
|
||||||
|
[[0, 3, 6]
|
||||||
|
[0, 2, 3, 3, 3, 9]]
|
||||||
|
```
|
||||||
|
|
||||||
|
the first level represents that there are two sequences,
|
||||||
|
their offsets in the second-level LoD is `[0, 3)` and `[3, 5)`.
|
||||||
|
|
||||||
|
The second level is the same with the relative offset example because the lower level is a tensor.
|
||||||
|
It is easy to find out the second sequence in the first-level LoD has two empty sequences.
|
||||||
|
|
||||||
|
The following demos are based on relative-offset LoD.
|
||||||
|
|
||||||
|
## Usage in a simple machine translation model
|
||||||
|
Let's start from a simple machine translation model that is simplified from [machine translation chapter](https://github.com/PaddlePaddle/book/tree/develop/08.machine_translation) to draw a simple blueprint of what a sequence decoder can do and how to use it.
|
||||||
|
|
||||||
|
The model has an encoder that learns the semantic vector from a sequence,
|
||||||
|
and a decoder which uses the sequence decoder to generate new sentences.
|
||||||
|
|
||||||
|
**Encoder**
|
||||||
|
```python
|
||||||
|
import paddle as pd
|
||||||
|
|
||||||
|
dict_size = 8000
|
||||||
|
source_dict_size = dict_size
|
||||||
|
target_dict_size = dict_size
|
||||||
|
word_vector_dim = 128
|
||||||
|
encoder_dim = 128
|
||||||
|
decoder_dim = 128
|
||||||
|
beam_size = 5
|
||||||
|
max_length = 120
|
||||||
|
|
||||||
|
# encoder
|
||||||
|
src_word_id = pd.data(
|
||||||
|
name='source_language_word',
|
||||||
|
type=pd.data.integer_value_sequence(source_dict_dim))
|
||||||
|
src_embedding = pd.embedding(size=source_dict_size, size=word_vector_dim)
|
||||||
|
|
||||||
|
src_word_vec = pd.lookup(src_embedding, src_word_id)
|
||||||
|
|
||||||
|
encoder_out_seq = pd.gru(input=src_word_vec, size=encoder_dim)
|
||||||
|
|
||||||
|
encoder_ctx = pd.last_seq(encoder_out_seq)
|
||||||
|
# encoder_ctx_proj is the learned semantic vector
|
||||||
|
encoder_ctx_proj = pd.fc(
|
||||||
|
encoder_ctx, size=decoder_dim, act=pd.activation.Tanh(), bias=None)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Decoder**
|
||||||
|
|
||||||
|
```python
|
||||||
|
def generate():
|
||||||
|
decoder = pd.while_loop()
|
||||||
|
with decoder.step():
|
||||||
|
decoder_mem = decoder.memory(init=encoder_ctx) # mark the memory
|
||||||
|
generated_ids = decoder.memory() # TODO init to batch_size <s>s
|
||||||
|
generated_scores = decoder.memory() # TODO init to batch_size 1s or 0s
|
||||||
|
|
||||||
|
target_word = pd.lookup(trg_embedding, gendrated_ids)
|
||||||
|
# expand encoder_ctx's batch to fit target_word's lod
|
||||||
|
# for example
|
||||||
|
# decoder_mem.lod is
|
||||||
|
# [[0 1 3],
|
||||||
|
# [0 1 3 6]]
|
||||||
|
# its tensor content is [a1 a2 a3 a4 a5]
|
||||||
|
# which means there are 2 sentences to translate
|
||||||
|
# - the first sentence has 1 translation prefixes, the offsets are [0, 1)
|
||||||
|
# - the second sentence has 2 translation prefixes, the offsets are [1, 3) and [3, 6)
|
||||||
|
# the target_word.lod is
|
||||||
|
# [[0, 1, 6]
|
||||||
|
# [0, 2, 4, 7, 9 12]]
|
||||||
|
# which means 2 sentences to translate, each has 1 and 5 prefixes
|
||||||
|
# the first prefix has 2 candidates
|
||||||
|
# the following has 2, 3, 2, 3 candidates
|
||||||
|
# the encoder_ctx_expanded's content will be
|
||||||
|
# [a1 a1 a2 a2 a3 a3 a3 a4 a4 a5 a5 a5]
|
||||||
|
encoder_ctx_expanded = pd.lod_expand(encoder_ctx, target_word)
|
||||||
|
decoder_input = pd.fc(
|
||||||
|
act=pd.activation.Linear(),
|
||||||
|
input=[target_word, encoder_ctx],
|
||||||
|
size=3 * decoder_dim)
|
||||||
|
gru_out, cur_mem = pd.gru_step(
|
||||||
|
decoder_input, mem=decoder_mem, size=decoder_dim)
|
||||||
|
scores = pd.fc(
|
||||||
|
gru_out,
|
||||||
|
size=trg_dic_size,
|
||||||
|
bias=None,
|
||||||
|
act=pd.activation.Softmax())
|
||||||
|
# K is an config
|
||||||
|
topk_scores, topk_ids = pd.top_k(scores, K)
|
||||||
|
topk_generated_scores = pd.add_scalar(topk_scores, generated_scores)
|
||||||
|
|
||||||
|
selected_ids, selected_generation_scores = decoder.beam_search(
|
||||||
|
topk_ids, topk_generated_scores)
|
||||||
|
|
||||||
|
# update the states
|
||||||
|
decoder_mem.update(cur_mem) # tells how to update state
|
||||||
|
generated_ids.update(selected_ids)
|
||||||
|
generated_scores.update(selected_generation_scores)
|
||||||
|
|
||||||
|
decoder.output(selected_ids)
|
||||||
|
decoder.output(selected_generation_scores)
|
||||||
|
|
||||||
|
translation_ids, translation_scores = decoder()
|
||||||
|
```
|
||||||
|
The `decoder.beam_search` is a operator that given the candidates and the scores of translations including the candidates,
|
||||||
|
return the result of the beam search algorithm.
|
||||||
|
|
||||||
|
In this way, users can customize anything on the inputs or outputs of beam search, for example, two ways to prune some translation prefixes
|
||||||
|
|
||||||
|
1. meke the correspondind elements in `topk_generated_scores` zero or some small values, beam_search will discard this candidate.
|
||||||
|
2. remove some specific candidate in `selected_ids`
|
||||||
|
3. get the final `translation_ids`, remove the translation sequence in it.
|
||||||
|
|
||||||
|
The implementation of sequence decoder can reuse the C++ class [RNNAlgorithm](https://github.com/Superjom/Paddle/blob/68cac3c0f8451fe62a4cdf156747d6dc0ee000b3/paddle/operators/dynamic_recurrent_op.h#L30),
|
||||||
|
so the python syntax is quite similar to a [RNN](https://github.com/Superjom/Paddle/blob/68cac3c0f8451fe62a4cdf156747d6dc0ee000b3/doc/design/block.md#blocks-with-for-and-rnnop).
|
||||||
|
|
||||||
|
Both of them are two-level `LoDTensors`
|
||||||
|
|
||||||
|
- the first level represents `batch_size` of (source) sentences;
|
||||||
|
- the second level represents the candidate ID sets for translation prefix.
|
||||||
|
|
||||||
|
for example, 3 source sentences to translate, and has 2, 3, 1 candidates.
|
||||||
|
|
||||||
|
Unlike an RNN, in sequence decoder, the previous state and the current state have different LoD and shape,
|
||||||
|
a `lod_expand` operator is used to expand the LoD of the previous state to fit the current state.
|
||||||
|
|
||||||
|
For example, the previous state
|
||||||
|
|
||||||
|
* LoD is `[0, 1, 3][0, 2, 5, 6]`
|
||||||
|
* content of tensor is `a1 a2 b1 b2 b3 c1`
|
||||||
|
|
||||||
|
the current state stored in `encoder_ctx_expanded`
|
||||||
|
|
||||||
|
* LoD is `[0, 2, 7][0 3 5 8 9 11 11]`
|
||||||
|
* the content is
|
||||||
|
- a1 a1 a1 (a1 has 3 candidates, so the state should be copied 3 times for each candidates)
|
||||||
|
- a2 a2
|
||||||
|
- b1 b1 b1
|
||||||
|
- b2
|
||||||
|
- b3 b3
|
||||||
|
- None (c1 has 0 candidates, so c1 is dropped)
|
||||||
|
|
||||||
|
Benefit from the relative offset LoD, empty candidate set can be represented naturally.
|
||||||
|
|
||||||
|
the status in each time step can be stored in `TensorArray`, and `Pack`ed to a final LoDTensor, the corresponding syntax is
|
||||||
|
|
||||||
|
```python
|
||||||
|
decoder.output(selected_ids)
|
||||||
|
decoder.output(selected_generation_scores)
|
||||||
|
```
|
||||||
|
|
||||||
|
the `selected_ids` is the candidate ids for the prefixes,
|
||||||
|
it will be `Packed` by `TensorArray` to a two-level `LoDTensor`,
|
||||||
|
the first level represents the source sequences,
|
||||||
|
the second level represents generated sequences.
|
||||||
|
|
||||||
|
Pack the `selected_scores` will get a `LoDTensor` that stores scores of each candidate of translations.
|
||||||
|
|
||||||
|
Pack the `selected_generation_scores` will get a `LoDTensor`, and each tail is the probability of the translation.
|
||||||
|
|
||||||
|
## LoD and shape changes during decoding
|
||||||
|
<p align="center">
|
||||||
|
<img src="./images/LOD-and-shape-changes-during-decoding.jpg"/>
|
||||||
|
</p>
|
||||||
|
|
||||||
|
According the image above, the only phrase to change LoD is beam search.
|
||||||
|
|
||||||
|
## Beam search design
|
||||||
|
The beam search algorthm will be implemented as one method of the sequence decoder, it has 3 inputs
|
||||||
|
|
||||||
|
1. `topk_ids`, top K candidate ids for each prefix.
|
||||||
|
2. `topk_scores`, the corresponding scores for `topk_ids`
|
||||||
|
3. `generated_scores`, the score of the prefixes.
|
||||||
|
|
||||||
|
All of the are LoDTensors, so that the sequence affilication is clear.
|
||||||
|
Beam search will keep a beam for each prefix and select a smaller candidate set for each prefix.
|
||||||
|
|
||||||
|
It will return three variables
|
||||||
|
|
||||||
|
1. `selected_ids`, the final candidate beam search function selected for the next step.
|
||||||
|
2. `selected_scores`, the scores for the candidates.
|
||||||
|
3. `generated_scores`, the updated scores for each prefixes (with the new candidates appended).
|
||||||
|
|
||||||
|
## Introducing the LoD-based `Pack` and `Unpack` methods in `TensorArray`
|
||||||
|
The `selected_ids`, `selected_scores` and `generated_scores` are LoDTensors,
|
||||||
|
and they exist in each time step,
|
||||||
|
so it is natural to store them in arrays.
|
||||||
|
|
||||||
|
Currently, PaddlePaddle has a module called `TensorArray` which can store an array of tensors,
|
||||||
|
the results of beam search are better to store in a `TensorArray`.
|
||||||
|
|
||||||
|
The `Pack` and `UnPack` in `TensorArray` are used to package tensors in the array to a `LoDTensor` or split the `LoDTensor` to an array of tensors.
|
||||||
|
It needs some extensions to support pack or unpack an array of `LoDTensors`.
|
||||||
@ -0,0 +1,155 @@
|
|||||||
|
/* 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 "ScaleSubRegionOp.h"
|
||||||
|
#include "paddle/function/TensorShape.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
|
||||||
|
template <>
|
||||||
|
void ScaleSubRegion<DEVICE_TYPE_CPU>(real* outputs,
|
||||||
|
const real* inputs,
|
||||||
|
const real* indices,
|
||||||
|
const TensorShape shape,
|
||||||
|
const FuncConfig& conf) {
|
||||||
|
real value = conf.get<real>("value");
|
||||||
|
|
||||||
|
int number = shape[0];
|
||||||
|
int channel = shape[1];
|
||||||
|
int height = shape[2];
|
||||||
|
int width = shape[3];
|
||||||
|
|
||||||
|
memcpy(outputs, inputs, number * channel * height * width * sizeof(real));
|
||||||
|
|
||||||
|
for (int n = 0; n < number; ++n) {
|
||||||
|
// indices start from 1
|
||||||
|
int offset = n * 6;
|
||||||
|
for (int c = indices[offset] - 1; c < indices[offset + 1]; ++c) {
|
||||||
|
for (int h = indices[offset + 2] - 1; h < indices[offset + 3]; ++h) {
|
||||||
|
for (int w = indices[offset + 4] - 1; w < indices[offset + 5]; ++w) {
|
||||||
|
int idx = ((n * channel + c) * height + h) * width + w;
|
||||||
|
outputs[idx] *= value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <>
|
||||||
|
void ScaleSubRegionGrad<DEVICE_TYPE_CPU>(const real* inGrad,
|
||||||
|
real* outGrad,
|
||||||
|
const real* indices,
|
||||||
|
const TensorShape shape,
|
||||||
|
const FuncConfig& conf) {
|
||||||
|
real value = conf.get<real>("value");
|
||||||
|
|
||||||
|
int number = shape[0];
|
||||||
|
int channel = shape[1];
|
||||||
|
int height = shape[2];
|
||||||
|
int width = shape[3];
|
||||||
|
|
||||||
|
for (int n = 0; n < number; ++n) {
|
||||||
|
for (int c = 0; c < channel; ++c) {
|
||||||
|
for (int h = 0; h < height; ++h) {
|
||||||
|
for (int w = 0; w < width; ++w) {
|
||||||
|
int idx = ((n * channel + c) * height + h) * width + w;
|
||||||
|
int offset = n * 6;
|
||||||
|
if (c >= (indices[offset] - 1) && c <= (indices[offset + 1] - 1) &&
|
||||||
|
h >= (indices[offset + 2] - 1) &&
|
||||||
|
h <= (indices[offset + 3] - 1) &&
|
||||||
|
w >= (indices[offset + 4] - 1) &&
|
||||||
|
w <= (indices[offset + 5] - 1)) {
|
||||||
|
outGrad[idx] += inGrad[idx] * value;
|
||||||
|
} else {
|
||||||
|
outGrad[idx] += inGrad[idx];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* \brief For each instance, ScaleSubRegion can be used to multiply a value to
|
||||||
|
* a specified sub continuous region. By providing start index and end
|
||||||
|
* index for C/H/W, you can specify the location and shape of the region.
|
||||||
|
*
|
||||||
|
* Argument in this Function:
|
||||||
|
* \param inputs A 4-D tensor with shape [N, C, H, W], only one input.
|
||||||
|
* \param indices A 2-D tensor with shape [N, 6], indicates the sub region.
|
||||||
|
* \param outputs A 4-D tensor with same shape as inputs, output value.
|
||||||
|
*/
|
||||||
|
template <DeviceType Device>
|
||||||
|
class ScaleSubRegionFunc : public FunctionBase {
|
||||||
|
public:
|
||||||
|
void init(const FuncConfig& config) override { conf_ = config; }
|
||||||
|
|
||||||
|
void calc(const BufferArgs& inputs, const BufferArgs& outputs) override {
|
||||||
|
CHECK_EQ(2UL, inputs.size());
|
||||||
|
CHECK_EQ(1UL, outputs.size());
|
||||||
|
CHECK_EQ(outputs[0].getArgType(), ASSIGN_TO);
|
||||||
|
|
||||||
|
TensorShape shape = inputs[0].shape();
|
||||||
|
|
||||||
|
ScaleSubRegion<Device>(outputs[0].data<real>(),
|
||||||
|
inputs[0].data<real>(),
|
||||||
|
inputs[1].data<real>(),
|
||||||
|
shape,
|
||||||
|
conf_);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
FuncConfig conf_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* \brief The backward propagation of ScaleSubRegion Function.
|
||||||
|
*
|
||||||
|
* Argument in this Function:
|
||||||
|
* \param inputs A 4-D tensor with shape [N, C, H, W], output gradient.
|
||||||
|
* \param indices A 2-D tensor with shape [N, 6], indicates the sub region.
|
||||||
|
* \param outputs A 4-D tensor with shape [N, C, H, W], gradient of input value.
|
||||||
|
*/
|
||||||
|
|
||||||
|
template <DeviceType Device>
|
||||||
|
class ScaleSubRegionGradFunc : public FunctionBase {
|
||||||
|
public:
|
||||||
|
void init(const FuncConfig& config) override { conf_ = config; }
|
||||||
|
|
||||||
|
void calc(const BufferArgs& inputs, const BufferArgs& outputs) override {
|
||||||
|
CHECK_EQ(2UL, inputs.size());
|
||||||
|
CHECK_EQ(1UL, outputs.size());
|
||||||
|
CHECK_EQ(outputs[0].getArgType(), ADD_TO);
|
||||||
|
|
||||||
|
TensorShape shape = inputs[0].shape();
|
||||||
|
|
||||||
|
ScaleSubRegionGrad<Device>(inputs[0].data<real>(),
|
||||||
|
outputs[0].data<real>(),
|
||||||
|
inputs[1].data<real>(),
|
||||||
|
shape,
|
||||||
|
conf_);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
FuncConfig conf_;
|
||||||
|
};
|
||||||
|
|
||||||
|
REGISTER_TYPED_FUNC(ScaleSubRegion, CPU, ScaleSubRegionFunc);
|
||||||
|
REGISTER_TYPED_FUNC(ScaleSubRegionGrad, CPU, ScaleSubRegionGradFunc);
|
||||||
|
#ifdef PADDLE_WITH_CUDA
|
||||||
|
REGISTER_TYPED_FUNC(ScaleSubRegion, GPU, ScaleSubRegionFunc);
|
||||||
|
REGISTER_TYPED_FUNC(ScaleSubRegionGrad, GPU, ScaleSubRegionGradFunc);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
} // namespace paddle
|
||||||
@ -0,0 +1,55 @@
|
|||||||
|
/* 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 "Function.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
|
||||||
|
/**
|
||||||
|
* \brief Function to multiply a value to values in specified sub continuous
|
||||||
|
* region. Indices must be provided to indcate the location and shape of
|
||||||
|
* the region and the multiplied value is passed by configure variable.
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* \param[out] outputs Output value.
|
||||||
|
* \param[in] inputs Input data which contains NCHW information.
|
||||||
|
* \param[in] indices Indices data to indcate the sub region.
|
||||||
|
* \param[in] shape Tensor shape of input value.
|
||||||
|
* \param[in] conf Configure variable which contains the multiplied value.
|
||||||
|
*/
|
||||||
|
template <DeviceType Device>
|
||||||
|
void ScaleSubRegion(real* outputs,
|
||||||
|
const real* inputs,
|
||||||
|
const real* indices,
|
||||||
|
const TensorShape shape,
|
||||||
|
const FuncConfig& conf);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* \brief Backward propagation function of ScaleSubRegion.
|
||||||
|
*
|
||||||
|
* \param[out] inGrad Gradients of previous layer.
|
||||||
|
* \param[in] outGrad Output gradient.
|
||||||
|
* \param[in] indices Indices data.
|
||||||
|
* \param[in] shape The Shape of input tensor.
|
||||||
|
* \param[in] conf Configure variable.
|
||||||
|
*/
|
||||||
|
template <DeviceType Device>
|
||||||
|
void ScaleSubRegionGrad(const real* inGrad,
|
||||||
|
real* outGrad,
|
||||||
|
const real* indices,
|
||||||
|
const TensorShape shape,
|
||||||
|
const FuncConfig& conf);
|
||||||
|
} // namespace paddle
|
||||||
@ -0,0 +1,116 @@
|
|||||||
|
/* 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 "ScaleSubRegionOp.h"
|
||||||
|
#include "hl_base.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
|
||||||
|
__global__ void KeScaleSubRegion(real* outputs,
|
||||||
|
const real* inputs,
|
||||||
|
const real* indices,
|
||||||
|
real value,
|
||||||
|
int channel,
|
||||||
|
int height,
|
||||||
|
int width,
|
||||||
|
int nthreads) {
|
||||||
|
const int idx = threadIdx.x + blockIdx.x * blockDim.x;
|
||||||
|
if (idx < nthreads) {
|
||||||
|
const int w = idx % width;
|
||||||
|
const int h = (idx / width) % height;
|
||||||
|
const int c = (idx / width / height) % channel;
|
||||||
|
const int n = idx / width / height / channel;
|
||||||
|
|
||||||
|
const int offset = n * 6;
|
||||||
|
if (c >= (indices[offset] - 1) && c <= (indices[offset + 1] - 1) &&
|
||||||
|
h >= (indices[offset + 2] - 1) && h <= (indices[offset + 3] - 1) &&
|
||||||
|
w >= (indices[offset + 4] - 1) && w <= (indices[offset + 5] - 1)) {
|
||||||
|
outputs[idx] = inputs[idx] * value;
|
||||||
|
} else {
|
||||||
|
outputs[idx] = inputs[idx];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <>
|
||||||
|
void ScaleSubRegion<DEVICE_TYPE_GPU>(real* outputs,
|
||||||
|
const real* inputs,
|
||||||
|
const real* indices,
|
||||||
|
const TensorShape shape,
|
||||||
|
const FuncConfig& conf) {
|
||||||
|
real value = conf.get<real>("value");
|
||||||
|
|
||||||
|
int number = shape[0];
|
||||||
|
int channel = shape[1];
|
||||||
|
int height = shape[2];
|
||||||
|
int width = shape[3];
|
||||||
|
|
||||||
|
size_t nth = number * channel * height * width;
|
||||||
|
int blockSize = 1024;
|
||||||
|
int gridSize = (nth + blockSize - 1) / blockSize;
|
||||||
|
|
||||||
|
KeScaleSubRegion<<<gridSize, blockSize, 0, STREAM_DEFAULT>>>(
|
||||||
|
outputs, inputs, indices, value, channel, height, width, nth);
|
||||||
|
CHECK_SYNC("ScaleSubRegion");
|
||||||
|
}
|
||||||
|
|
||||||
|
__global__ void KeScaleSubRegionDiff(const real* inGrad,
|
||||||
|
real* outGrad,
|
||||||
|
const real* indices,
|
||||||
|
real value,
|
||||||
|
int channel,
|
||||||
|
int height,
|
||||||
|
int width,
|
||||||
|
int nthreads) {
|
||||||
|
const int idx = threadIdx.x + blockIdx.x * blockDim.x;
|
||||||
|
if (idx < nthreads) {
|
||||||
|
const int w = idx % width;
|
||||||
|
const int h = (idx / width) % height;
|
||||||
|
const int c = (idx / width / height) % channel;
|
||||||
|
const int n = idx / width / height / channel;
|
||||||
|
|
||||||
|
const int offset = n * 6;
|
||||||
|
if (c >= (indices[offset] - 1) && c <= (indices[offset + 1] - 1) &&
|
||||||
|
h >= (indices[offset + 2] - 1) && h <= (indices[offset + 3] - 1) &&
|
||||||
|
w >= (indices[offset + 4] - 1) && w <= (indices[offset + 5] - 1)) {
|
||||||
|
outGrad[idx] += inGrad[idx] * value;
|
||||||
|
} else {
|
||||||
|
outGrad[idx] += inGrad[idx];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <>
|
||||||
|
void ScaleSubRegionGrad<DEVICE_TYPE_GPU>(const real* inGrad,
|
||||||
|
real* outGrad,
|
||||||
|
const real* indices,
|
||||||
|
const TensorShape shape,
|
||||||
|
const FuncConfig& conf) {
|
||||||
|
real value = conf.get<real>("value");
|
||||||
|
|
||||||
|
int number = shape[0];
|
||||||
|
int channel = shape[1];
|
||||||
|
int height = shape[2];
|
||||||
|
int width = shape[3];
|
||||||
|
|
||||||
|
size_t nth = number * channel * height * width;
|
||||||
|
int blockSize = 1024;
|
||||||
|
int gridSize = (nth + blockSize - 1) / blockSize;
|
||||||
|
|
||||||
|
KeScaleSubRegionDiff<<<gridSize, blockSize, 0, STREAM_DEFAULT>>>(
|
||||||
|
inGrad, outGrad, indices, value, channel, height, width, nth);
|
||||||
|
CHECK_SYNC("ScaleSubRegionGrad");
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace paddle
|
||||||
@ -0,0 +1,72 @@
|
|||||||
|
/* 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 <gtest/gtest.h>
|
||||||
|
#include "FunctionTest.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
|
||||||
|
TEST(ScaleSubRegion, real) {
|
||||||
|
for (size_t numSamples : {5, 32}) {
|
||||||
|
for (size_t channels : {5, 32}) {
|
||||||
|
for (size_t imgSizeH : {5, 33}) {
|
||||||
|
for (size_t imgSizeW : {5, 32}) {
|
||||||
|
for (real value : {-0.5, 0.0, 0.5}) {
|
||||||
|
for (bool firstHalf : {false, true}) {
|
||||||
|
VLOG(3) << " numSamples=" << numSamples
|
||||||
|
<< " channels=" << channels << " imgSizeH=" << imgSizeH
|
||||||
|
<< " imgSizeW=" << imgSizeW;
|
||||||
|
|
||||||
|
for (bool testGrad : {false, true}) {
|
||||||
|
CpuGpuFuncCompare compare(
|
||||||
|
testGrad ? "ScaleSubRegionGrad" : "ScaleSubRegion",
|
||||||
|
FuncConfig().set<real>("value", value));
|
||||||
|
|
||||||
|
TensorShape shape{numSamples, channels, imgSizeH, imgSizeW};
|
||||||
|
TensorShape indicesShape{numSamples, 6};
|
||||||
|
|
||||||
|
compare.addInputs(BufferArg(VALUE_TYPE_FLOAT, shape));
|
||||||
|
compare.addInputs(BufferArg(VALUE_TYPE_FLOAT, indicesShape));
|
||||||
|
|
||||||
|
compare.registerInitCallback([=](BufferArg& arg, size_t index) {
|
||||||
|
if (index == 1) {
|
||||||
|
real* data = (real*)arg.data();
|
||||||
|
|
||||||
|
for (size_t i = 0; i < numSamples; ++i) {
|
||||||
|
size_t offset = i * 6;
|
||||||
|
data[offset] = firstHalf ? 1 : channels / 2;
|
||||||
|
data[offset + 1] = firstHalf ? channels / 2 : channels;
|
||||||
|
data[offset + 2] = firstHalf ? 1 : imgSizeH / 2;
|
||||||
|
data[offset + 3] = firstHalf ? imgSizeH / 2 : imgSizeH;
|
||||||
|
data[offset + 4] = firstHalf ? 1 : imgSizeW / 2;
|
||||||
|
data[offset + 5] = firstHalf ? imgSizeW / 2 : imgSizeW;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
compare.addOutputs(
|
||||||
|
BufferArg(
|
||||||
|
VALUE_TYPE_FLOAT, shape, testGrad ? ADD_TO : ASSIGN_TO),
|
||||||
|
testGrad ? ADD_TO : ASSIGN_TO);
|
||||||
|
compare.run();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace paddle
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue