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

improve error msg

This commit is contained in:
ms_yan 2021-11-18 21:54:05 +08:00
parent 8bdcc68bb7
commit 07c8b361f5
52 changed files with 193 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
mindspore/ccsrc/minddata/dataset/kernels/ir/data/transforms_ir.cc
View File

@ -46,6 +46,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
#ifdef ENABLE_PYTHON
#include "minddata/dataset/kernels/py_func_op.h"
#endif
@ -175,7 +176,7 @@ Status OneHotOperation::to_json(nlohmann::json *out_json) {
}
Status OneHotOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("num_classes") != op_params.end(), "Failed tofind num_classes");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "num_classes", kOneHotOperation));
int32_t num_classes = op_params["num_classes"];
*operation = std::make_shared<transforms::OneHotOperation>(num_classes);
return Status::OK();
@ -281,7 +282,7 @@ Status TypeCastOperation::to_json(nlohmann::json *out_json) {
}
Status TypeCastOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("data_type") != op_params.end(), "Failed tofind data_type");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "data_type", kTypeCastOperation));
std::string data_type = op_params["data_type"];
*operation = std::make_shared<transforms::TypeCastOperation>(data_type);
return Status::OK();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/adjust_gamma_ir.cc
View File

@ -20,6 +20,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -49,8 +50,8 @@ Status AdjustGammaOperation::to_json(nlohmann::json *out_json) {
}
Status AdjustGammaOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("gamma") != op_params.end(), "Failed to find gamma");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("gain") != op_params.end(), "Failed to find gain");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "gamma", kAdjustGammaOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "gain", kAdjustGammaOperation));
float gamma = op_params["gamma"];
float gain = op_params["gain"];
*operation = std::make_shared<vision::AdjustGammaOperation>(gamma, gain);

13
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/affine_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/image/affine_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -84,12 +85,12 @@ Status AffineOperation::to_json(nlohmann::json *out_json) {
}
Status AffineOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("degrees") != op_params.end(), "Failed to find degrees");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("translate") != op_params.end(), "Failed to find translate");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("scale") != op_params.end(), "Failed to find scale");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("shear") != op_params.end(), "Failed to find shear");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("resample") != op_params.end(), "Failed to find resample");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find fill_value");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "degrees", kAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "translate", kAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "scale", kAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "shear", kAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "resample", kAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kAffineOperation));
float_t degrees = op_params["degrees"];
std::vector<float> translation = op_params["translate"];
float scale = op_params["scale"];

15
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/ascend_vision_ir.cc
View File

@ -24,6 +24,7 @@
#include "minddata/dataset/kernels/image/dvpp/dvpp_decode_png_op.h"
#include "minddata/dataset/kernels/image/dvpp/dvpp_normalize_op.h"
#include "minddata/dataset/kernels/image/dvpp/dvpp_resize_jpeg_op.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -78,7 +79,7 @@ Status DvppCropJpegOperation::to_json(nlohmann::json *out_json) {
}
Status DvppCropJpegOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Fail to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kDvppCropJpegOperation));
std::vector<uint32_t> resize = op_params["size"];
*operation = std::make_shared<vision::DvppCropJpegOperation>(resize);
return Status::OK();
@ -132,7 +133,7 @@ Status DvppDecodeResizeOperation::to_json(nlohmann::json *out_json) {
}
Status DvppDecodeResizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Fail to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kDvppDecodeResizeOperation));
std::vector<uint32_t> resize = op_params["size"];
*operation = std::make_shared<vision::DvppDecodeResizeOperation>(resize);
return Status::OK();
@ -236,8 +237,8 @@ Status DvppDecodeResizeCropOperation::to_json(nlohmann::json *out_json) {
}
Status DvppDecodeResizeCropOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("crop_size") != op_params.end(), "Fail to find crop_size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("resize_size") != op_params.end(), "Fail to find resize_size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "crop_size", kDvppDecodeResizeCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "resize_size", kDvppDecodeResizeCropOperation));
std::vector<uint32_t> crop = op_params["crop_size"];
std::vector<uint32_t> resize = op_params["resize_size"];
*operation = std::make_shared<vision::DvppDecodeResizeCropOperation>(crop, resize);
@ -304,8 +305,8 @@ Status DvppNormalizeOperation::to_json(nlohmann::json *out_json) {
}
Status DvppNormalizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("mean") != op_params.end(), "Fail to find mean");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("std") != op_params.end(), "Fail to find std");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "mean", kDvppNormalizeOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "std", kDvppNormalizeOperation));
std::vector<float> mean = op_params["mean"];
std::vector<float> std = op_params["std"];
*operation = std::make_shared<vision::DvppNormalizeOperation>(mean, std);
@ -359,7 +360,7 @@ Status DvppResizeJpegOperation::to_json(nlohmann::json *out_json) {
}
Status DvppResizeJpegOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Fail to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kDvppResizeJpegOperation));
std::vector<uint32_t> resize = op_params["size"];
*operation = std::make_shared<vision::DvppResizeJpegOperation>(resize);
return Status::OK();

