def get_default_params(cls):
"""Get default parameters."""
params = super().get_default_params(with_embedding=True)
params.add(
engine.Param('lstm_num_units',
256,
hyper_space=engine.hyper_spaces.quniform(low=128,
high=384,
q=32),
desc="The hidden size in the LSTM layer."))
params.add(
engine.Param('fc_num_units',
200,
hyper_space=engine.hyper_spaces.quniform(low=100,
high=300,
q=20),
desc="The hidden size in the full connection layer."))
params.add(
engine.Param('dropout_rate',
0.0,
hyper_space=engine.hyper_spaces.quniform(low=0.0,
high=0.9,
q=0.01),
desc="The dropout rate."))
return params
def get_default_params(cls):
"""Get default parameters."""
params = super().get_default_params(with_embedding=True)
params.add(
engine.Param(name='lm_filters',
value=32,
desc="Filter size of 1D convolution layer in "
"the local model."))
params.add(
engine.Param(name='lm_hidden_sizes',
value=[32],
desc="A list of hidden size of the MLP layer "
"in the local model."))
params.add(
engine.Param(name='dm_filters',
value=32,
desc="Filter size of 1D convolution layer in "
"the distributed model."))
params.add(
engine.Param(name='dm_kernel_size',
value=3,
desc="Kernel size of 1D convolution layer in "
"the distributed model."))
params.add(
engine.Param(name='dm_q_hidden_size',
value=32,
desc="Hidden size of the MLP layer for the "
"left text in the distributed model."))
params.add(
engine.Param(name='dm_d_mpool',
value=3,
desc="Max pooling size for the right text in "
"the distributed model."))
params.add(
engine.Param(name='dm_hidden_sizes',
value=[32],
desc="A list of hidden size of the MLP layer "
"in the distributed model."))
params.add(
engine.Param(name='padding',
value='same',
desc="The padding mode in the convolution "
"layer. It should be one of `same`, "
"`valid`, "
"and `causal`."))
params.add(
engine.Param(name='activation_func',
value='relu',
desc="Activation function in the convolution"
" layer."))
params.add(
engine.Param(name='dropout_rate',
value=0.5,
hyper_space=engine.hyper_spaces.quniform(low=0.0,
high=0.8,
q=0.02),
desc="The dropout rate."))
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params(with_embedding=True)
params.add(engine.Param(name='dropout_rate', value=0.1,
desc="The dropout rate."))
params.add(engine.Param(name='num_layers', value=2,
desc="Number of hidden layers in the MLP "
"layer."))
params.add(engine.Param(name='hidden_sizes', value=[30, 30],
desc="Number of hidden size for each hidden"
" layer"))
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
# set :attr:`with_multi_layer_perceptron` to False to support
# user-defined variable dense layer units
params = super().get_default_params(with_multi_layer_perceptron=True)
params.add(engine.Param(name='filters', value=32,
desc="Number of filters in the 1D convolution "
"layer."))
params.add(engine.Param(name='kernel_size', value=3,
desc="Number of kernel size in the 1D "
"convolution layer."))
params.add(engine.Param(name='strides', value=1,
desc="Strides in the 1D convolution layer."))
params.add(engine.Param(name='padding', value='same',
desc="The padding mode in the convolution "
"layer. It should be one of `same`, "
"`valid`, ""and `causal`."))
params.add(engine.Param(name='conv_activation_func', value='relu',
desc="Activation function in the convolution"
" layer."))
params.add(engine.Param(name='w_initializer', value='glorot_normal'))
params.add(engine.Param(name='b_initializer', value='zeros'))
params.add(engine.Param(name='dropout_rate', value=0.3,
desc="The dropout rate."))
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params(with_embedding=True)
params['optimizer'] = 'adam'
opt_space = engine.hyper_spaces.choice(['adam', 'rmsprop', 'adagrad'])
params.get('optimizer').hyper_space = opt_space
params.add(
engine.Param(name='num_blocks',
value=1,
desc="Number of 2D convolution blocks."))
params.add(
engine.Param(name='kernel_1d_count',
value=32,
desc="Kernel count of 1D convolution layer."))
params.add(
engine.Param(name='kernel_1d_size',
value=3,
desc="Kernel size of 1D convolution layer."))
params.add(
engine.Param(name='kernel_2d_count',
value=[32],
desc="Kernel count of 2D convolution layer in"
"each block"))
params.add(
engine.Param(name='kernel_2d_size',
value=[[3, 3]],
desc="Kernel size of 2D convolution layer in"
" each block."))
params.add(
engine.Param(name='activation',
value='relu',
desc="Activation function."))
params.add(
engine.Param(name='pool_2d_size',
value=[[2, 2]],
desc="Size of pooling layer in each block."))
params.add(
engine.Param(
name='padding',
value='same',
hyper_space=engine.hyper_spaces.choice(
['same', 'valid', 'causal']),
desc=
"The padding mode in the convolution layer. It should be one"
"of `same`, `valid`, and `causal`."))
params.add(
engine.Param(name='dropout_rate',
value=0.0,
hyper_space=engine.hyper_spaces.quniform(low=0.0,
high=0.8,
q=0.01),
desc="The dropout rate."))
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params(
with_embedding=True, with_multi_layer_perceptron=True)
params.add(engine.Param(name='lstm_units', value=32,
desc="Integer, the hidden size in the "
"bi-directional LSTM layer."))
params.add(engine.Param(name='dropout_rate', value=0.0,
desc="Float, the dropout rate."))
params.add(engine.Param(
'top_k', value=10,
hyper_space=engine.hyper_spaces.quniform(low=2, high=100),
desc="Integer, the size of top-k pooling layer."
))
params['optimizer'] = 'adam'
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params(with_embedding=True,
with_multi_layer_perceptron=True)
params.add(
engine.Param(name='mask_value',
value=-1,
desc="The value to be masked from inputs."))
params['optimizer'] = 'adam'
params['input_shapes'] = [(5, ), (300, )]
params.add(
engine.Param('top_k',
value=10,
hyper_space=engine.hyper_spaces.quniform(low=2,
high=100),
desc="Size of top-k pooling layer."))
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params(with_embedding=True,
with_multi_layer_perceptron=True)
params['optimizer'] = 'adam'
params.add(
engine.Param(name='encode_filters',
value=128,
desc="The filter size of each convolution "
"blocks for encode."))
params.add(
engine.Param(name='encode_kernel_sizes',
value=[3],
desc="The kernel size of each convolution "
"blocks for the encode."))
params.add(
engine.Param(name='decode_filters',
value=128,
desc="The filter size of each convolution "
"blocks for decode."))
params.add(
engine.Param(name='decode_kernel_size',
value=3,
desc="The kernel size of each convolution "
"blocks for the decode."))
params.add(
engine.Param(name='conv_activation_func',
value='relu',
desc="The activation function in the "
"convolution layer."))
params.add(
engine.Param(name='pool_size',
value=4,
desc="pool size of max pooling"
"pool size of max pooling"))
params.add(
engine.Param(
name='padding',
value='same',
hyper_space=engine.hyper_spaces.choice(
['same', 'valid', 'causal']),
desc=
"The padding mode in the convolution layer. It should be one"
"of `same`, `valid`, and `causal`."))
params.add(
engine.Param('dropout_rate',
0.0,
hyper_space=engine.hyper_spaces.quniform(low=0.0,
high=0.8,
q=0.01),
desc="The dropout rate."))
return params
def get_default_params(cls):
"""Get default parameters."""
params = super().get_default_params(with_embedding=True)
params.add(engine.Param(
name='kernel_num',
value=11,
hyper_space=engine.hyper_spaces.quniform(low=5, high=20),
desc="The number of RBF kernels."
))
params.add(engine.Param(
name='sigma',
value=0.1,
hyper_space=engine.hyper_spaces.quniform(
low=0.01, high=0.2, q=0.01),
desc="The `sigma` defines the kernel width."
))
params.add(engine.Param(name='exact_sigma', value=0.001,
desc="The `exact_sigma` denotes the `sigma` "
"for exact match."))
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params()
params['optimizer'] = 'adam'
# TODO GET TRI-LETTER DIMENSIONALITY FROM FIT-TRANSFORM AS INPUT SHAPE
# Dimension: (NUM_TRI_LETTERS, DIM-TRILETTER )
params['input_shapes'] = [(None, 900), (None, 900)]
params.add(engine.Param('w_initializer', 'glorot_normal'))
params.add(engine.Param('b_initializer', 'zeros'))
params.add(engine.Param('dim_fan_out', 128))
params.add(engine.Param('dim_hidden', 300))
params.add(engine.Param('contextual_window', 3))
params.add(engine.Param('strides', 1))
params.add(engine.Param('padding', 'same'))
params.add(engine.Param('activation_hidden', 'tanh'))
params.add(engine.Param('num_hidden_layers', 1))
return params
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:
""":return: model default parameters."""
params = super().get_default_params(with_embedding=True,
with_multi_layer_perceptron=True)
params.add(
engine.Param(name='mask_value',
value=-1,
desc="The value to be masked from inputs."))
params['optimizer'] = 'adam'
params['input_shapes'] = [(5, ), (
5,
30,
)]
return params
def get_default_params(cls):
"""Get default parameters."""
params = super().get_default_params()
params.add(
engine.Param(name='filters',
value=128,
desc="The filter size in the convolution"
" layer."))
params.add(
engine.Param(name='conv_activation_func',
value='relu',
desc="The activation function in the "
"convolution layer."))
params.add(
engine.Param(name='max_ngram',
value=3,
desc="The maximum length of n-grams for the "
"convolution layer."))
params.add(
engine.Param(name='use_crossmatch',
value=True,
desc="Whether to match left n-grams and right "
"n-grams of different lengths"))
return params
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params()
params['optimizer'] = 'adam'
# TODO GET TRI-LETTER DIMENSIONALITY FROM FIT-TRANSFORM AS INPUT SHAPE
params['input_shapes'] = [(300, ), (300, )]
params.add(engine.Param('w_initializer', 'glorot_normal'))
params.add(engine.Param('b_initializer', 'zeros'))
params.add(engine.Param('dim_fan_out', 128))
params.add(engine.Param('dim_hidden', 300))
params.add(engine.Param('activation_hidden', 'tanh'))
params.add(engine.Param('num_hidden_layers', 2))
return params
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
def get_default_params(cls) -> engine.ParamTable:
""":return: model default parameters."""
params = super().get_default_params()
params['optimizer'] = 'adam'
params['input_shapes'] = [(32, ), (32, )]
params.add(engine.Param('trainable_embedding', False))
params.add(engine.Param('embedding_dim', 300))
params.add(engine.Param('vocab_size', 100))
params.add(engine.Param('num_blocks', 1))
params.add(engine.Param('left_kernel_count', [32]))
params.add(engine.Param('left_kernel_size', [3]))
params.add(engine.Param('right_kernel_count', [32]))
params.add(engine.Param('right_kernel_size', [3]))
params.add(engine.Param('activation', 'relu'))
params.add(engine.Param('left_pool_size', [16]))
params.add(engine.Param('right_pool_size', [16]))
params.add(engine.Param('padding', 'same'))
params.add(engine.Param('dropout_rate', 0.0))
params.add(
engine.Param(
'embedding_mat',
np.random.uniform(
-0.2, 0.2,
(params['vocab_size'], params['embedding_dim']))))
return params
