def __init__(self, **kwargs):
"""Tuner."""
self._params = engine.ParamTable()
self._params.add(engine.Param('model', validator=self._validate_model))
self._params.add(
engine.Param('train_data',
validator=lambda data: isinstance(
data,
(matchzoo.DataPack, matchzoo.DataGenerator))))
self._params.add(
engine.Param(
'test_data',
validator=lambda data: isinstance(data, matchzoo.DataPack)))
self._params.add(
engine.Param('fit_kwargs', {},
validator=lambda x: isinstance(x, dict)))
self._params.add(
engine.Param('evaluate_kwargs', {},
validator=lambda x: isinstance(x, dict)))
self._params.add(
engine.Param('mode',
'minimize',
validator=lambda mode: mode in
('minimize', 'maximize')))
input_model_metrics = self._params['model']['task'].metrics
self._params.add(
engine.Param(
'optimizing_metric',
'loss',
validator=lambda metric: metric in input_model_metrics))
self._params.add(
engine.Param(
'num_evals',
32,
validator=lambda max_evals: isinstance(max_evals, int)))
self._params.add(
engine.Param('save_dir',
matchzoo.USER_TUNED_MODELS_DIR,
validator=lambda save_dir: bool(Path(save_dir))))
for key, value in kwargs:
self._params[key] = value
def get_default_params(cls) -> engine.ParamTable:
"""
Model default parameters.
The common usage is to instantiate :class:`matchzoo.engine.ModelParams`
first, then set the model specific parametrs.
Examples:
>>> class MyModel(BaseModel):
... def build(self):
... print(self._params['num_eggs'], 'eggs')
... print('and', self._params['ham_type'])
...
... @classmethod
... def get_default_params(cls):
... params = engine.ParamTable()
... params.add(engine.Param('num_eggs', 512))
... params.add(engine.Param('ham_type', 'Parma Ham'))
... return params
>>> my_model = MyModel()
>>> my_model.build()
512 eggs
and Parma Ham
Notice that all parameters must be serialisable for the entire model
to be serialisable. Therefore, it's strongly recommended to use python
native data types to store parameters.
:return: model parameters
"""
params = engine.ParamTable()
params.add(engine.Param('name'))
params.add(engine.Param('model_class', cls))
params.add(engine.Param('input_shapes'))
params.add(engine.Param('task'))
params.add(engine.Param('metrics'))
params.add(engine.Param('loss'))
params.add(engine.Param('optimizer'))
return params
def get_default_params(
cls,
with_embedding=False,
with_multi_layer_perceptron=False) -> engine.ParamTable:
"""
Model default parameters.
The common usage is to instantiate :class:`matchzoo.engine.ModelParams`
first, then set the model specific parametrs.
Examples:
>>> class MyModel(BaseModel):
... def build(self):
... print(self._params['num_eggs'], 'eggs')
... print('and', self._params['ham_type'])
...
... @classmethod
... def get_default_params(cls):
... params = engine.ParamTable()
... params.add(engine.Param('num_eggs', 512))
... params.add(engine.Param('ham_type', 'Parma Ham'))
... return params
>>> my_model = MyModel()
>>> my_model.build()
512 eggs
and Parma Ham
Notice that all parameters must be serialisable for the entire model
to be serialisable. Therefore, it's strongly recommended to use python
native data types to store parameters.
:return: model parameters
"""
params = engine.ParamTable()
params.add(
engine.Param(name='model_class',
value=cls,
desc="Model class. Used internally for save/load. "
"Changing this may cause unexpected behaviors."))
params.add(
engine.Param(
name='input_shapes',
desc="Dependent on the model and data. Should be set manually."
))
params.add(
engine.Param(
name='task',
desc="Decides model output shape, loss, and metrics."))
params.add(engine.Param(
name='optimizer',
value='adam',
))
if with_embedding:
params.add(
engine.Param(
name='with_embedding',
value=True,
desc="A flag used help `auto` module. Shouldn't be changed."
))
params.add(
engine.Param(
name='embedding_input_dim',
desc=
'Usually equals vocab size + 1. Should be set manually.'))
params.add(
engine.Param(name='embedding_output_dim',
desc='Should be set manually.'))
params.add(
engine.Param(name='embedding_trainable',
value=True,
desc='`True` to enable embedding layer training, '
'`False` to freeze embedding parameters.'))
if with_multi_layer_perceptron:
params.add(
engine.Param(
name='with_multi_layer_perceptron',
value=True,
desc=
"A flag of whether a multiple layer perceptron is used. "
"Shouldn't be changed."))
params.add(
engine.Param(
name='mlp_num_units',
value=64,
desc="Number of units in first `mlp_num_layers` layers.",
hyper_space=hyper_spaces.quniform(8, 256, 8)))
params.add(
engine.Param(
name='mlp_num_layers',
value=3,
desc="Number of layers of the multiple layer percetron.",
hyper_space=hyper_spaces.quniform(1, 6)))
params.add(
engine.Param(
name='mlp_num_fan_out',
value=32,
desc=
"Number of units of the layer that connects the multiple "
"layer percetron and the output.",
hyper_space=hyper_spaces.quniform(4, 128, 4)))
params.add(
engine.Param(name='mlp_activation_func',
value='relu',
desc='Activation function used in the multiple '
'layer perceptron.'))
return params