7
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/auto_augment_ir.cc
View File

@ -20,6 +20,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -64,9 +65,9 @@ Status AutoAugmentOperation::to_json(nlohmann::json *out_json) {
}
Status AutoAugmentOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("policy") != op_params.end(), "Failed to find degrees");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("interpolation") != op_params.end(), "Failed to find translate");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find scale");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "policy", kAutoAugmentOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "interpolation", kAutoAugmentOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kAutoAugmentOperation));
AutoAugmentPolicy policy = op_params["policy"];
InterpolationMode interpolation = op_params["interpolation"];
std::vector<uint8_t> fill_value = op_params["fill_value"];

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/auto_contrast_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -66,8 +67,8 @@ Status AutoContrastOperation::to_json(nlohmann::json *out_json) {
}
Status AutoContrastOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("cutoff") != op_params.end(), "Failed to find cutoff");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("ignore") != op_params.end(), "Failed to find ignore");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "cutoff", kAutoContrastOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "ignore", kAutoContrastOperation));
float cutoff = op_params["cutoff"];
std::vector<uint32_t> ignore = op_params["ignore"];
*operation = std::make_shared<vision::AutoContrastOperation>(cutoff, ignore);

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/bounding_box_augment_ir.cc
View File

@ -23,6 +23,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -59,8 +60,8 @@ Status BoundingBoxAugmentOperation::to_json(nlohmann::json *out_json) {
}
Status BoundingBoxAugmentOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("transform") != op_params.end(), "Failed to find transform");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("ratio") != op_params.end(), "Failed to find ratio");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "transform", kBoundingBoxAugmentOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "ratio", kBoundingBoxAugmentOperation));
std::vector<std::shared_ptr<TensorOperation>> transforms;
std::vector<nlohmann::json> json_operations = {};
json_operations.push_back(op_params["transform"]);

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/center_crop_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/image/center_crop_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -53,7 +54,7 @@ Status CenterCropOperation::to_json(nlohmann::json *out_json) {
}
Status CenterCropOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kCenterCropOperation));
std::vector<int32_t> size = op_params["size"];
*operation = std::make_shared<CenterCropOperation>(size);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/convert_color_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -55,7 +56,7 @@ Status ConvertColorOperation::to_json(nlohmann::json *out_json) {
}
Status ConvertColorOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("convert_mode") != op_params.end(), "Failed to find convert_mode");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "convert_mode", kConvertColorOperation));
ConvertMode convert_mode = static_cast<ConvertMode>(op_params["convert_mode"]);
*operation = std::make_shared<vision::ConvertColorOperation>(convert_mode);
return Status::OK();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/crop_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/image/crop_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -68,8 +69,8 @@ Status CropOperation::to_json(nlohmann::json *out_json) {
}
Status CropOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("coordinates") != op_params.end(), "Failed to find coordinates");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "coordinates", kCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kCropOperation));
std::vector<int32_t> coordinates = op_params["coordinates"];
std::vector<int32_t> size = op_params["size"];
*operation = std::make_shared<CropOperation>(coordinates, size);

8
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/cutmix_batch_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -60,10 +61,9 @@ Status CutMixBatchOperation::to_json(nlohmann::json *out_json) {
}
Status CutMixBatchOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("image_batch_format") != op_params.end(),
"Failed to find image_batch_format");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("alpha") != op_params.end(), "Failed to find alpha");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "image_batch_format", kCutMixBatchOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "alpha", kCutMixBatchOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kCutMixBatchOperation));
ImageBatchFormat image_batch = static_cast<ImageBatchFormat>(op_params["image_batch_format"]);
float alpha = op_params["alpha"];
float prob = op_params["prob"];

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/cutout_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -53,8 +54,8 @@ Status CutOutOperation::to_json(nlohmann::json *out_json) {
}
Status CutOutOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("length") != op_params.end(), "Failed to find length");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("num_patches") != op_params.end(), "Failed to find num_patches");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "length", kCutOutOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "num_patches", kCutOutOperation));
int32_t length = op_params["length"];
int32_t num_patches = op_params["num_patches"];
*operation = std::make_shared<vision::CutOutOperation>(length, num_patches);

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/decode_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/image/decode_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -38,7 +39,7 @@ Status DecodeOperation::to_json(nlohmann::json *out_json) {
return Status::OK();
}
Status DecodeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("rgb") != op_params.end(), "Failed to find rgb");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "rgb", kDecodeOperation));
bool rgb = op_params["rgb"];
*operation = std::make_shared<vision::DecodeOperation>(rgb);
return Status::OK();

