def __init__(
self,
merge_mode: CategoricalValue("sum", "mul", "concat", "ave"),
units: DiscreteValue(32, 1024),
activation_fn: CategoricalValue("tanh", "sigmoid", "relu",
"linear"),
recurrent_activation_fn: CategoricalValue("tanh", "sigmoid",
"relu", "linear"),
dropout: ContinuousValue(0, 0.5),
recurrent_dropout: ContinuousValue(0, 0.5),
):
super().__init__(
layer=_LSTM(
units=units,
activation=activation_fn,
recurrent_activation=recurrent_activation_fn,
dropout=dropout,
recurrent_dropout=recurrent_dropout,
return_sequences=True,
),
merge_mode=merge_mode,
)
self.activation_fn = activation_fn
self.recurrent_activation_fn = recurrent_activation_fn
def __init__(
self,
preprocessor: KerasImagePreprocessor,
optimizer: CategoricalValue("sgd", "adam", "rmsprop"),
**kwargs,
):
self.preprocessor = preprocessor
super().__init__(optimizer=optimizer, **kwargs)
def __init__(self, units: DiscreteValue(32, 1024),
activation_fn: CategoricalValue("tanh", "sigmoid", "relu",
"linear"),
recurrent_activation_fn: CategoricalValue(
"tanh", "sigmoid", "relu",
"linear"), dropout: ContinuousValue(0, 0.5),
recurrent_dropout: ContinuousValue(0, 0.5), **kwargs):
super().__init__(units=units,
activation=activation_fn,
recurrent_activation=recurrent_activation_fn,
dropout=dropout,
recurrent_dropout=recurrent_dropout,
return_sequences=False,
**kwargs)
self.activation_fn = activation_fn
self.recurrent_activation_fn = recurrent_activation_fn
def __init__(
self,
decode: CategoricalValue("dense", "crf"),
optimizer: CategoricalValue("sgd", "adam", "rmsprop"),
grammar=None,
**kwargs,
):
self._classes = None
self._num_classes = None
if decode not in ["dense", "crf"]:
raise ValueError(f"Invalid decode={decode}")
self.decode = decode
super().__init__(grammar=grammar or self._build_grammar(),
optimizer=optimizer,
**kwargs)
def _get_args(cls):
full_specs = inspect.getfullargspec(cls.__init__)
args = full_specs.args
specs = full_specs.defaults
if not args or not specs:
return {}
non_kwargs = [arg for arg in args[:-len(specs):] if arg != "self"]
args = args[-len(specs):]
args_map = {k: v for k, v in zip(args, specs)}
drop_args = [
"url",
"n_jobs",
"max_iter",
"class_weight",
"warm_start",
"copy_X",
"copy_x",
"copy",
"eps",
"ignore_stopwords",
"verbose",
"load",
]
for arg in drop_args:
args_map.pop(arg, None)
result = {}
for arg, value in args_map.items():
values = _get_arg_values(arg, value, cls)
if not values:
continue
result[arg] = values
for arg in non_kwargs:
# special handling of language
if str.lower(arg) == "language":
values = _find_language_values(cls)
if values:
result[arg] = CategoricalValue(*values)
continue
if str.lower(arg) == "train" and _is_tagger(cls):
continue
raise Exception("No values found for positional argument %s " % (arg))
return result
def __init__(self,
merge_mode: CategoricalValue("avg", "first") = "avg",
*,
verbose=False): # , length: Discrete(16, 512)):
self.device = (torch.device("cuda")
if torch.cuda.is_available() else torch.device("cpu"))
self.verbose = verbose
self.print("Using device: %s" % self.device)
self.merge_mode = merge_mode
self.model = None
self.tokenizer = None
def __init__(
self,
optimizer: CategoricalValue("sgd", "adam", "rmsprop"),
grammar=None,
**kwargs,
):
self._classes = None
self._num_classes = None
super().__init__(grammar=grammar or self._build_grammar(),
optimizer=optimizer,
**kwargs)
def _get_arg_values(arg, value, cls):
if isinstance(value, bool):
return BooleanValue()
if isinstance(value, int):
return DiscreteValue(*_get_integer_values(arg, value, cls))
if isinstance(value, float):
return ContinuousValue(*_get_float_values(arg, value, cls))
if isinstance(value, str):
values = _find_parameter_values(arg, cls)
return CategoricalValue(*values) if values else None
return None
def __init__(self, function: CategoricalValue(
"elu",
"selu",
"relu",
"tanh",
"sigmoid",
"hard_sigmoid",
"exponential",
"linear",
), **kwargs):
self.function = function
super().__init__(activation=function, **kwargs)
def __init__(self, filters: DiscreteValue(2, 8),
kernel_size: CategoricalValue(3, 5, 7),
l1: ContinuousValue(0, 1e-3), l2: ContinuousValue(0, 1e-3),
**kwargs):
self.l1 = l1
self.l2 = l2
super().__init__(filters=2**filters,
kernel_size=(kernel_size, kernel_size),
kernel_regularizer=regularizers.l1_l2(l1=l1, l2=l2),
padding="same",
data_format="channels_last",
**kwargs)
def __init__(
self,
grammar: GraphGrammar,
optimizer: CategoricalValue("sgd", "adam", "rmsprop"),
epochs=10,
early_stop=3,
validation_split=0.1,
**compile_kwargs,
):
self.optimizer = optimizer
self._grammar = grammar
self._epochs = epochs
self._compile_kwargs = compile_kwargs
self._model: Optional[Model] = None
self._mode = "train"
self._graph = None
self._validation_split = validation_split
self._early_stop = early_stop
def _find_parameter_values(parameter, cls):
documentation = []
lines = cls.__doc__.split("\n")
while lines:
l = lines.pop(0)
if l.strip().startswith(parameter):
documentation.append(l)
tabs = l.index(parameter)
break
while lines:
l = lines.pop(0)
if not l.strip():
continue
if l.startswith(" " * (tabs + 1)):
documentation.append(l)
else:
break
options = set(re.findall(r"'(\w+)'", " ".join(documentation)))
valid = []
invalid = []
skip = set(["deprecated", "auto_deprecated", "precomputed"])
for opt in options:
opt = opt.lower()
if opt in skip:
continue
with warnings.catch_warnings():
warnings.simplefilter("ignore")
if _try(cls, parameter, opt):
valid.append(opt)
else:
invalid.append(opt)
if valid:
return CategoricalValue(*sorted(valid))
return None
def __init__(
self,
language: CategoricalValue("en", "es"),
extract_pos: BooleanValue(),
extract_lemma: BooleanValue(),
extract_pos_tag: BooleanValue(),
extract_dep: BooleanValue(),
extract_entity: BooleanValue(),
extract_details: BooleanValue(),
extract_sentiment: BooleanValue(),
):
self.language = language
self.extract_pos = extract_pos
self.extract_lemma = extract_lemma
self.extract_pos_tag = extract_pos_tag
self.extract_dep = extract_dep
self.extract_entity = extract_entity
self.extract_details = extract_details
self.extract_sentiment = extract_sentiment
self._nlp = None
def __init__(
self,
language: CategoricalValue(
"italian",
"portuguese",
"hungarian",
"english",
"german",
"arabic",
"danish",
"norwegian",
"finnish",
"dutch",
"romanian",
"russian",
"swedish",
"spanish",
"french",
),
):
self.language = language
NltkStemmer.__init__(self)
_SnowballStemmer.__init__(self, language=language)
def __init__(
self,
language: CategoricalValue(
"danish",
"dutch",
"english",
"finnish",
"french",
"german",
"hungarian",
"italian",
"norwegian",
"portuguese",
"russian",
"spanish",
"swedish",
"turkish",
),
):
self.language = language
from nltk.corpus import stopwords
self.words = stopwords.words(language)
SklearnTransformer.__init__(self)
def __init__(self, penalty: CategoricalValue("l1", "l2"),
C: ContinuousValue(0.1, 10)):
super().__init__(penalty=penalty, C=C, solver="liblinear")
def __init__(self, mode: CategoricalValue("mean", "max")):
self.mode = mode
def __init__(
self,
features: Subset("Subset", DiscreteValue(1, 5),
CategoricalValue("adam", "sgd")),
):
pass
def __init__(self, filters: DiscreteValue(2, 8),
kernel_size: CategoricalValue(3, 5, 7), **kwargs):
super().__init__(filters=2**filters,
kernel_size=kernel_size,
padding="causal",
**kwargs)
def __init__(self, criterion: CategoricalValue("gini", "entropy")):
super().__init__(criterion=criterion)
def __init__(self, x: CategoricalValue("A", "B", "C")):
self.x = x
def __init__(
self,
kernel: CategoricalValue("rbf", "linear", "poly"),
C: ContinuousValue(0.1, 10),
):
super().__init__(C=C, kernel=kernel)
