p85971406
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!120 Fix test for RandomCropDecodeResizeOp. 

Merge pull request !120 from Alexey_Shevlyakov/master
This commit is contained in:
mindspore-ci-bot 2020-04-07 20:52:45 +08:00 committed by Gitee
parent 9e17b996c7 d37b8c4f2d
commit a4b9f8a728
3 changed files with 62 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/ut/cpp/dataset/CMakeLists.txt
View File

@ -32,7 +32,7 @@ SET(DE_UT_SRCS
project_op_test.cc
queue_test.cc
random_crop_op_test.cc
random_crop_decode_resizeOp_test.cc
random_crop_decode_resize_op_test.cc
random_crop_and_resize_op_test.cc
random_color_adjust_op_test.cc
random_horizontal_flip_op_test.cc

36
tests/ut/cpp/dataset/random_crop_and_resize_op_test.cc
View File

@ -20,35 +20,17 @@
#include "utils/log_adapter.h"
using namespace mindspore::dataset;
using mindspore::MsLogLevel::INFO;
using mindspore::ExceptionType::NoExceptionType;
using mindspore::LogStream;
using mindspore::ExceptionType::NoExceptionType;
using mindspore::MsLogLevel::INFO;
class MindDataTestRandomCropAndResizeOp : public UT::CVOP::CVOpCommon {
public:
MindDataTestRandomCropAndResizeOp() : CVOpCommon() {}
};
TEST_F(MindDataTestRandomCropAndResizeOp, TestOpDefault) {
MS_LOG(INFO) << "Doing testRandomCropAndResize.";
TensorShape s_in = input_tensor_->shape();
std::shared_ptr<Tensor> output_tensor;
int h_out = 512;
int w_out = 512;
TensorShape s_out({(uint32_t) h_out, (uint32_t) w_out, (uint32_t) s_in[2]});
std::unique_ptr<RandomCropAndResizeOp> op(new RandomCropAndResizeOp(h_out, w_out));
Status s;
for (auto i = 0; i < 100; i++) {
s = op->Compute(input_tensor_, &output_tensor);
}
EXPECT_TRUE(s.IsOk());
MS_LOG(INFO) << "testRandomCropAndResize end.";
}
TEST_F(MindDataTestRandomCropAndResizeOp, TestOpExtended) {
MS_LOG(INFO) << "Doing testRandomCropAndResize.";
TEST_F(MindDataTestRandomCropAndResizeOp, TestOpSimpleTest) {
MS_LOG(INFO) << " starting RandomCropAndResizeOp simple test";
TensorShape s_in = input_tensor_->shape();
std::shared_ptr<Tensor> output_tensor;
int h_out = 1024;
@ -58,14 +40,14 @@ TEST_F(MindDataTestRandomCropAndResizeOp, TestOpExtended) {
float scale_lb = 0.0001;
float scale_ub = 1.0;
TensorShape s_out({(uint32_t) h_out, (uint32_t) w_out, (uint32_t) s_in[2]});
TensorShape s_out({h_out, w_out, s_in[2]});
std::unique_ptr<RandomCropAndResizeOp> op(
new RandomCropAndResizeOp(h_out, w_out, scale_lb, scale_ub, aspect_lb, aspect_ub));
auto op = std::make_unique<RandomCropAndResizeOp>(h_out, w_out, scale_lb, scale_ub, aspect_lb, aspect_ub);
Status s;
for (auto i = 0; i < 100; i++) {
s = op->Compute(input_tensor_, &output_tensor);
EXPECT_TRUE(s.IsOk());
}
EXPECT_TRUE(s.IsOk());
MS_LOG(INFO) << "testRandomCropAndResize end.";
MS_LOG(INFO) << "RandomCropAndResizeOp simple test finished";
}

105
tests/ut/cpp/dataset/random_crop_decode_resizeOp_test.cc → tests/ut/cpp/dataset/random_crop_decode_resize_op_test.cc
View File

@ -23,9 +23,10 @@
#include "utils/log_adapter.h"
using namespace mindspore::dataset;
using mindspore::MsLogLevel::INFO;
using mindspore::ExceptionType::NoExceptionType;
using mindspore::LogStream;
using mindspore::ExceptionType::NoExceptionType;
using mindspore::MsLogLevel::INFO;
constexpr double kMseThreshold = 2.0;
class MindDataTestRandomCropDecodeResizeOp : public UT::CVOP::CVOpCommon {
public:
@ -33,39 +34,38 @@ class MindDataTestRandomCropDecodeResizeOp : public UT::CVOP::CVOpCommon {
};
TEST_F(MindDataTestRandomCropDecodeResizeOp, TestOp2) {
MS_LOG(INFO) << "Doing testRandomCropDecodeResizeOp Test";
MS_LOG(INFO) << "starting RandomCropDecodeResizeOp test 1";
std::shared_ptr<Tensor> output_tensor1;
std::shared_ptr<Tensor> output_tensor2;
std::shared_ptr<Tensor> decode_and_crop_output;
std::shared_ptr<Tensor> crop_and_decode_output;
int target_height = 884;
int target_width = 718;
float scale_lb = 0.08;
float scale_ub = 1.0;
float aspect_lb = 0.75;
float aspect_ub = 1.333333;
InterpolationMode interpolation = InterpolationMode::kLinear;
uint32_t max_iter = 10;
std::unique_ptr<RandomCropAndResizeOp> op1(new RandomCropAndResizeOp(
target_height, target_width, scale_lb, scale_ub, aspect_lb, aspect_ub, interpolation, max_iter));
EXPECT_TRUE(op1->OneToOne());
std::unique_ptr<RandomCropDecodeResizeOp> op2(new RandomCropDecodeResizeOp(
target_height, target_width, scale_lb, scale_ub, aspect_lb, aspect_ub, interpolation, max_iter));
EXPECT_TRUE(op2->OneToOne());
Status s1, s2;
constexpr int target_height = 884;
constexpr int target_width = 718;
constexpr float scale_lb = 0.08;
constexpr float scale_ub = 1.0;
constexpr float aspect_lb = 0.75;
constexpr float aspect_ub = 1.333333;
const InterpolationMode interpolation = InterpolationMode::kLinear;
constexpr uint32_t max_iter = 10;
auto crop_and_decode = RandomCropDecodeResizeOp(target_height, target_width, scale_lb, scale_ub, aspect_lb, aspect_ub,
interpolation, max_iter);
auto crop_and_decode_copy = crop_and_decode;
auto decode_and_crop = static_cast<RandomCropAndResizeOp>(crop_and_decode_copy);
EXPECT_TRUE(crop_and_decode.OneToOne());
GlobalContext::config_manager()->set_seed(42);
for (int i = 0; i < 100; i++) {
s1 = op1->Compute(input_tensor_, &output_tensor1);
s2 = op2->Compute(raw_input_tensor_, &output_tensor2);
cv::Mat output1(target_height, target_width, CV_8UC3, output_tensor1->StartAddr());
cv::Mat output2(target_height, target_width, CV_8UC3, output_tensor2->StartAddr());
(void)crop_and_decode.Compute(raw_input_tensor_, &crop_and_decode_output);
(void)decode_and_crop.Compute(input_tensor_, &decode_and_crop_output);
cv::Mat output1(target_height, target_width, CV_8UC3, crop_and_decode_output->StartAddr());
cv::Mat output2(target_height, target_width, CV_8UC3, decode_and_crop_output->StartAddr());
long int mse_sum = 0;
long int count = 0;
int a, b;
for (int i = 0; i < target_height; i++) {
for (int j = 0; j < target_width; j++) {
a = (int)output1.at<cv::Vec3b>(i, j)[1];
b = (int)output2.at<cv::Vec3b>(i, j)[1];
for (int j = 0; j < target_height; j++) {
for (int k = 0; k < target_width; k++) {
a = static_cast<int>(output1.at<cv::Vec3b>(i, j)[1]);
b = static_cast<int>(output2.at<cv::Vec3b>(i, j)[1]);
mse_sum += sqrt((a - b) * (a - b));
if (a != b) {
count++;
@ -73,24 +73,22 @@ TEST_F(MindDataTestRandomCropDecodeResizeOp, TestOp2) {
}
}
double mse;
if (count > 0) {
mse = (double) mse_sum / count;
} else {
mse = mse_sum;
}
MS_LOG(DEBUG) << "mse: " << mse << std::endl;
mse = count > 0 ? static_cast<double>(mse_sum) / count : mse_sum;
MS_LOG(INFO) << "mse: " << mse << std::endl;
EXPECT_LT(mse, kMseThreshold);
}
MS_LOG(INFO) << "MindDataTestRandomCropDecodeResizeOp end!";
MS_LOG(INFO) << "RandomCropDecodeResizeOp test 1 finished";
}
TEST_F(MindDataTestRandomCropDecodeResizeOp, TestOp1) {
MS_LOG(INFO) << "Doing MindDataTestRandomCropDecodeResizeOp";
const unsigned int h = 884;
const unsigned int w = 718;
const float scale_lb = 0.1;
const float scale_ub = 1;
const float aspect_lb = 0.1;
const float aspect_ub = 10;
MS_LOG(INFO) << "starting RandomCropDecodeResizeOp test 2";
constexpr int h = 884;
constexpr int w = 718;
constexpr float scale_lb = 0.1;
constexpr float scale_ub = 1;
constexpr float aspect_lb = 0.1;
constexpr float aspect_ub = 10;
std::shared_ptr<Tensor> decoded, decoded_and_cropped, cropped_and_decoded;
std::mt19937 rd;
@ -98,14 +96,14 @@ TEST_F(MindDataTestRandomCropDecodeResizeOp, TestOp1) {
std::uniform_real_distribution<float> rd_aspect(aspect_lb, aspect_ub);
DecodeOp op(true);
op.Compute(raw_input_tensor_, &decoded);
Status s1, s2;
Status crop_and_decode_status, decode_and_crop_status;
float scale, aspect;
int crop_width, crop_height;
bool crop_success = false;
unsigned int mse_sum, m1, m2, count;
float mse;
int mse_sum, m1, m2, count;
double mse;
for (unsigned int k = 0; k < 100; ++k) {
for (int k = 0; k < 100; ++k) {
mse_sum = 0;
count = 0;
for (auto i = 0; i < 100; i++) {
@ -132,13 +130,13 @@ TEST_F(MindDataTestRandomCropDecodeResizeOp, TestOp1) {
int y = rd_y(rd);
op.Compute(raw_input_tensor_, &decoded);
s1 = Crop(decoded, &decoded_and_cropped, x, y, crop_width, crop_height);
s2 = JpegCropAndDecode(raw_input_tensor_, &cropped_and_decoded, x, y, crop_width, crop_height);
crop_and_decode_status = Crop(decoded, &decoded_and_cropped, x, y, crop_width, crop_height);
decode_and_crop_status = JpegCropAndDecode(raw_input_tensor_, &cropped_and_decoded, x, y, crop_width, crop_height);
{
cv::Mat M1(crop_height, crop_width, CV_8UC3, decoded_and_cropped->StartAddr());
cv::Mat M2(crop_height, crop_width, CV_8UC3, cropped_and_decoded->StartAddr());
for (unsigned int i = 0; i < crop_height; ++i) {
for (unsigned int j = 0; j < crop_width; ++j) {
for (int i = 0; i < crop_height; ++i) {
for (int j = 0; j < crop_width; ++j) {
m1 = M1.at<cv::Vec3b>(i, j)[1];
m2 = M2.at<cv::Vec3b>(i, j)[1];
mse_sum += sqrt((m1 - m2) * (m1 - m2));
@ -149,8 +147,9 @@ TEST_F(MindDataTestRandomCropDecodeResizeOp, TestOp1) {
}
}
mse = (count == 0) ? mse_sum : static_cast<float>(mse_sum) / count;
MS_LOG(DEBUG) << "mse: " << mse << std::endl;
mse = count > 0 ? static_cast<double>(mse_sum) / count : mse_sum;
MS_LOG(INFO) << "mse: " << mse << std::endl;
EXPECT_LT(mse, kMseThreshold);
}
MS_LOG(INFO) << "MindDataTestRandomCropDecodeResizeOp end!";
MS_LOG(INFO) << "RandomCropDecodeResizeOp test 2 finished";
}