9
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/gaussian_blur_ir.cc
View File

@ -17,10 +17,13 @@
#include "minddata/dataset/kernels/image/gaussian_blur_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
namespace vision {
constexpr int sigma_size = 2;
GaussianBlurOperation::GaussianBlurOperation(const std::vector<int32_t> kernel_size, const std::vector<float> sigma)
: kernel_size_(kernel_size), sigma_(sigma) {}
@ -47,7 +50,7 @@ std::shared_ptr<TensorOp> GaussianBlurOperation::Build() {
float sigma_y = sigma_x;
// User has specified sigma_y.
if (sigma_.size() == 2) {
if (sigma_.size() == sigma_size) {
sigma_y = sigma_[1] <= 0 ? kernel_y * 0.15 + 0.35 : sigma_[1];
}
std::shared_ptr<GaussianBlurOp> tensor_op = std::make_shared<GaussianBlurOp>(kernel_x, kernel_y, sigma_x, sigma_y);
@ -63,8 +66,8 @@ Status GaussianBlurOperation::to_json(nlohmann::json *out_json) {
}
Status GaussianBlurOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("kernel_size") != op_params.end(), "Failed to find kernel_size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("sigma") != op_params.end(), "Failed to find sigma");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "kernel_size", kGaussianBlurOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "sigma", kGaussianBlurOperation));
std::vector<int32_t> kernel_size = op_params["kernel_size"];
std::vector<float> sigma = op_params["sigma"];
*operation = std::make_shared<vision::GaussianBlurOperation>(kernel_size, sigma);

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/mixup_batch_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -47,7 +48,7 @@ Status MixUpBatchOperation::to_json(nlohmann::json *out_json) {
}
Status MixUpBatchOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("alpha") != op_params.end(), "Failed to find alpha");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "alpha", kMixUpBatchOperation));
float alpha = op_params["alpha"];
*operation = std::make_shared<vision::MixUpBatchOperation>(alpha);
return Status::OK();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/normalize_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/image/normalize_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -46,8 +47,8 @@ Status NormalizeOperation::to_json(nlohmann::json *out_json) {
}
Status NormalizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("mean") != op_params.end(), "Fail to find mean");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("std") != op_params.end(), "Fail to find std");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "mean", kNormalizeOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "std", kNormalizeOperation));
std::vector<float> mean = op_params["mean"];
std::vector<float> std = op_params["std"];
*operation = std::make_shared<vision::NormalizeOperation>(mean, std);

7
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/normalize_pad_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -63,9 +64,9 @@ Status NormalizePadOperation::to_json(nlohmann::json *out_json) {
}
Status NormalizePadOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("mean") != op_params.end(), "Failed to find mean");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("std") != op_params.end(), "Failed to find std");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("dtype") != op_params.end(), "Failed to find dtype");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "mean", kNormalizePadOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "std", kNormalizePadOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "dtype", kNormalizePadOperation));
std::vector<float> mean = op_params["mean"];
std::vector<float> std = op_params["std"];
std::string dtype = op_params["dtype"];

7
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/pad_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -105,9 +106,9 @@ Status PadOperation::to_json(nlohmann::json *out_json) {
}
Status PadOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("padding") != op_params.end(), "Failed to find padding");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find fill_value");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("padding_mode") != op_params.end(), "Failed to find padding_mode");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "padding", kPadOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kPadOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "padding_mode", kPadOperation));
std::vector<int32_t> padding = op_params["padding"];
std::vector<uint8_t> fill_value = op_params["fill_value"];
BorderType padding_mode = static_cast<BorderType>(op_params["padding_mode"]);

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_adjust_sharpness_ir.cc
View File

@ -20,6 +20,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -54,8 +55,8 @@ Status RandomAdjustSharpnessOperation::to_json(nlohmann::json *out_json) {
Status RandomAdjustSharpnessOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("degree") != op_params.end(), "Failed to find degree");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "degree", kRandomAdjustSharpnessOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomAdjustSharpnessOperation));
float degree = op_params["degree"];
float prob = op_params["prob"];
*operation = std::make_shared<vision::RandomAdjustSharpnessOperation>(degree, prob);

