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

Fix variable name and add the annotation

Browse Source
avx_docs
gaoyuan 9 years ago
parent c0076084e2
commit 707a9c9bbd
3 changed files with 63 additions and 79 deletions
Show Stats Download Patch File Download Diff File

130
paddle/gserver/layers/PriorBox.cpp
Unescape View File

@ -17,6 +17,15 @@ limitations under the License. */
#include "paddle/math/BaseMatrix.h"
namespace paddle {
/**
* @brief A layer for generate prior box locations and variances.
* - Input: Two and only two input layer are accepted. The input layer must be
* be a data output layer and a convolution output layer.
* - Output: The prior box locations and variances of the input data.
* Reference:
* Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed,
* Cheng-Yang Fu, Alexander C. Berg. SSD: Single Shot MultiBox Detector
*/
class PriorBoxLayer : public Layer {
public:
@ -24,106 +33,84 @@ public:
bool init(const LayerMap& layerMap, const ParameterMap& parameterMap);
void forward(PassType passType);
void backward(const UpdateCallback& callback) {}
void forwardImp(const Argument& featureMap, const Argument& imageShape);
int numPriors_;
std::vector<int> minSize_;
std::vector<int> maxSize_;
std::vector<float> aspectRatio_;
std::vector<float> variance_;
std::vector<Argument> tmpCpuInput_;
MatrixPtr buffer_;
};
bool PriorBoxLayer::init(const LayerMap& layerMap,
const ParameterMap& parameterMap) {
Layer::init(layerMap, parameterMap);
auto pb_conf = config_.inputs(0).priorbox_conf();
std::copy(pb_conf.min_size().begin(),
pb_conf.min_size().end(),
auto pbConf = config_.inputs(0).priorbox_conf();
std::copy(pbConf.min_size().begin(),
pbConf.min_size().end(),
std::back_inserter(minSize_));
std::copy(pb_conf.max_size().begin(),
pb_conf.max_size().end(),
std::copy(pbConf.max_size().begin(),
pbConf.max_size().end(),
std::back_inserter(maxSize_));
std::copy(pb_conf.aspect_ratio().begin(),
pb_conf.aspect_ratio().end(),
std::copy(pbConf.aspect_ratio().begin(),
pbConf.aspect_ratio().end(),
std::back_inserter(aspectRatio_));
std::copy(pb_conf.variance().begin(),
pb_conf.variance().end(),
std::copy(pbConf.variance().begin(),
pbConf.variance().end(),
std::back_inserter(variance_));
// flip
int input_ratio_length = aspectRatio_.size();
for (int index = 0; index < input_ratio_length; index++)
int inputRatioLength = aspectRatio_.size();
for (int index = 0; index < inputRatioLength; index++)
aspectRatio_.push_back(1 / aspectRatio_[index]);
aspectRatio_.push_back(1.);
numPriors_ = aspectRatio_.size();
if (maxSize_.size() > 0) numPriors_++;
buffer_ = Matrix::create(1, 1, false, false);
if (useGpu_) {
tmpCpuInput_.reserve(inputLayers_.size());
for (size_t i = 0; i < inputLayers_.size(); i++) {
tmpCpuInput_.push_back(Argument());
}
}
return true;
}
void PriorBoxLayer::forward(PassType passType) {
Layer::forward(passType);
if (useGpu_) {
for (size_t i = 0; i < inputLayers_.size(); i++) {
tmpCpuInput_[i].resizeAndCopyFrom(
getInput(i), false, HPPL_STREAM_DEFAULT);
hl_stream_synchronize(HPPL_STREAM_DEFAULT);
forwardImp(tmpCpuInput_[0], tmpCpuInput_[1]);
}
} else {
forwardImp(getInput(0), getInput(1));
}
}
void PriorBoxLayer::forwardImp(const Argument& featureMap,
const Argument& imageShape) {
int layer_width = featureMap.getFrameWidth();
int layer_height = featureMap.getFrameHeight();
auto input = getInput(0);
int layerWidth = input.getFrameWidth();
int layerHeight = input.getFrameHeight();
MatrixPtr inV1 = imageShape.value;
int image_width = inV1->getElement(0, 0);
int image_height = inV1->getElement(0, 1);
float step_w = static_cast<float>(image_width) / layer_width;
float step_h = static_cast<float>(image_height) / layer_height;
int dim = layer_height * layer_width * numPriors_ * 4;
auto image = getInput(1);
int imageWidth = image.getFrameWidth();
int imageHeight = image.getFrameHeight();
float stepW = static_cast<float>(imageWidth) / layerWidth;
float stepH = static_cast<float>(imageHeight) / layerHeight;
int dim = layerHeight * layerWidth * numPriors_ * 4;
reserveOutput(1, dim * 2);
// use a cpu buffer to compute
Matrix::resizeOrCreate(buffer_, 1, dim * 2, false, false);
auto* tmp_ptr = buffer_->getData();
auto* tmpPtr = buffer_->getData();
int idx = 0;
for (int h = 0; h < layer_height; ++h) {
for (int w = 0; w < layer_width; ++w) {
float center_x = (w + 0.5) * step_w;
float center_y = (h + 0.5) * step_h;
int min_size = 0;
for (int h = 0; h < layerHeight; ++h) {
for (int w = 0; w < layerWidth; ++w) {
float centerX = (w + 0.5) * stepW;
float centerY = (h + 0.5) * stepH;
int minSize = 0;
for (size_t s = 0; s < minSize_.size(); s++) {
// first prior.
min_size = minSize_[s];
int box_width = min_size;
int box_height = min_size;
minSize = minSize_[s];
int boxWidth = minSize;
int boxHeight = minSize;
// xmin, ymin, xmax, ymax.
tmp_ptr[idx++] = (center_x - box_width / 2.) / image_width;
tmp_ptr[idx++] = (center_y - box_height / 2.) / image_height;
tmp_ptr[idx++] = (center_x + box_width / 2.) / image_width;
tmp_ptr[idx++] = (center_y + box_height / 2.) / image_height;
tmpPtr[idx++] = (centerX - boxWidth / 2.) / imageWidth;
tmpPtr[idx++] = (centerY - boxHeight / 2.) / imageHeight;
tmpPtr[idx++] = (centerX + boxWidth / 2.) / imageWidth;
tmpPtr[idx++] = (centerY + boxHeight / 2.) / imageHeight;
if (maxSize_.size() > 0) {
CHECK_EQ(minSize_.size(), maxSize_.size());
// second prior.
for (size_t s = 0; s < maxSize_.size(); s++) {
int max_size = maxSize_[s];
box_width = box_height = sqrt(min_size * max_size);
tmp_ptr[idx++] = (center_x - box_width / 2.) / image_width;
tmp_ptr[idx++] = (center_y - box_height / 2.) / image_height;
tmp_ptr[idx++] = (center_x + box_width / 2.) / image_width;
tmp_ptr[idx++] = (center_y + box_height / 2.) / image_height;
int maxSize = maxSize_[s];
boxWidth = boxHeight = sqrt(minSize * maxSize);
tmpPtr[idx++] = (centerX - boxWidth / 2.) / imageWidth;
tmpPtr[idx++] = (centerY - boxHeight / 2.) / imageHeight;
tmpPtr[idx++] = (centerX + boxWidth / 2.) / imageWidth;
tmpPtr[idx++] = (centerY + boxHeight / 2.) / imageHeight;
}
}
}
@ -131,27 +118,26 @@ void PriorBoxLayer::forwardImp(const Argument& featureMap,
for (size_t r = 0; r < aspectRatio_.size(); r++) {
float ar = aspectRatio_[r];
if (fabs(ar - 1.) < 1e-6) continue;
float box_width = min_size * sqrt(ar);
float box_height = min_size / sqrt(ar);
tmp_ptr[idx++] = (center_x - box_width / 2.) / image_width;
tmp_ptr[idx++] = (center_y - box_height / 2.) / image_height;
tmp_ptr[idx++] = (center_x + box_width / 2.) / image_width;
tmp_ptr[idx++] = (center_y + box_height / 2.) / image_height;
float boxWidth = minSize * sqrt(ar);
float boxHeight = minSize / sqrt(ar);
tmpPtr[idx++] = (centerX - boxWidth / 2.) / imageWidth;
tmpPtr[idx++] = (centerY - boxHeight / 2.) / imageHeight;
tmpPtr[idx++] = (centerX + boxWidth / 2.) / imageWidth;
tmpPtr[idx++] = (centerY + boxHeight / 2.) / imageHeight;
}
}
}
// clip the prior's coordidate such that it is within [0, 1]
for (int d = 0; d < dim; ++d)
tmp_ptr[d] = std::min(std::max(tmp_ptr[d], (float)0.), (float)1.);
tmpPtr[d] = std::min(std::max(tmpPtr[d], (float)0.), (float)1.);
// set the variance.
for (int h = 0; h < layer_height; h++)
for (int w = 0; w < layer_width; w++)
for (int h = 0; h < layerHeight; h++)
for (int w = 0; w < layerWidth; w++)
for (int i = 0; i < numPriors_; i++)
for (int j = 0; j < 4; j++) tmp_ptr[idx++] = variance_[j];
for (int j = 0; j < 4; j++) tmpPtr[idx++] = variance_[j];
MatrixPtr outV = getOutputValue();
outV->copyFrom(buffer_->data_, dim * 2);
}
REGISTER_LAYER(priorbox, PriorBoxLayer);
} // namespace paddle

2
python/paddle/trainer/config_parser.py
Unescape View File

@ -1589,8 +1589,6 @@ class PriorBoxLayer(LayerBase):
self.config.inputs[0].priorbox_conf.aspect_ratio.extend(aspect_ratio)
self.config.inputs[0].priorbox_conf.variance.extend(variance)
self.config.size = size
input_layer0 = self.get_input_layer(0)
input_layer1 = self.get_input_layer(1)
@config_layer('data')

10
python/paddle/trainer_config_helpers/layers.py
Unescape View File

@ -938,7 +938,7 @@ def print_layer(input, name=None):
@wrap_name_default("priorbox")
def priorbox_layer(input,
img_shape,
image,
aspect_ratio,
variance,
min_size,
@ -951,8 +951,8 @@ def priorbox_layer(input,
:type name: basestring
:param input: The input layer.
:type input: LayerOutput
:param img_shape: The width and height of the network input image.
:type img_shape: LayerOutput
:param image: The network input image.
:type image: LayerOutput
:param aspect_ratio: The aspect ratio.
:type aspect_ratio: list
:param variance: The bounding box variance.
@ -968,7 +968,7 @@ def priorbox_layer(input,
Layer(
name=name,
type=LayerType.PRIORBOX_LAYER,
inputs=[input.name, img_shape.name],
inputs=[input.name, image.name],
size=size,
min_size=min_size,
max_size=max_size,
@ -977,7 +977,7 @@ def priorbox_layer(input,
return LayerOutput(
name,
LayerType.PRIORBOX_LAYER,
parents=[input, img_shape],
parents=[input, image],
num_filters=num_filters,
size=size)

Write Preview
Loading…
Cancel
Save