Skip to content

P
Paddle

SummerGao. / Paddle
与 Fork 源项目一致

Fork自 PaddlePaddle / Paddle

通知 1
Star 0
Fork 0
P
Paddle

体验新版 GitCode，发现更多精彩内容 >>

提交 1f516fa0 编写于 作者: X xzl
浏览文件
操作

modify format, and modify the layer grad test, op test

上级 81998868
隐藏空白更改
内联 并排
Showing with 168 addition and 243 deletion
paddle/function/ConvOpTest.cpp
浏览文件 @ 1f516fa0
...@@ -25,95 +25,89 @@ enum TestType { ...@@ -25,95 +25,89 @@ enum TestType {
kBackwardFilterTest = 2, kBackwardFilterTest = 2,
}; };
enum LayerType {
convolutionType = 0,
depthwiseConvolutionType = 1,
};
template <DeviceType DType1, DeviceType DType2> template <DeviceType DType1, DeviceType DType2>
class ConvolutionTest { class ConvolutionTest {
public: public:
ConvolutionTest(const std::string& conv1, ConvolutionTest(const std::string& conv1,
const std::string& conv2, const std::string& conv2,
LayerType layerType,
TestType type, TestType type,
bool useGroups = true,
std::string algo = "auto") { std::string algo = "auto") {
for (size_t batchSize : {1, 32}) { for (size_t batchSize : {1, 32}) {
for (size_t inputSize : {7, 14, 54}) { for (size_t inputSize : {7, 14, 54}) {
for (size_t filterSize : {1, 3, 5}) { for (size_t filterSize : {1, 3, 5}) {
for (size_t inputChannels : {3, 64}) { for (size_t inputChannels : {3, 64}) {
for (size_t outputChannels : {3, 64, 128}) { for (size_t outputChannels : {3, 64, 128}) {
if (inputChannels > outputChannels) break; for (size_t groups : {1, 3, 64}) {
if (layerType == depthwiseConvolutionType && if (inputChannels > outputChannels) break;
outputChannels % inputChannels != 0) if (groups != 1 &&
break; (inputChannels != groups || outputChannels % groups != 0))
continue;
size_t groups = 1; if (!useGroups) groups = 1;
if (layerType == depthwiseConvolutionType) { for (size_t stride : {1, 2}) {
groups = inputChannels; for (size_t padding : {0, 1}) {
} if (padding >= filterSize) break;
size_t outputSize =
for (size_t stride : {1, 2}) { (inputSize - filterSize + 2 * padding + stride) /
for (size_t padding : {0, 1}) { stride;
if (padding >= filterSize) break; VLOG(3) << " batchSize=" << batchSize
size_t outputSize = << " inputChannels=" << inputChannels
(inputSize - filterSize + 2 * padding + stride) / stride; << " inputHeight=" << inputSize
VLOG(3) << " batchSize=" << batchSize << " inputWidth=" << inputSize
<< " inputChannels=" << inputChannels << " outputChannels=" << outputChannels
<< " inputHeight=" << inputSize << " filterHeight=" << filterSize
<< " inputWidth=" << inputSize << " filterWidth=" << filterSize
<< " outputChannels=" << outputChannels << " outputHeight=" << outputSize
<< " filterHeight=" << filterSize << " outputWidth=" << outputSize
<< " filterWidth=" << filterSize << " stride=" << stride << " padding=" << padding;
<< " outputHeight=" << outputSize
<< " outputWidth=" << outputSize std::vector<size_t> paddings = {padding, padding};
<< " stride=" << stride << " padding=" << padding; std::vector<size_t> strides = {stride, stride};
Compare2Function<DType1, DType2> test(
std::vector<size_t> paddings = {padding, padding}; conv1,
std::vector<size_t> strides = {stride, stride}; conv2,
Compare2Function<DType1, DType2> test( FuncConfig()
conv1, .set("paddings", paddings)
conv2, .set("strides", strides)
FuncConfig() .set("groups", groups)
.set("paddings", paddings) .set("algo", algo));
.set("strides", strides)
.set("groups", groups) TensorShape input{
.set("algo", algo)); batchSize, inputChannels, inputSize, inputSize};
TensorShape input{ TensorShape filter;
batchSize, inputChannels, inputSize, inputSize}; if (groups > 1)
filter = TensorShape({groups,
TensorShape filter; outputChannels / groups,
if (layerType == depthwiseConvolutionType) inputChannels / groups,
filter = TensorShape({groups, filterSize,
outputChannels / groups, filterSize});
(size_t)1, else
filterSize, filter = TensorShape({outputChannels,
filterSize}); inputChannels,
else filterSize,
filter = TensorShape({outputChannels, filterSize});
inputChannels, TensorShape output{
filterSize, batchSize, outputChannels, outputSize, outputSize};
filterSize});
TensorShape output{ if (type == kForwardTest) {
batchSize, outputChannels, outputSize, outputSize}; test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
if (type == kForwardTest) { test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, output));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input)); test.run();
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter)); } else if (type == kBackwardInputTest) {
test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, output)); test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
test.run(); test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
} else if (type == kBackwardInputTest) { test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, input),
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output)); ADD_TO);
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter)); test.run();
test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, input), ADD_TO); } else if (type == kBackwardFilterTest) {
test.run(); test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
} else if (type == kBackwardFilterTest) { test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output)); test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, filter));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input)); test.run();
test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, filter)); }
test.run();
} }
} }
} }
...@@ -132,8 +126,8 @@ class ConvolutionTest2 { ...@@ -132,8 +126,8 @@ class ConvolutionTest2 {
public: public:
ConvolutionTest2(const std::string& conv1, ConvolutionTest2(const std::string& conv1,
const std::string& conv2, const std::string& conv2,
LayerType layerType,
TestType type, TestType type,
bool useGroups = true,
std::string algo = "auto") { std::string algo = "auto") {
for (size_t batchSize : {16}) { for (size_t batchSize : {16}) {
for (size_t inputHeight : {7, 31}) { for (size_t inputHeight : {7, 31}) {
...@@ -142,78 +136,78 @@ public: ...@@ -142,78 +136,78 @@ public:
for (size_t filterWidth : {3, 7}) { for (size_t filterWidth : {3, 7}) {
for (size_t inputChannels : {7}) { for (size_t inputChannels : {7}) {
for (size_t outputChannels : {7, 32}) { for (size_t outputChannels : {7, 32}) {
if (layerType == depthwiseConvolutionType && for (size_t groups : {1, 7}) {
outputChannels % inputChannels != 0) if (!useGroups && groups != 1 &&
break; (inputChannels != groups ||
outputChannels % groups != 0))
size_t groups = 1; continue;
if (!useGroups) groups = 1;
if (layerType == depthwiseConvolutionType) {
groups = inputChannels; size_t stride = 1;
} size_t padding = 0;
size_t stride = 1; size_t outputHeight =
size_t padding = 0; (inputHeight - filterHeight + 2 * padding + stride) /
size_t outputHeight = stride;
(inputHeight - filterHeight + 2 * padding + stride) / size_t outputWidth =
stride; (inputWidth - filterWidth + 2 * padding + stride) /
size_t outputWidth = stride;
(inputWidth - filterWidth + 2 * padding + stride) / VLOG(3) << " batchSize=" << batchSize
stride; << " inputChannels=" << inputChannels
VLOG(3) << " batchSize=" << batchSize << " inputHeight=" << inputHeight
<< " inputChannels=" << inputChannels << " inputWidth=" << inputWidth
<< " inputHeight=" << inputHeight << " outputChannels=" << outputChannels
<< " inputWidth=" << inputWidth << " filterHeight=" << filterHeight
<< " outputChannels=" << outputChannels << " filterWidth=" << filterWidth
<< " filterHeight=" << filterHeight << " outputHeight=" << outputHeight
<< " filterWidth=" << filterWidth << " outputWidth=" << outputWidth
<< " outputHeight=" << outputHeight << " stride=" << stride << " padding=" << padding;
<< " outputWidth=" << outputWidth
<< " stride=" << stride << " padding=" << padding; std::vector<size_t> paddings = {padding, padding};
std::vector<size_t> strides = {stride, stride};
std::vector<size_t> paddings = {padding, padding}; Compare2Function<DType1, DType2> test(
std::vector<size_t> strides = {stride, stride}; conv1,
Compare2Function<DType1, DType2> test( conv2,
conv1, FuncConfig()
conv2, .set("paddings", paddings)
FuncConfig() .set("strides", strides)
.set("paddings", paddings) .set("groups", groups)
.set("strides", strides) .set("algo", algo));
.set("groups", groups)
.set("algo", algo)); TensorShape input{
batchSize, inputChannels, inputHeight, inputWidth};
TensorShape input{
batchSize, inputChannels, inputHeight, inputWidth}; TensorShape filter;
if (groups > 1)
TensorShape filter; filter = TensorShape({groups,
if (layerType == depthwiseConvolutionType) outputChannels / groups,
filter = TensorShape({groups, inputChannels / groups,
outputChannels / groups, filterHeight,
(size_t)1, filterWidth});
filterHeight, else
filterWidth}); filter = TensorShape({outputChannels,
else inputChannels,
filter = TensorShape({outputChannels, filterHeight,
inputChannels, filterWidth});
filterHeight, TensorShape output{
filterWidth}); batchSize, outputChannels, outputHeight, outputWidth};
TensorShape output{
batchSize, outputChannels, outputHeight, outputWidth}; if (type == kForwardTest) {
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
if (type == kForwardTest) { test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input)); test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, output));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter)); test.run();
test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, output)); } else if (type == kBackwardInputTest) {
test.run(); test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
} else if (type == kBackwardInputTest) { test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output)); test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, input),
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter)); ADD_TO);
test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, input), ADD_TO); test.run();
test.run(); } else if (type == kBackwardFilterTest) {
} else if (type == kBackwardFilterTest) { test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output)); test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input)); test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, filter));
test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, filter)); test.run();
test.run(); }
} }
} }
} }
...@@ -225,107 +219,34 @@ public: ...@@ -225,107 +219,34 @@ public:
} }
}; };
// ======Start Convolution TEST======
TEST(Forward, GEMM) { TEST(Forward, GEMM) {
ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_CPU> test( ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_CPU> test(
"NaiveConv-CPU", "GemmConv-CPU", convolutionType, kForwardTest); "NaiveConv-CPU", "GemmConv-CPU", kForwardTest, false);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_CPU> test2( ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_CPU> test2(
"NaiveConv-CPU", "GemmConv-CPU", convolutionType, kForwardTest); "NaiveConv-CPU", "GemmConv-CPU", kForwardTest, false);
} }
#ifndef PADDLE_ONLY_CPU #ifndef PADDLE_ONLY_CPU
TEST(Forward, GEMM2) { TEST(Forward, GEMM2) {
ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test( ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test(
"GemmConv-CPU", "GemmConv-GPU", convolutionType, kForwardTest); "GemmConv-CPU", "GemmConv-GPU", kForwardTest);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2( ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
"GemmConv-CPU", "GemmConv-GPU", convolutionType, kForwardTest); "GemmConv-CPU", "GemmConv-GPU", kForwardTest);
} }
TEST(BackwardInput, GEMM) { TEST(BackwardInput, GEMM) {
ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test( ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test(
"GemmConvGradInput-CPU", "GemmConvGradInput-CPU", "GemmConvGradInput-GPU", kBackwardInputTest);
"GemmConvGradInput-GPU",
convolutionType,
kBackwardInputTest);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2( ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
"GemmConvGradInput-CPU", "GemmConvGradInput-CPU", "GemmConvGradInput-GPU", kBackwardInputTest);
"GemmConvGradInput-GPU",
convolutionType,
kBackwardInputTest);
} }
TEST(BackwardFilter, GEMM) { TEST(BackwardFilter, GEMM) {
ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test( ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test(
"GemmConvGradFilter-CPU", "GemmConvGradFilter-CPU", "GemmConvGradFilter-GPU", kBackwardFilterTest);
"GemmConvGradFilter-GPU",
convolutionType,
kBackwardFilterTest);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
"GemmConvGradFilter-CPU",
"GemmConvGradFilter-GPU",
convolutionType,
kBackwardFilterTest);
}
#endif
// ======End Convolution TEST======
// ======Start DepthwiseConvolution TEST======
// TODO(zhaolong) The depthwise convolution cpu test will be added when the cpu
// version of depthwiseConv is implemented.
#ifndef PADDLE_ONLY_CPU
TEST(DepthwiseConvForward, GEMM) {
ConvolutionTest<DEVICE_TYPE_GPU, DEVICE_TYPE_GPU> test(
"GemmConv-GPU",
"DepthwiseConv-GPU",
depthwiseConvolutionType,
kForwardTest);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
"GemmConv-GPU",
"DepthwiseConv-GPU",
depthwiseConvolutionType,
kForwardTest);
}
TEST(DepthwiseConvForward, GEMM2) {
ConvolutionTest<DEVICE_TYPE_GPU, DEVICE_TYPE_GPU> test(
"DepthwiseConv-GPU",
"DepthwiseConv-GPU",
depthwiseConvolutionType,
kForwardTest);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
"DepthwiseConv-GPU",
"DepthwiseConv-GPU",
depthwiseConvolutionType,
kForwardTest);
}
TEST(DepthwiseConvBackwardInput, GEMM) {
ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test(
"DepthwiseConvGradInput-GPU",
"DepthwiseConvGradInput-GPU",
depthwiseConvolutionType,
kBackwardInputTest);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
"DepthwiseConvGradInput-GPU",
"DepthwiseConvGradInput-GPU",
depthwiseConvolutionType,
kBackwardInputTest);
}
TEST(DepthwiseConvBackwardFilter, GEMM) {
ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test(
"DepthwiseConvGradFilter-GPU",
"DepthwiseConvGradFilter-GPU",
depthwiseConvolutionType,
kBackwardFilterTest);
ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2( ConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
"DepthwiseConvGradFilter-GPU", "GemmConvGradFilter-CPU", "GemmConvGradFilter-GPU", kBackwardFilterTest);
"DepthwiseConvGradFilter-GPU",
depthwiseConvolutionType,
kBackwardFilterTest);
} }
#endif #endif
// ======End DepthwiseConvolution TEST======
} // namespace paddle } // namespace paddle
paddle/gserver/layers/ExpandConvLayer.cpp
浏览文件 @ 1f516fa0
...@@ -39,21 +39,22 @@ bool ExpandConvLayer::init(const LayerMap &layerMap, ...@@ -39,21 +39,22 @@ bool ExpandConvLayer::init(const LayerMap &layerMap,
filterShape_.resize(numInputs); filterShape_.resize(numInputs);
outputShape_.resize(numInputs); outputShape_.resize(numInputs);
string convType; std::string convType;
string convGradInputType; std::string convGradInputType;
string convGradFilterType; std::string convGradFilterType;
for (int i = 0; i < config_.inputs_size(); i++) { for (int i = 0; i < config_.inputs_size(); i++) {
std::vector<size_t> paddings = {(size_t)paddingY_[i], (size_t)padding_[i]}; std::vector<size_t> paddings = {(size_t)paddingY_[i], (size_t)padding_[i]};
std::vector<size_t> strides = {(size_t)strideY_[i], (size_t)stride_[i]}; std::vector<size_t> strides = {(size_t)strideY_[i], (size_t)stride_[i]};
if (useGpu_ && (size_t)groups_[i] == (size_t)channels_[i] && !isDeconv_) { if (useGpu_ && (size_t)groups_[i] == (size_t)channels_[i] && !isDeconv_) {
convType = "DepthwiseConv" convGradInputType = convType = "DepthwiseConv";
"DepthwiseConvGradInput" convGradFilterType = convGradInputType = "DepthwiseConvGradInput";
"DepthwiseConvGradFilter" convGradFilterType = "DepthwiseConvGradFilter";
} else { } else {
convType = "GemmConv" convGradInputType = convType = "GemmConv";
"GemmConvGradInput" convGradFilterType = "GemmConvGradFilter" convGradInputType = "GemmConvGradInput";
convGradFilterType = "GemmConvGradFilter";
} }
if (FLAGS_use_nnpack) { if (FLAGS_use_nnpack) {
......
paddle/gserver/tests/test_LayerGrad.cpp
浏览文件 @ 1f516fa0
...@@ -349,13 +349,13 @@ TEST(Layer, CosSimVecMatLayer) { ...@@ -349,13 +349,13 @@ TEST(Layer, CosSimVecMatLayer) {
void testDepthwiseConvLayer(const string& type, bool useGpu) { void testDepthwiseConvLayer(const string& type, bool useGpu) {
TestConfig config; TestConfig config;
config.biasSize = 16; config.biasSize = 32;
config.layerConfig.set_type(type); config.layerConfig.set_type(type);
config.layerConfig.set_num_filters(16); config.layerConfig.set_num_filters(32);
config.layerConfig.set_partial_sum(1); config.layerConfig.set_partial_sum(1);
config.layerConfig.set_shared_biases(true); config.layerConfig.set_shared_biases(true);
config.inputDefs.push_back({INPUT_DATA, "layer_0", 2048, 192 / 2}); config.inputDefs.push_back({INPUT_DATA, "layer_0", 2048, 192});
LayerInputConfig* input = config.layerConfig.add_inputs(); LayerInputConfig* input = config.layerConfig.add_inputs();
ConvConfig* conv = input->mutable_conv_conf(); ConvConfig* conv = input->mutable_conv_conf();
conv->set_filter_size(2); conv->set_filter_size(2);
...@@ -388,8 +388,11 @@ void testDepthwiseConvLayer(const string& type, bool useGpu) { ...@@ -388,8 +388,11 @@ void testDepthwiseConvLayer(const string& type, bool useGpu) {
} }
TEST(Layer, depthwiseConvLayer) { TEST(Layer, depthwiseConvLayer) {
// 'depthwise_conv' is a sepecial case of 'exconv' whose
// groups size equals to the input channels size.
testDepthwiseConvLayer("exconv", /* useGpu= */ false);
#ifndef PADDLE_ONLY_CPU #ifndef PADDLE_ONLY_CPU
testDepthwiseConvLayer("depthwise_conv", /* useGpu= */ true); testDepthwiseConvLayer("exconv", /* useGpu= */ true);
#endif #endif
} }
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或