13
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_affine_ir.cc
View File

@ -20,6 +20,7 @@
#include "minddata/dataset/kernels/image/random_affine_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -154,12 +155,12 @@ Status RandomAffineOperation::to_json(nlohmann::json *out_json) {
}
Status RandomAffineOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("degrees") != op_params.end(), "Failed to find degrees");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("translate") != op_params.end(), "Failed to find translate");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("scale") != op_params.end(), "Failed to find scale");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("shear") != op_params.end(), "Failed to find shear");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("resample") != op_params.end(), "Failed to find resample");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find fill_value");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "degrees", kRandomAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "translate", kRandomAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "scale", kRandomAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "shear", kRandomAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "resample", kRandomAffineOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kRandomAffineOperation));
std::vector<float_t> degrees = op_params["degrees"];
std::vector<float_t> translate_range = op_params["translate"];
std::vector<float_t> scale_range = op_params["scale"];

7
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_auto_contrast_ir.cc
View File

@ -20,6 +20,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -60,9 +61,9 @@ Status RandomAutoContrastOperation::to_json(nlohmann::json *out_json) {
}
Status RandomAutoContrastOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("cutoff") != op_params.end(), "Failed to find cutoff");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("ignore") != op_params.end(), "Failed to find ignore");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "cutoff", kRandomAutoContrastOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "ignore", kRandomAutoContrastOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomAutoContrastOperation));
float cutoff = op_params["cutoff"];
std::vector<uint32_t> ignore = op_params["ignore"];
float prob = op_params["prob"];

9
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_color_adjust_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -95,10 +96,10 @@ Status RandomColorAdjustOperation::to_json(nlohmann::json *out_json) {
}
Status RandomColorAdjustOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("brightness") != op_params.end(), "Failed to find brightness");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("contrast") != op_params.end(), "Failed to find contrast");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("saturation") != op_params.end(), "Failed to find saturation");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("hue") != op_params.end(), "Failed to find hue");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "brightness", kRandomColorAdjustOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "contrast", kRandomColorAdjustOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "saturation", kRandomColorAdjustOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "hue", kRandomColorAdjustOperation));
std::vector<float> brightness = op_params["brightness"];
std::vector<float> contrast = op_params["contrast"];
std::vector<float> saturation = op_params["saturation"];

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_color_ir.cc
View File

@ -23,6 +23,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -62,7 +63,7 @@ Status RandomColorOperation::to_json(nlohmann::json *out_json) {
}
Status RandomColorOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("degrees") != op_params.end(), "Failed to find degrees");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "degrees", kRandomColorOperation));
std::vector<float> degrees = op_params["degrees"];
CHECK_FAIL_RETURN_UNEXPECTED(degrees.size() == 2, "The number of degrees should be 2");
float t_lb = degrees[0];

11
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_decode_resize_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -79,11 +80,11 @@ Status RandomCropDecodeResizeOperation::to_json(nlohmann::json *out_json) {
Status RandomCropDecodeResizeOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("scale") != op_params.end(), "Failed to find scale");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("ratio") != op_params.end(), "Failed to find ratio");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("interpolation") != op_params.end(), "Failed to find interpolation");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("max_attempts") != op_params.end(), "Failed to find max_attempts");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kRandomCropDecodeResizeOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "scale", kRandomCropDecodeResizeOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "ratio", kRandomCropDecodeResizeOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "interpolation", kRandomCropDecodeResizeOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "max_attempts", kRandomCropDecodeResizeOperation));
std::vector<int32_t> size = op_params["size"];
std::vector<float> scale = op_params["scale"];
std::vector<float> ratio = op_params["ratio"];

13
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_ir.cc
View File

@ -16,12 +16,13 @@
#include <algorithm>
#include "minddata/dataset/kernels/ir/vision/random_crop_ir.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
#ifndef ENABLE_ANDROID
#include "minddata/dataset/kernels/image/random_crop_op.h"
#endif
#include "minddata/dataset/kernels/ir/validators.h"
namespace mindspore {
namespace dataset {
namespace vision {
@ -125,11 +126,11 @@ Status RandomCropOperation::to_json(nlohmann::json *out_json) {
}
Status RandomCropOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("padding") != op_params.end(), "Failed to find padding");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("pad_if_needed") != op_params.end(), "Failed to find pad_if_needed");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find fill_value");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("padding_mode") != op_params.end(), "Failed to find padding_mode");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kRandomCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "padding", kRandomCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "pad_if_needed", kRandomCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kRandomCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "padding_mode", kRandomCropOperation));
std::vector<int32_t> size = op_params["size"];
std::vector<int32_t> padding = op_params["padding"];
bool pad_if_needed = op_params["pad_if_needed"];

11
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_with_bbox_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -126,11 +127,11 @@ Status RandomCropWithBBoxOperation::to_json(nlohmann::json *out_json) {
}
Status RandomCropWithBBoxOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("padding") != op_params.end(), "Failed to find padding");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("pad_if_needed") != op_params.end(), "Failed to find pad_if_needed");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find fill_value");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("padding_mode") != op_params.end(), "Failed to find padding_mode");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kRandomCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "padding", kRandomCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "pad_if_needed", kRandomCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kRandomCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "padding_mode", kRandomCropWithBBoxOperation));
std::vector<int32_t> size = op_params["size"];
std::vector<int32_t> padding = op_params["padding"];
bool pad_if_needed = op_params["pad_if_needed"];

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_equalize_ir.cc
View File

