add description

matchzoo/auto/prepare.py

@@ -49,10 +49,7 @@ def prepare(
 
     context = {}
     if 'input_shapes' in new_preprocessor.context:
-        context['input_shapes'] = new_preprocessor.context['input_shapes']
-
-    if isinstance(model, models.DSSMModel):
-        params['input_shapes'] = context['input_shapes']
+        params['input_shapes'] = new_preprocessor.context['input_shapes']
 
     if 'with_embedding' in params:
         term_index = new_preprocessor.context['vocab_unit'].state['term_index']

matchzoo/models/__init__.py

@@ -1,16 +1,16 @@
 from .naive_model import NaiveModel
-from .dssm_model import DSSMModel
-from .cdssm_model import CDSSMModel
+from .dssm import DSSM
+from .cdssm import CDSSM
 from .dense_baseline_model import DenseBaselineModel
-from .arci_model import ArcI
+from .arci import ArcI
 from .arcii import ArcII
 from .match_pyramid import MatchPyramid
-from .knrm_model import KNRM
-from .conv_knrm_model import ConvKNRM
+from .knrm import KNRM
+from .conv_knrm import ConvKNRM
 from .duet import DUET
-from .drmmtks_model import DRMMTKSModel
+from .drmmtks import DRMMTKS
 from .drmm import DRMM
-from .anmm_model import ANMMModel
+from .anmm import ANMM
 from .mvlstm import MVLSTM
 
 import matchzoo

matchzoo/models/anmm_model.py → matchzoo/models/anmm.py

@@ -12,12 +12,12 @@
 logger = logging.getLogger(__name__)
 
 
-class ANMMModel(engine.BaseModel):
+class ANMM(engine.BaseModel):
     """
     ANMM Model.
 
     Examples:
-        >>> model = ANMMModel()
+        >>> model = ANMM()
         >>> model.guess_and_fill_missing_params(verbose=0)
         >>> model.build()
 
@@ -27,10 +27,14 @@ class ANMMModel(engine.BaseModel):
     def get_default_params(cls) -> engine.ParamTable:
         """:return: model default parameters."""
         params = super().get_default_params(with_embedding=True)
-        params.add(engine.Param('bin_num', 60))
-        params.add(engine.Param('dropout_rate', 0.1))
-        params.add(engine.Param('num_layers', 2))
-        params.add(engine.Param('hidden_sizes', [30, 30]))
+        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 build(self):

matchzoo/models/arcii.py

@@ -32,20 +32,34 @@ def get_default_params(cls) -> engine.ParamTable:
         params['optimizer'] = 'adam'
         opt_space = engine.hyper_spaces.choice(['adam', 'rmsprop', 'adagrad'])
         params.get('optimizer').hyper_space = opt_space
-        params.add(engine.Param('num_blocks', 1))
-        params.add(engine.Param('kernel_1d_count', 32))
-        params.add(engine.Param('kernel_1d_size', 3))
-        params.add(engine.Param('kernel_2d_count', [32]))
-        params.add(engine.Param('kernel_2d_size', [[3, 3]]))
-        params.add(engine.Param('activation', 'relu'))
-        params.add(engine.Param('pool_2d_size', [[2, 2]]))
+        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'])
+            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)
+            hyper_space=engine.hyper_spaces.quniform(low=0.0, high=0.8,
+                                                     q=0.01),
+            desc="The dropout rate."
         ))
         return params
 

matchzoo/models/cdssm_model.py → matchzoo/models/cdssm.py

@@ -9,7 +9,7 @@
 from keras.models import Model
 
 
-class CDSSMModel(engine.BaseModel):
+class CDSSM(engine.BaseModel):
     """
     CDSSM Model implementation.
 
@@ -19,7 +19,7 @@ class CDSSMModel(engine.BaseModel):
     Information Retrieval. (2014b)
 
     Examples:
-        >>> model = CDSSMModel()
+        >>> model = CDSSM()
         >>> model.params['optimizer'] = 'adam'
         >>> model.params['filters'] =  32
         >>> model.params['kernel_size'] = 3
@@ -35,14 +35,25 @@ def get_default_params(cls) -> engine.ParamTable:
         # 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('filters', 32))
-        params.add(engine.Param('kernel_size', 3))
-        params.add(engine.Param('strides', 1))
-        params.add(engine.Param('padding', 'same'))
-        params.add(engine.Param('conv_activation_func', 'relu'))
-        params.add(engine.Param('w_initializer', 'glorot_normal'))
-        params.add(engine.Param('b_initializer', 'zeros'))
-        params.add(engine.Param('dropout_rate', 0.3))
+        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 _create_base_network(self) -> typing.Callable:

matchzoo/models/drmmtks_model.py → matchzoo/models/drmmtks.py

@@ -10,12 +10,12 @@
 logger = logging.getLogger(__name__)
 
 
-class DRMMTKSModel(engine.BaseModel):
+class DRMMTKS(engine.BaseModel):
     """
     DRMMTKS Model.
 
     Examples:
-        >>> model = DRMMTKSModel()
+        >>> model = DRMMTKS()
         >>> model.params['embedding_input_dim'] = 10000
         >>> model.params['embedding_output_dim'] = 100
         >>> model.params['top_k'] = 20
@@ -39,7 +39,8 @@ def get_default_params(cls) -> engine.ParamTable:
         params['input_shapes'] = [(5,), (300,)]
         params.add(engine.Param(
             'top_k', value=10,
-            hyper_space=engine.hyper_spaces.quniform(low=2, high=100)
+            hyper_space=engine.hyper_spaces.quniform(low=2, high=100),
+            desc="Size of top-k pooling layer."
         ))
         return params
 

matchzoo/models/dssm_model.py → matchzoo/models/dssm.py

@@ -6,12 +6,12 @@
 from matchzoo import preprocessors
 
 
-class DSSMModel(engine.BaseModel):
+class DSSM(engine.BaseModel):
     """
     Deep structured semantic model.
 
     Examples:
-        >>> model = DSSMModel()
+        >>> model = DSSM()
         >>> model.params['mlp_num_layers'] = 3
         >>> model.params['mlp_num_units'] = 300
         >>> model.params['mlp_num_fan_out'] = 128

matchzoo/models/duet.py

@@ -18,12 +18,11 @@ class DUET(engine.BaseModel):
         >>> model.params['embedding_output_dim'] = 300
         >>> model.params['lm_filters'] = 32
         >>> model.params['lm_hidden_sizes'] = [64, 32]
-        >>> model.params['lm_dropout_rate'] = 0.5
+        >>> model.params['dropout_rate'] = 0.5
         >>> model.params['dm_filters'] = 32
         >>> model.params['dm_kernel_size'] = 3
         >>> model.params['dm_d_mpool'] = 4
         >>> model.params['dm_hidden_sizes'] = [64, 32]
-        >>> model.params['dm_dropout_rate'] = 0.5
         >>> model.guess_and_fill_missing_params(verbose=0)
         >>> model.build()
 
@@ -33,30 +32,41 @@ class DUET(engine.BaseModel):
     def get_default_params(cls):
         """Get default parameters."""
         params = super().get_default_params(with_embedding=True)
-        params.add(engine.Param('lm_filters', 32))
-        params.add(engine.Param('lm_hidden_sizes', [32]))
-        params.add(engine.Param('dm_filters', 32))
-        params.add(engine.Param('dm_kernel_size', 3))
-        params.add(engine.Param('dm_q_hidden_size', 32))
-        params.add(engine.Param('dm_d_mpool', 3))
-        params.add(engine.Param('dm_hidden_sizes', [32]))
-        params.add(engine.Param('padding', 'same'))
-        params.add(engine.Param('activation_func', 'relu'))
+        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(
-            'lm_dropout_rate', 0.5,
-            hyper_space=engine.hyper_spaces.quniform(low=0.0, high=0.8, q=0.02)
-        ))
-        params.add(engine.Param(
-            'dm_dropout_rate', 0.5,
-            hyper_space=engine.hyper_spaces.quniform(low=0.0, high=0.8, q=0.02)
-        ))
+            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
 
