def new_method(self, *args, **kwargs): [image_batch_format, alpha, prob], _ = parse_user_args(method, *args, **kwargs) type_check(image_batch_format, (ImageBatchFormat,), "image_batch_format") check_pos_float32(alpha) check_positive(alpha, "alpha") check_value(prob, [0, 1], "prob") return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [length, num_patches], _ = parse_user_args(method, *args, **kwargs) check_value(length, (1, FLOAT_MAX_INTEGER)) check_value(num_patches, (1, FLOAT_MAX_INTEGER)) return method(self, *args, **kwargs)
def check_size_scale_ration_max_attempts_paras(size, scale, ratio, max_attempts): """Wrapper method to check the parameters of RandomCropDecodeResize and SoftDvppDecodeRandomCropResizeJpeg.""" check_crop_size(size) if scale is not None: type_check(scale, (tuple, list), "scale") if len(scale) != 2: raise TypeError("scale should be a list/tuple of length 2.") type_check_list(scale, (float, int), "scale") if scale[0] > scale[1]: raise ValueError( "scale should be in (min,max) format. Got (max,min).") check_range(scale, [0, FLOAT_MAX_INTEGER]) check_positive(scale[1], "scale[1]") if ratio is not None: type_check(ratio, (tuple, list), "ratio") if len(ratio) != 2: raise TypeError("ratio should be a list/tuple of length 2.") type_check_list(ratio, (float, int), "ratio") if ratio[0] > ratio[1]: raise ValueError( "ratio should be in (min,max) format. Got (max,min).") check_range(ratio, [0, FLOAT_MAX_INTEGER]) check_positive(ratio[0], "ratio[0]") check_positive(ratio[1], "ratio[1]") if max_attempts is not None: check_value(max_attempts, (1, FLOAT_MAX_INTEGER))
def check_normalize_py_param(mean, std): if len(mean) != len(std): raise ValueError("Length of mean and std must be equal.") for mean_value in mean: check_value(mean_value, [0., 1.], "mean_value") for std_value in std: check_value_normalize_std(std_value, [0., 1.], "std_value")
def new_method(self, *args, **kwargs): [batch_size, alpha, is_single], _ = parse_user_args(method, *args, **kwargs) check_value(batch_size, (1, FLOAT_MAX_INTEGER)) check_positive(alpha, "alpha") type_check(is_single, (bool,), "is_single") return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [transform, ratio], _ = parse_user_args(method, *args, **kwargs) type_check(ratio, (float, int), "ratio") check_value(ratio, [0., 1.], "ratio") if transform and getattr(transform, 'parse', None): transform = transform.parse() type_check(transform, (TensorOp, TensorOperation), "transform") return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [distortion_scale, prob, interpolation], _ = parse_user_args(method, *args, **kwargs) check_value(distortion_scale, [0., 1.], "distortion_scale") check_value(prob, [0., 1.], "prob") type_check(interpolation, (Inter,), "interpolation") return method(self, *args, **kwargs)
def check_normalize_c_param(mean, std): type_check(mean, (list, tuple), "mean") type_check(std, (list, tuple), "std") if len(mean) != len(std): raise ValueError("Length of mean and std must be equal.") for mean_value in mean: check_value(mean_value, [0, 255], "mean_value") for std_value in std: check_value_normalize_std(std_value, [0, 255], "std_value")
def new_method(self, *args, **kwargs): [prob], _ = parse_user_args(method, *args, **kwargs) type_check(prob, ( float, int, ), "prob") check_value(prob, [0., 1.], "prob") return method(self, *args, **kwargs)
def check_resize_size(size): """Wrapper method to check the parameters of resize.""" if isinstance(size, int): check_value(size, (1, FLOAT_MAX_INTEGER)) elif isinstance(size, (tuple, list)) and len(size) == 2: for i, value in enumerate(size): check_value(value, (1, INT32_MAX), "size at dim {0}".format(i)) else: raise TypeError("Size should be a single integer or a list/tuple (h, w) of length 2.")
def check_crop_size(size): """Wrapper method to check the parameters of crop size.""" type_check(size, (int, list, tuple), "size") if isinstance(size, int): check_value(size, (1, FLOAT_MAX_INTEGER)) elif isinstance(size, (tuple, list)) and len(size) == 2: for value in size: check_value(value, (1, FLOAT_MAX_INTEGER)) else: raise TypeError("Size should be a single integer or a list/tuple (h, w) of length 2.")
def check_padding(padding): """Parsing the padding arguments and check if it is legal.""" type_check(padding, (tuple, list, numbers.Number), "padding") if isinstance(padding, numbers.Number): check_value(padding, (0, INT32_MAX), "padding") if isinstance(padding, (tuple, list)): if len(padding) not in (2, 4): raise ValueError("The size of the padding list or tuple should be 2 or 4.") for i, pad_value in enumerate(padding): type_check(pad_value, (int,), "padding[{}]".format(i)) check_value(pad_value, (0, INT32_MAX), "pad_value")
def new_method(self, *args, **kwargs): [prob, scale, ratio, value, inplace, max_attempts], _ = parse_user_args(method, *args, **kwargs) check_value(prob, [0., 1.], "prob") check_range(scale, [0, FLOAT_MAX_INTEGER]) check_range(ratio, [0, FLOAT_MAX_INTEGER]) check_erasing_value(value) type_check(inplace, (bool,), "inplace") check_value(max_attempts, (1, FLOAT_MAX_INTEGER)) return method(self, *args, **kwargs)
def check_degrees(degrees): """Check if the degrees is legal.""" type_check(degrees, (numbers.Number, list, tuple), "degrees") if isinstance(degrees, numbers.Number): check_value(degrees, (0, float("inf")), "degrees") elif isinstance(degrees, (list, tuple)): if len(degrees) == 2: type_check_list(degrees, (numbers.Number,), "degrees") if degrees[0] > degrees[1]: raise ValueError("degrees should be in (min,max) format. Got (max,min).") else: raise TypeError("If degrees is a sequence, the length must be 2.")
def new_method(self, *args, **kwargs): [threshold], _ = parse_user_args(method, *args, **kwargs) type_check(threshold, (tuple,), "threshold") type_check_list(threshold, (int,), "threshold") if len(threshold) != 2: raise ValueError("threshold must be a sequence of two numbers.") for element in threshold: check_value(element, (0, UINT8_MAX)) if threshold[1] < threshold[0]: raise ValueError("threshold must be in min max format numbers.") return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [cutoff, ignore], _ = parse_user_args(method, *args, **kwargs) type_check(cutoff, (int, float), "cutoff") check_value_cutoff(cutoff, [0, 50], "cutoff") if ignore is not None: type_check(ignore, (list, tuple, int), "ignore") if isinstance(ignore, int): check_value(ignore, [0, 255], "ignore") if isinstance(ignore, (list, tuple)): for item in ignore: type_check(item, (int, ), "item") check_value(item, [0, 255], "ignore") return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [degrees, translate, scale, shear, resample, fill_value], _ = parse_user_args(method, *args, **kwargs) check_degrees(degrees) if translate is not None: type_check(translate, (list, tuple), "translate") type_check_list(translate, (int, float), "translate") if len(translate) != 2 and len(translate) != 4: raise TypeError( "translate should be a list or tuple of length 2 or 4.") for i, t in enumerate(translate): check_value(t, [-1.0, 1.0], "translate at {0}".format(i)) if scale is not None: type_check(scale, (tuple, list), "scale") type_check_list(scale, (int, float), "scale") if len(scale) == 2: if scale[0] > scale[1]: raise ValueError( "Input scale[1] must be equal to or greater than scale[0]." ) check_range(scale, [0, FLOAT_MAX_INTEGER]) check_positive(scale[1], "scale[1]") else: raise TypeError("scale should be a list or tuple of length 2.") if shear is not None: type_check(shear, (numbers.Number, tuple, list), "shear") if isinstance(shear, numbers.Number): check_positive(shear, "shear") else: type_check_list(shear, (int, float), "shear") if len(shear) not in (2, 4): raise TypeError("shear must be of length 2 or 4.") if len(shear) == 2 and shear[0] > shear[1]: raise ValueError( "Input shear[1] must be equal to or greater than shear[0]" ) if len(shear) == 4 and (shear[0] > shear[1] or shear[2] > shear[3]): raise ValueError( "Input shear[1] must be equal to or greater than shear[0] and " "shear[3] must be equal to or greater than shear[2].") type_check(resample, (Inter, ), "resample") if fill_value is not None: check_fill_value(fill_value) return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [prob, scale, ratio, value, inplace, max_attempts], _ = parse_user_args(method, *args, **kwargs) type_check(prob, (float, int,), "prob") type_check_list(scale, (float, int,), "scale") if len(scale) != 2: raise TypeError("scale should be a list or tuple of length 2.") type_check_list(ratio, (float, int,), "ratio") if len(ratio) != 2: raise TypeError("ratio should be a list or tuple of length 2.") type_check(value, (int, list, tuple, str), "value") type_check(inplace, (bool,), "inplace") type_check(max_attempts, (int,), "max_attempts") check_erasing_value(value) check_value(prob, [0., 1.], "prob") if scale[0] > scale[1]: raise ValueError("scale should be in (min,max) format. Got (max,min).") check_range(scale, [0, FLOAT_MAX_INTEGER]) check_positive(scale[1], "scale[1]") if ratio[0] > ratio[1]: raise ValueError("ratio should be in (min,max) format. Got (max,min).") check_value_ratio(ratio[0], [0, FLOAT_MAX_INTEGER]) check_value_ratio(ratio[1], [0, FLOAT_MAX_INTEGER]) if isinstance(value, int): check_value(value, (0, 255)) if isinstance(value, (list, tuple)): for item in value: type_check(item, (int,), "value") check_value(item, [0, 255], "value") check_value(max_attempts, (1, FLOAT_MAX_INTEGER)) return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [kernel_size, sigma], _ = parse_user_args(method, *args, **kwargs) type_check(kernel_size, (int, list, tuple), "kernel_size") if isinstance(kernel_size, int): check_value(kernel_size, (1, FLOAT_MAX_INTEGER), "kernel_size") check_odd(kernel_size, "kernel_size") elif isinstance(kernel_size, (list, tuple)) and len(kernel_size) == 2: for index, value in enumerate(kernel_size): type_check(value, (int, ), "kernel_size[{}]".format(index)) check_value(value, (1, FLOAT_MAX_INTEGER), "kernel_size") check_odd(value, "kernel_size[{}]".format(index)) else: raise TypeError( "Kernel size should be a single integer or a list/tuple (kernel_width, kernel_height) of length 2." ) if sigma is not None: type_check(sigma, (numbers.Number, list, tuple), "sigma") if isinstance(sigma, numbers.Number): check_value(sigma, (0, FLOAT_MAX_INTEGER), "sigma") elif isinstance(sigma, (list, tuple)) and len(sigma) == 2: for index, value in enumerate(sigma): type_check(value, (numbers.Number, ), "size[{}]".format(index)) check_value(value, (0, FLOAT_MAX_INTEGER), "sigma") else: raise TypeError( "Sigma should be a single number or a list/tuple of length 2 for width and height." ) return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [bits], _ = parse_user_args(method, *args, **kwargs) if bits is not None: type_check(bits, (list, tuple, int), "bits") if isinstance(bits, int): check_value(bits, [1, 8]) if isinstance(bits, (list, tuple)): if len(bits) != 2: raise TypeError("Size of bits should be a single integer or a list/tuple (min, max) of length 2.") for item in bits: check_uint8(item, "bits") # also checks if min <= max check_range(bits, [1, 8]) return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [policy], _ = parse_user_args(method, *args, **kwargs) type_check(policy, (list,), "policy") if not policy: raise ValueError("policy can not be empty.") for sub_ind, sub in enumerate(policy): type_check(sub, (list,), "policy[{0}]".format([sub_ind])) if not sub: raise ValueError("policy[{0}] can not be empty.".format(sub_ind)) for op_ind, tp in enumerate(sub): check_2tuple(tp, "policy[{0}][{1}]".format(sub_ind, op_ind)) check_tensor_op(tp[0], "op of (op, prob) in policy[{0}][{1}]".format(sub_ind, op_ind)) check_value(tp[1], (0, 1), "prob of (op, prob) policy[{0}][{1}]".format(sub_ind, op_ind)) return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [degrees], _ = parse_user_args(method, *args, **kwargs) if degrees is not None: if not isinstance(degrees, (list, tuple)): raise TypeError("degrees must be either a tuple or a list.") type_check_list(degrees, (int, float), "degrees") if len(degrees) != 2: raise ValueError("degrees must be a sequence with length 2.") for degree in degrees: check_value(degree, (0, FLOAT_MAX_INTEGER)) if degrees[0] > degrees[1]: raise ValueError("degrees should be in (min,max) format. Got (max,min).") return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [prob, scale, ratio, value, inplace, max_attempts], _ = parse_user_args(method, *args, **kwargs) check_value(prob, [0., 1.], "prob") if scale[0] > scale[1]: raise ValueError("scale should be in (min,max) format. Got (max,min).") check_range(scale, [0, FLOAT_MAX_INTEGER]) check_positive(scale[1], "scale[1]") if ratio[0] > ratio[1]: raise ValueError("ratio should be in (min,max) format. Got (max,min).") check_range(ratio, [0, FLOAT_MAX_INTEGER]) check_positive(ratio[0], "ratio[0]") check_positive(ratio[1], "ratio[1]") check_erasing_value(value) type_check(inplace, (bool,), "inplace") check_value(max_attempts, (1, FLOAT_MAX_INTEGER)) return method(self, *args, **kwargs)
def new_method(self, *args, **kwargs): [transform, ratio], _ = parse_user_args(method, *args, **kwargs) type_check(ratio, (float, int), "ratio") check_value(ratio, [0., 1.], "ratio") type_check(transform, (TensorOp,), "transform") return method(self, *args, **kwargs)