@ -21,6 +21,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -49,7 +50,7 @@ Status RandomEqualizeOperation::to_json(nlohmann::json *out_json) {
}
Status RandomEqualizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomEqualizeOperation));
float prob = op_params["prob"];
*operation = std::make_shared<vision::RandomEqualizeOperation>(prob);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_horizontal_flip_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -50,7 +51,7 @@ Status RandomHorizontalFlipOperation::to_json(nlohmann::json *out_json) {
}
Status RandomHorizontalFlipOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomHorizontalFlipOperation));
float prob = op_params["prob"];
*operation = std::make_shared<vision::RandomHorizontalFlipOperation>(prob);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_horizontal_flip_with_bbox_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -53,7 +54,7 @@ Status RandomHorizontalFlipWithBBoxOperation::to_json(nlohmann::json *out_json)
Status RandomHorizontalFlipWithBBoxOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomHorizontalFlipWithBBoxOperation));
float prob = op_params["prob"];
*operation = std::make_shared<vision::RandomHorizontalFlipWithBBoxOperation>(prob);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_invert_ir.cc
View File

@ -20,6 +20,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -48,7 +49,7 @@ Status RandomInvertOperation::to_json(nlohmann::json *out_json) {
}
Status RandomInvertOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomInvertOperation));
float prob = op_params["prob"];
*operation = std::make_shared<vision::RandomInvertOperation>(prob);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_posterize_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -77,7 +78,7 @@ Status RandomPosterizeOperation::to_json(nlohmann::json *out_json) {
}
Status RandomPosterizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("bits") != op_params.end(), "Failed to find bits");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "bits", kRandomPosterizeOperation));
std::vector<uint8_t> bit_range = op_params["bits"];
*operation = std::make_shared<vision::RandomPosterizeOperation>(bit_range);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resize_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -64,7 +65,7 @@ Status RandomResizeOperation::to_json(nlohmann::json *out_json) {
}
Status RandomResizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kRandomResizeOperation));
std::vector<int32_t> size = op_params["size"];
*operation = std::make_shared<vision::RandomResizeOperation>(size);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resize_with_bbox_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -65,7 +66,7 @@ Status RandomResizeWithBBoxOperation::to_json(nlohmann::json *out_json) {
}
Status RandomResizeWithBBoxOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kRandomResizeWithBBoxOperation));
std::vector<int32_t> size = op_params["size"];
*operation = std::make_shared<vision::RandomResizeWithBBoxOperation>(size);
return Status::OK();

11
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resized_crop_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -96,11 +97,11 @@ Status RandomResizedCropOperation::to_json(nlohmann::json *out_json) {
}
Status RandomResizedCropOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("scale") != op_params.end(), "Failed to find scale");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("ratio") != op_params.end(), "Failed to find ratio");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("interpolation") != op_params.end(), "Failed to find interpolation");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("max_attempts") != op_params.end(), "Failed to find max_attempts");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kRandomResizedCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "scale", kRandomResizedCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "ratio", kRandomResizedCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "interpolation", kRandomResizedCropOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "max_attempts", kRandomResizedCropOperation));
std::vector<int32_t> size = op_params["size"];
std::vector<float> scale = op_params["scale"];
std::vector<float> ratio = op_params["ratio"];

11
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resized_crop_with_bbox_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -92,11 +93,11 @@ Status RandomResizedCropWithBBoxOperation::to_json(nlohmann::json *out_json) {
Status RandomResizedCropWithBBoxOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("scale") != op_params.end(), "Failed to find scale");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("ratio") != op_params.end(), "Failed to find ratio");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("interpolation") != op_params.end(), "Failed to find interpolation");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("max_attempts") != op_params.end(), "Failed to find max_attempts");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kRandomResizedCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "scale", kRandomResizedCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "ratio", kRandomResizedCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "interpolation", kRandomResizedCropWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "max_attempts", kRandomResizedCropWithBBoxOperation));
std::vector<int32_t> size = op_params["size"];
std::vector<float> scale = op_params["scale"];
std::vector<float> ratio = op_params["ratio"];