-    @classmethod
-    def get_default_preprocessor(cls):
-        """Get default preprocessor."""
-        return preprocessors.NaivePreprocessor()
-
     def build(self):
         """Build model."""
         query, doc = self._make_inputs()
@@ -73,15 +83,15 @@ def build(self):
             activation=self._params['activation_func']
         )(lm_xor)
 
-        lm_conv = keras.layers.Dropout(self._params['lm_dropout_rate'])(
+        lm_conv = keras.layers.Dropout(self._params['dropout_rate'])(
             lm_conv)
         lm_feat = keras.layers.Reshape((-1,))(lm_conv)
         for hidden_size in self._params['lm_hidden_sizes']:
             lm_feat = keras.layers.Dense(
                 hidden_size,
                 activation=self._params['activation_func']
             )(lm_feat)
-        lm_drop = keras.layers.Dropout(self._params['lm_dropout_rate'])(
+        lm_drop = keras.layers.Dropout(self._params['dropout_rate'])(
             lm_feat)
         lm_score = keras.layers.Dense(1)(lm_drop)
 
@@ -91,7 +101,7 @@ def build(self):
             padding=self._params['padding'],
             activation=self._params['activation_func']
         )(q_embed)
-        dm_q_conv = keras.layers.Dropout(self._params['dm_dropout_rate'])(
+        dm_q_conv = keras.layers.Dropout(self._params['dropout_rate'])(
             dm_q_conv)
         dm_q_mp = keras.layers.MaxPooling1D(
             pool_size=self._params['input_shapes'][0][0])(dm_q_conv)
@@ -107,7 +117,7 @@ def build(self):
             padding=self._params['padding'],
             activation=self._params['activation_func']
         )(d_embed)
-        dm_d_conv1 = keras.layers.Dropout(self._params['dm_dropout_rate'])(
+        dm_d_conv1 = keras.layers.Dropout(self._params['dropout_rate'])(
             dm_d_conv1)
         dm_d_mp = keras.layers.MaxPooling1D(
             pool_size=self._params['dm_d_mpool'])(dm_d_conv1)
@@ -116,14 +126,14 @@ def build(self):
             padding=self._params['padding'],
             activation=self._params['activation_func']
         )(dm_d_mp)
-        dm_d_conv2 = keras.layers.Dropout(self._params['dm_dropout_rate'])(
+        dm_d_conv2 = keras.layers.Dropout(self._params['dropout_rate'])(
             dm_d_conv2)
 
         h_dot = keras.layers.Lambda(self._hadamard_dot)([dm_q_rep, dm_d_conv2])
         dm_feat = keras.layers.Reshape((-1,))(h_dot)
         for hidden_size in self._params['dm_hidden_sizes']:
             dm_feat = keras.layers.Dense(hidden_size)(dm_feat)
-        dm_feat_drop = keras.layers.Dropout(self._params['dm_dropout_rate'])(
+        dm_feat_drop = keras.layers.Dropout(self._params['dropout_rate'])(
             dm_feat)
         dm_score = keras.layers.Dense(1)(dm_feat_drop)
 

matchzoo/models/knrm_model.py → matchzoo/models/knrm.py

@@ -32,17 +32,19 @@ def get_default_params(cls):
         """Get default parameters."""
         params = super().get_default_params(with_embedding=True)
         params.add(engine.Param(
-            'kernel_num', 11,
+            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(
-            'sigma', 0.1,
+            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('exact_sigma', value=0.001,
+        params.add(engine.Param(name='exact_sigma', value=0.001,
                                 desc="The `exact_sigma` denotes the `sigma` "
                                      "for exact match."))
         return params

matchzoo/models/match_pyramid.py

@@ -30,18 +30,30 @@ def get_default_params(cls) -> engine.ParamTable:
         params['optimizer'] = 'adam'
         opt_space = engine.hyper_spaces.choice(['adam', 'rmsprop', 'adagrad'])
         params.get('optimizer').hyper_space = opt_space
-        params.add(engine.Param('num_blocks', 1))
-        params.add(engine.Param('kernel_count', [32]))
-        params.add(engine.Param('kernel_size', [[3, 3]]))
-        params.add(engine.Param('activation', 'relu'))
-        params.add(engine.Param('dpool_size', [3, 10]))
+        params.add(engine.Param(name='num_blocks', value=1,
+                                desc="Number of convolution blocks."))
+        params.add(engine.Param(name='kernel_count', value=[32],
+                                desc="The kernel count of the 2D convolution "
+                                     "of each block."))
+        params.add(engine.Param(name='kernel_size', value=[[3, 3]],
+                                desc="The kernel size of the 2D convolution "
+                                     "of each block."))
+        params.add(engine.Param(name='activation', value='relu',
+                                desc="The activation function."))
+        params.add(engine.Param(name='dpool_size', value=[3, 10],
+                                desc="The max-pooling size of each block."))
         params.add(engine.Param(
             name='padding', value='same',
-            hyper_space=engine.hyper_spaces.choice(['same', 'valid', 'causal'])
+            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)
+            hyper_space=engine.hyper_spaces.quniform(low=0.0, high=0.8,
+                                                     q=0.01),
+            desc="The dropout rate."
         ))
         return params