def __init__(self, k=1, name=None, deterministic=False, random_state=None): super(MedianBlur, self).__init__(name=name, deterministic=deterministic, random_state=random_state) if eu.is_single_number(k): eu.do_assert( k % 2 != 0, "Expected k to be odd, got %d. Add or subtract 1." % (int(k), )) self.k = Deterministic(int(k)) elif eu.is_iterable(k): eu.do_assert(len(k) == 2) eu.do_assert(all([eu.is_single_number(ki) for ki in k])) eu.do_assert( k[0] % 2 != 0, "Expected k[0] to be odd, got %d. Add or subtract 1." % (int(k[0]), )) eu.do_assert( k[1] % 2 != 0, "Expected k[1] to be odd, got %d. Add or subtract 1." % (int(k[1]), )) self.k = DiscreteUniform(int(k[0]), int(k[1])) elif isinstance(k, StochasticParameter): self.k = k else: raise Exception( "Expected int, tuple/list with 2 entries or StochasticParameter. Got %s." % (type(k), ))
def __init__(self, other_param, minval=None, maxval=None): super(Clip, self).__init__() eu.do_assert(isinstance(other_param, StochasticParameter)) eu.do_assert(minval is None or eu.is_single_number(minval)) eu.do_assert(maxval is None or eu.is_single_number(maxval)) self.other_param = other_param self.minval = minval self.maxval = maxval
def __init__(self, sigma=0, name=None, deterministic=False, random_state=None): super(GaussianBlur, self).__init__(name=name, deterministic=deterministic, random_state=random_state) if eu.is_single_number(sigma): self.sigma = Deterministic(sigma) elif eu.is_iterable(sigma): eu.do_assert( len(sigma) == 2, "Expected tuple/list with 2 entries, got %d entries." % (len(sigma), )) self.sigma = Uniform(sigma[0], sigma[1]) elif isinstance(sigma, StochasticParameter): self.sigma = sigma else: raise Exception( "Expected float, int, tuple/list with 2 entries or StochasticParameter. Got %s." % (type(sigma), )) self.eps = 0.001 # epsilon value to estimate whether sigma is above 0
def __rtruediv__(self, other): if eu.is_single_number(other) or isinstance(other, StochasticParameter): return Divide(other, self) else: raise Exception( "Invalid datatypes in: %s / StochasticParameter (truediv). Expected second argument to be number or StochasticParameter." % (type(other), ))
def __rmul__(self, other): if eu.is_single_number(other) or isinstance(other, StochasticParameter): return Multiply(other, self) else: raise Exception( "Invalid datatypes in: %s * StochasticParameter. Expected second argument to be number or StochasticParameter." % (type(other), ))
def __sub__(self, other): if eu.is_single_number(other) or isinstance(other, StochasticParameter): return Subtract(self, other) else: raise Exception( "Invalid datatypes in: StochasticParameter - %s. Expected second argument to be number or StochasticParameter." % (type(other), ))
def handle_continuous_param(param, name, value_range=None, tuple_to_uniform=True, list_to_choice=True): def check_value_range(v): if value_range is None: return True elif isinstance(value_range, tuple): eu.do_assert(len(value_range) == 2) if value_range[0] is None and value_range[1] is None: return True elif value_range[0] is None: eu.do_assert( v <= value_range[1], "Parameter '%s' is outside " "of the expected value range (x <= %.4f)" % (name, value_range[1])) return True elif value_range[1] is None: eu.do_assert( value_range[0] <= v, "Parameter '%s' is outside " "of the expected value range (%.4f <= x)" % (name, value_range[0])) return True else: eu.do_assert( value_range[0] <= v <= value_range[1], "Parameter '%s' is outside of the expected value range (%.4f <= x <= %.4f)" % (name, value_range[0], value_range[1])) return True elif eu.is_callable(value_range): value_range(v) return True else: raise Exception("Unexpected input for value_range, got %s." % (str(value_range), )) if eu.is_single_number(param): check_value_range(param) return Deterministic(param) elif tuple_to_uniform and isinstance(param, tuple): eu.do_assert(len(param) == 2) check_value_range(param[0]) check_value_range(param[1]) return Uniform(param[0], param[1]) elif list_to_choice and eu.is_iterable(param): for param_i in param: check_value_range(param_i) return Choice(param) elif isinstance(param, StochasticParameter): return param else: raise Exception( "Expected number, tuple of two number, list of number or StochasticParameter for %s, got %s." % ( name, type(param), ))
def __init__(self, p=0, name=None, deterministic=False, random_state=None): super(Flipud, self).__init__(name=name, deterministic=deterministic, random_state=random_state) if eu.is_single_number(p): self.p = Binomial(p) elif isinstance(p, StochasticParameter): self.p = p else: raise Exception("Expected p type StochasticParameter")
def __init__(self, value): super(Deterministic, self).__init__() if isinstance(value, StochasticParameter): self.value = value.draw_sample() elif eu.is_single_number(value) or eu.is_string(value): self.value = value else: raise Exception( "Expected StochasticParameter object or number or string, got %s." % (type(value), ))
def __rpow__(self, other, z=None): if z is not None: raise NotImplementedError( "Modulo power is currently not supported by StochasticParameter." ) if eu.is_single_number(other) or isinstance(other, StochasticParameter): return Power(other, self) else: raise Exception( "Invalid datatypes in: %s ** StochasticParameter. Expected second argument to be number or StochasticParameter." % (type(other), ))
def __init__(self, to_colorspace, from_colorspace="RGB", alpha=1.0, name=None, deterministic=False, random_state=None): super(ChangeColorspace, self).__init__(name=name, deterministic=deterministic, random_state=random_state) if eu.is_single_number(alpha): self.alpha = Deterministic(alpha) elif eu.is_iterable(alpha): eu.do_assert( len(alpha) == 2, "Expected tuple/list with 2 entries, got %d entries." % (len(alpha), )) self.alpha = Uniform(alpha[0], alpha[1]) elif isinstance(alpha, StochasticParameter): self.alpha = alpha else: raise Exception( "Expected alpha to be int or float or tuple/list of ints/floats or StochasticParameter, got %s." % (type(alpha), )) if eu.is_string(to_colorspace): eu.do_assert(to_colorspace in ChangeColorspace.COLORSPACES) self.to_colorspace = Deterministic(to_colorspace) elif eu.is_iterable(to_colorspace): eu.do_assert( all([eu.is_string(colorspace) for colorspace in to_colorspace])) eu.do_assert( all([(colorspace in ChangeColorspace.COLORSPACES) for colorspace in to_colorspace])) self.to_colorspace = Choice(to_colorspace) elif isinstance(to_colorspace, StochasticParameter): self.to_colorspace = to_colorspace else: raise Exception( "Expected to_colorspace to be string, list of strings or StochasticParameter, got %s." % (type(to_colorspace), )) self.from_colorspace = from_colorspace eu.do_assert(self.from_colorspace in ChangeColorspace.COLORSPACES) eu.do_assert(from_colorspace != ChangeColorspace.GRAY) self.eps = 0.001 # epsilon value to check if alpha is close to 1.0 or 0.0
def __init__(self, loc, scale): super(Normal, self).__init__() if isinstance(loc, StochasticParameter): self.loc = loc elif eu.is_single_number(loc): self.loc = Deterministic(loc) else: raise Exception( "Expected float, int or StochasticParameter as loc, got %s." % (type(loc), )) if isinstance(scale, StochasticParameter): self.scale = scale elif eu.is_single_number(scale): eu.do_assert( scale >= 0, "Expected scale to be in range [0, inf) got %s (type %s)." % (scale, type(scale))) self.scale = Deterministic(scale) else: raise Exception( "Expected float, int or StochasticParameter as scale, got %s." % (type(scale), ))
def __init__(self, value=0, per_channel=False, name=None, deterministic=False, random_state=None): super(Add, self).__init__(name=name, deterministic=deterministic, random_state=random_state) if eu.is_single_integer(value): eu.do_assert( -255 <= value <= 255, "Expected value to have range [-255, 255], got value %d." % (value, )) self.value = Deterministic(value) elif eu.is_iterable(value): eu.do_assert( len(value) == 2, "Expected tuple/list with 2 entries, got %d entries." % (len(value), )) self.value = DiscreteUniform(value[0], value[1]) elif isinstance(value, StochasticParameter): self.value = value else: raise Exception( "Expected float or int, tuple/list with 2 entries or StochasticParameter. Got %s." % (type(value), )) if per_channel in [True, False, 0, 1, 0.0, 1.0]: self.per_channel = Deterministic(int(per_channel)) elif eu.is_single_number(per_channel): eu.do_assert( 0 <= per_channel <= 1.0, "Expected bool, or number in range [0, 1.0] for per_channel, got %s." % (type(per_channel), )) self.per_channel = Binomial(per_channel) else: raise Exception( "Expected per_channel to be boolean or number or StochasticParameter" )
def __init__(self, k=1, name=None, deterministic=False, random_state=None): super(AverageBlur, self).__init__(name=name, deterministic=deterministic, random_state=random_state) self.mode = "single" if eu.is_single_number(k): self.k = Deterministic(int(k)) elif eu.is_iterable(k): eu.do_assert(len(k) == 2) if all([eu.is_single_number(ki) for ki in k]): self.k = DiscreteUniform(int(k[0]), int(k[1])) elif all([isinstance(ki, StochasticParameter) for ki in k]): self.mode = "two" self.k = (k[0], k[1]) else: k_tuple = [None, None] if eu.is_single_number(k[0]): k_tuple[0] = Deterministic(int(k[0])) elif eu.is_iterable(k[0]) and all( [eu.is_single_number(ki) for ki in k[0]]): k_tuple[0] = DiscreteUniform(int(k[0][0]), int(k[0][1])) else: raise Exception( "k[0] expected to be int or tuple of two ints, got %s" % (type(k[0]), )) if eu.is_single_number(k[1]): k_tuple[1] = Deterministic(int(k[1])) elif eu.is_iterable(k[1]) and all( [eu.is_single_number(ki) for ki in k[1]]): k_tuple[1] = DiscreteUniform(int(k[1][0]), int(k[1][1])) else: raise Exception( "k[1] expected to be int or tuple of two ints, got %s" % (type(k[1]), )) self.mode = "two" self.k = k_tuple elif isinstance(k, StochasticParameter): self.k = k else: raise Exception( "Expected int, tuple/list with 2 entries or StochasticParameter. Got %s." % (type(k), ))