11
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_rotation_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -123,11 +124,11 @@ Status RandomRotationOperation::to_json(nlohmann::json *out_json) {
}
Status RandomRotationOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("degrees") != op_params.end(), "Failed to find degrees");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("resample") != op_params.end(), "Failed to find resample");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("expand") != op_params.end(), "Failed to find expand");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("center") != op_params.end(), "Failed to find center");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find fill_value");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "degrees", kRandomRotationOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "resample", kRandomRotationOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "expand", kRandomRotationOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "center", kRandomRotationOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kRandomRotationOperation));
std::vector<float> degrees = op_params["degrees"];
InterpolationMode resample = static_cast<InterpolationMode>(op_params["resample"]);
bool expand = op_params["expand"];

7
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_select_subpolicy_ir.cc
View File

@ -23,6 +23,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -100,14 +101,14 @@ Status RandomSelectSubpolicyOperation::to_json(nlohmann::json *out_json) {
Status RandomSelectSubpolicyOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("policy") != op_params.end(), "Failed to find policy");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "policy", kRandomSelectSubpolicyOperation));
nlohmann::json policy_json = op_params["policy"];
std::vector<std::vector<std::pair<std::shared_ptr<TensorOperation>, double>>> policy;
std::vector<std::pair<std::shared_ptr<TensorOperation>, double>> policy_items;
for (nlohmann::json item : policy_json) {
for (nlohmann::json item_pair : item) {
CHECK_FAIL_RETURN_UNEXPECTED(item_pair.find("prob") != item_pair.end(), "Failed to find prob");
CHECK_FAIL_RETURN_UNEXPECTED(item_pair.find("tensor_op") != item_pair.end(), "Failed to find tensor_op");
RETURN_IF_NOT_OK(ValidateParamInJson(item_pair, "prob", kRandomSelectSubpolicyOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(item_pair, "tensor_op", kRandomSelectSubpolicyOperation));
std::vector<std::shared_ptr<TensorOperation>> operations;
std::pair<std::shared_ptr<TensorOperation>, double> policy_pair;
std::shared_ptr<TensorOperation> operation;

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_sharpness_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -66,7 +67,7 @@ Status RandomSharpnessOperation::to_json(nlohmann::json *out_json) {
}
Status RandomSharpnessOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("degrees") != op_params.end(), "Failed to find degrees");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "degrees", kRandomSharpnessOperation));
std::vector<float> degrees = op_params["degrees"];
*operation = std::make_shared<vision::RandomSharpnessOperation>(degrees);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_solarize_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -71,7 +72,7 @@ Status RandomSolarizeOperation::to_json(nlohmann::json *out_json) {
}
Status RandomSolarizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("threshold") != op_params.end(), "Failed to find threshold");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "threshold", kRandomSolarizeOperation));
std::vector<uint8_t> threshold = op_params["threshold"];
*operation = std::make_shared<vision::RandomSolarizeOperation>(threshold);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_vertical_flip_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -51,7 +52,7 @@ Status RandomVerticalFlipOperation::to_json(nlohmann::json *out_json) {
}
Status RandomVerticalFlipOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomVerticalFlipOperation));
float prob = op_params["prob"];
*operation = std::make_shared<vision::RandomVerticalFlipOperation>(prob);
return Status::OK();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_vertical_flip_with_bbox_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -54,7 +55,7 @@ Status RandomVerticalFlipWithBBoxOperation::to_json(nlohmann::json *out_json) {
Status RandomVerticalFlipWithBBoxOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("prob") != op_params.end(), "Failed to find prob");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "prob", kRandomVerticalFlipWithBBoxOperation));
float prob = op_params["prob"];
*operation = std::make_shared<vision::RandomVerticalFlipWithBBoxOperation>(prob);
return Status::OK();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/rescale_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -56,8 +57,8 @@ Status RescaleOperation::to_json(nlohmann::json *out_json) {
}
Status RescaleOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("rescale") != op_params.end(), "Failed to find rescale");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("shift") != op_params.end(), "Failed to find shift");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "rescale", kRescaleOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "shift", kRescaleOperation));
float rescale = op_params["rescale"];
float shift = op_params["shift"];
*operation = std::make_shared<vision::RescaleOperation>(rescale, shift);

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/resize_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/image/resize_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -69,8 +70,8 @@ Status ResizeOperation::to_json(nlohmann::json *out_json) {
}
Status ResizeOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("interpolation") != op_params.end(), "Failed to find interpolation");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kResizeOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "interpolation", kResizeOperation));
std::vector<int32_t> size = op_params["size"];
InterpolationMode interpolation = static_cast<InterpolationMode>(op_params["interpolation"]);
*operation = std::make_shared<vision::ResizeOperation>(size, interpolation);

7
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/resize_preserve_ar_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/image/resize_preserve_ar_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -53,9 +54,9 @@ Status ResizePreserveAROperation::to_json(nlohmann::json *out_json) {
}
Status ResizePreserveAROperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("height") != op_params.end(), "Failed to find height");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("width") != op_params.end(), "Failed to find width");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("img_orientation") != op_params.end(), "Failed to find img_orientation");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "height", kResizePreserveAROperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "width", kResizePreserveAROperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "img_orientation", kResizePreserveAROperation));
int32_t height = op_params["height"];
int32_t width = op_params["width"];
int32_t img_orientation = op_params["img_orientation"];

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/resize_with_bbox_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -72,8 +73,8 @@ Status ResizeWithBBoxOperation::to_json(nlohmann::json *out_json) {
}
Status ResizeWithBBoxOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("interpolation") != op_params.end(), "Failed to find interpolation");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kResizeWithBBoxOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "interpolation", kResizeWithBBoxOperation));
std::vector<int32_t> size = op_params["size"];
InterpolationMode interpolation = static_cast<InterpolationMode>(op_params["interpolation"]);
*operation = std::make_shared<vision::ResizeWithBBoxOperation>(size, interpolation);

12
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/rotate_ir.cc
View File

@ -103,11 +103,11 @@ Status RotateOperation::to_json(nlohmann::json *out_json) {
Status RotateOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
#ifndef ENABLE_ANDROID
RETURN_IF_NOT_OK(ValidateParamInJson(op_params.find("degree") != op_params.end(), "degree"));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params.find("resample") != op_params.end(), "resample"));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params.find("expand") != op_params.end(), "expand"));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params.find("center") != op_params.end(), "center"));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params.find("fill_value") != op_params.end(), "fill_value"));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "degree", kRotateOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "resample", kRotateOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "expand", kRotateOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "center", kRotateOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kRotateOperation));
float degrees = op_params["degree"];
InterpolationMode resample = static_cast<InterpolationMode>(op_params["resample"]);
bool expand = op_params["expand"];
@ -115,7 +115,7 @@ Status RotateOperation::from_json(nlohmann::json op_params, std::shared_ptr<Tens
std::vector<uint8_t> fill_value = op_params["fill_value"];
*operation = std::make_shared<vision::RotateOperation>(degrees, resample, expand, center, fill_value);
#else
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("angle_id") != op_params.end(), "Failed to find angle_id");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "angle_id", kRotateOperation));
uint64_t angle_id = op_params["angle_id"];
std::shared_ptr<RotateOperation> rotate_operation =
std::make_shared<vision::RotateOperation>(FixRotationAngle::k0Degree);

9
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/slice_patches_ir.cc
View File

@ -18,6 +18,7 @@
#include "minddata/dataset/kernels/ir/vision/slice_patches_ir.h"
#include "minddata/dataset/kernels/image/slice_patches_op.h"
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -57,10 +58,10 @@ Status SlicePatchesOperation::to_json(nlohmann::json *out_json) {
}
Status SlicePatchesOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("num_height") != op_params.end(), "Failed to find num_height");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("num_width") != op_params.end(), "Failed to find num_width");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("slice_mode") != op_params.end(), "Failed to find slice_mode");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("fill_value") != op_params.end(), "Failed to find fill_value");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "num_height", kSlicePatchesOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "num_width", kSlicePatchesOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "slice_mode", kSlicePatchesOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "fill_value", kSlicePatchesOperation));
int32_t num_height = op_params["num_height"];
int32_t num_width = op_params["num_width"];
SliceMode slice_mode = static_cast<SliceMode>(op_params["slice_mode"]);

9
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/softdvpp_decode_random_crop_resize_jpeg_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -94,10 +95,10 @@ Status SoftDvppDecodeRandomCropResizeJpegOperation::to_json(nlohmann::json *out_
Status SoftDvppDecodeRandomCropResizeJpegOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("scale") != op_params.end(), "Failed to find scale");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("ratio") != op_params.end(), "Failed to find ratio");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("max_attempts") != op_params.end(), "Failed to find max_attempts");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kSoftDvppDecodeRandomCropResizeJpegOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "scale", kSoftDvppDecodeRandomCropResizeJpegOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "ratio", kSoftDvppDecodeRandomCropResizeJpegOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "max_attempts", kSoftDvppDecodeRandomCropResizeJpegOperation));
std::vector<int32_t> size = op_params["size"];
std::vector<float> scale = op_params["scale"];
std::vector<float> ratio = op_params["ratio"];

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/softdvpp_decode_resize_jpeg_ir.cc
View File

@ -22,6 +22,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -73,7 +74,7 @@ Status SoftDvppDecodeResizeJpegOperation::to_json(nlohmann::json *out_json) {
Status SoftDvppDecodeResizeJpegOperation::from_json(nlohmann::json op_params,
std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("size") != op_params.end(), "Failed to find size");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "size", kSoftDvppDecodeResizeJpegOperation));
std::vector<int32_t> size = op_params["size"];
*operation = std::make_shared<vision::SoftDvppDecodeResizeJpegOperation>(size);
return Status::OK();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/uniform_aug_ir.cc
View File

@ -23,6 +23,7 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -77,8 +78,8 @@ Status UniformAugOperation::to_json(nlohmann::json *out_json) {
}
Status UniformAugOperation::from_json(nlohmann::json op_params, std::shared_ptr<TensorOperation> *operation) {
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("transforms") != op_params.end(), "Failed to find transforms");
CHECK_FAIL_RETURN_UNEXPECTED(op_params.find("num_ops") != op_params.end(), "Failed to find num_ops");
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "transforms", kUniformAugOperation));
RETURN_IF_NOT_OK(ValidateParamInJson(op_params, "num_ops", kUniformAugOperation));
std::vector<std::shared_ptr<TensorOperation>> transforms = {};
RETURN_IF_NOT_OK(Serdes::ConstructTensorOps(op_params["transforms"], &transforms));
int32_t num_ops = op_params["num_ops"];

5
mindspore/ccsrc/minddata/dataset/kernels/py_func_op.cc
View File

@ -22,6 +22,7 @@
#include "minddata/dataset/kernels/tensor_op.h"
#include "minddata/dataset/kernels/ir/data/transforms_ir.h"
#include "minddata/dataset/util/status.h"
#include "minddata/dataset/util/validators.h"
namespace mindspore {
namespace dataset {
@ -134,8 +135,8 @@ Status PyFuncOp::to_json(nlohmann::json *out_json) {
Status PyFuncOp::from_json(nlohmann::json json_obj, std::vector<std::shared_ptr<TensorOperation>> *result) {
std::vector<std::shared_ptr<TensorOperation>> output;
CHECK_FAIL_RETURN_UNEXPECTED(json_obj.find("tensor_op_name") != json_obj.end(), "Failed to find tensor_op_name");
CHECK_FAIL_RETURN_UNEXPECTED(json_obj.find("tensor_op_params") != json_obj.end(), "Failed to find tensor_op_params");
RETURN_IF_NOT_OK(ValidateParamInJson(json_obj, "tensor_op_name", kPyFuncOp));
RETURN_IF_NOT_OK(ValidateParamInJson(json_obj, "tensor_op_params", kPyFuncOp));
std::string op_name = json_obj["tensor_op_name"];
nlohmann::json op_params = json_obj["tensor_op_params"];
std::string python_module = json_obj["python_module"];

9
mindspore/ccsrc/minddata/dataset/util/validators.h
View File

@ -17,6 +17,7 @@
#ifndef MINDSPORE_CCSRC_MINDDATA_DATASET_UTIL_VALIDATORS_H_
#define MINDSPORE_CCSRC_MINDDATA_DATASET_UTIL_VALIDATORS_H_
#include <nlohmann/json.hpp>
#include <string>
#include "minddata/dataset/util/status.h"
@ -24,9 +25,11 @@
namespace mindspore {
namespace dataset {
// validator Parameter in json file
inline Status ValidateParamInJson(const bool cond, const std::string &param_name) {
if (!cond) {
std::string err_msg = "Failed to find param '" + param_name + "' in json file for deserialize.";
inline Status ValidateParamInJson(nlohmann::json op_params, const std::string &param_name,
const std::string &operator_name) {
if (op_params.find(param_name) == op_params.end()) {
std::string err_msg = "Failed to find parameter '" + param_name + "' of '" + operator_name +
"' operator in input json file or input dict, check input parameter of API 'deserialize.";
RETURN_STATUS_UNEXPECTED(err_msg);
}
return Status::OK();