def test_trainable_variables(self): """Tests the functionality of automatically collecting trainable variables. """ inputs = torch.rand(self._batch_size, self._max_time, self._input_size) # case 1 encoder = UnidirectionalRNNEncoder(input_size=self._input_size) _, _ = encoder(inputs) self.assertEqual(len(encoder.trainable_variables), 4) # case 2 hparams = {"rnn_cell": {"dropout": {"input_keep_prob": 0.5}}} encoder = UnidirectionalRNNEncoder(input_size=self._input_size, hparams=hparams) _, _ = encoder(inputs) self.assertEqual(len(encoder.trainable_variables), 4) # case 3 hparams = { "output_layer": { "num_layers": 2, "layer_size": [100, 6], "activation": "ReLU", "final_layer_activation": "Identity", "dropout_layer_ids": [0, 1, 2], "variational_dropout": False } } encoder = UnidirectionalRNNEncoder(input_size=self._input_size, hparams=hparams) _, _ = encoder(inputs) self.assertEqual(len(encoder.trainable_variables), 8)
def test_encode(self): """Tests encoding. """ # case 1 encoder = UnidirectionalRNNEncoder() max_time = 8 batch_size = 16 emb_dim = 100 inputs = tf.random_uniform([batch_size, max_time, emb_dim], maxval=1., dtype=tf.float32) outputs, state = encoder(inputs) cell_dim = encoder.hparams.rnn_cell.kwargs.num_units with self.test_session() as sess: sess.run(tf.global_variables_initializer()) outputs_, state_ = sess.run([outputs, state]) self.assertEqual(outputs_.shape, (batch_size, max_time, cell_dim)) self.assertEqual(state_[0].shape, (batch_size, cell_dim)) # case 2: with output layers hparams = { "output_layer": { "num_layers": 2, "layer_size": [100, 6], "dropout_layer_ids": [0, 1, 2], "variational_dropout": True } } encoder = UnidirectionalRNNEncoder(hparams=hparams) max_time = 8 batch_size = 16 emb_dim = 100 inputs = tf.random_uniform([batch_size, max_time, emb_dim], maxval=1., dtype=tf.float32) outputs, state, cell_outputs, output_size = encoder( inputs, return_cell_output=True, return_output_size=True) self.assertEqual(output_size[0], 6) self.assertEqual(cell_outputs.shape[-1], encoder.cell.output_size) out_dim = encoder.hparams.output_layer.layer_size[-1] with self.test_session() as sess: sess.run(tf.global_variables_initializer()) outputs_ = sess.run(outputs) self.assertEqual(outputs_.shape, (batch_size, max_time, out_dim))
def test_encode(self): r"""Tests encoding. """ inputs = torch.rand(self._batch_size, self._max_time, self._input_size) # case 1 encoder = UnidirectionalRNNEncoder(input_size=self._input_size) outputs, state = encoder(inputs) cell_dim = encoder.hparams.rnn_cell.kwargs.num_units self.assertEqual( outputs.shape, torch.Size([self._batch_size, self._max_time, cell_dim])) self.assertIsInstance(state, tuple) self.assertEqual(state[0].shape, torch.Size([self._batch_size, cell_dim])) self.assertEqual(state[1].shape, torch.Size([self._batch_size, cell_dim])) # case 2: with output layers hparams = { "output_layer": { "num_layers": 2, "layer_size": [100, 6], "dropout_layer_ids": [0, 1, 2], "variational_dropout": False } } encoder = UnidirectionalRNNEncoder(input_size=self._input_size, hparams=hparams) outputs, state, cell_outputs, output_size = encoder( inputs, return_cell_output=True, return_output_size=True) self.assertEqual(output_size, 6) self.assertEqual(cell_outputs.shape[-1], encoder.cell.hidden_size) out_dim = encoder.hparams.output_layer.layer_size[-1] self.assertEqual( outputs.shape, torch.Size([self._batch_size, self._max_time, out_dim]))
def test_trainable_variables(self): """Tests the functionality of automatically collecting trainable variables. """ inputs = tf.placeholder(dtype=tf.float32, shape=[None, None, 100]) # case 1 encoder = UnidirectionalRNNEncoder() _, _ = encoder(inputs) self.assertEqual(len(encoder.trainable_variables), 2) # case 2 hparams = { "rnn_cell": { "dropout": { "input_keep_prob": 0.5 } } } encoder = UnidirectionalRNNEncoder(hparams=hparams) _, _ = encoder(inputs) self.assertEqual(len(encoder.trainable_variables), 2) # case 3 hparams = { "output_layer": { "num_layers": 2, "layer_size": [100, 6], "activation": "relu", "final_layer_activation": "identity", "dropout_layer_ids": [0, 1, 2], "variational_dropout": False } } encoder = UnidirectionalRNNEncoder(hparams=hparams) _, _ = encoder(inputs) self.assertEqual(len(encoder.trainable_variables), 2+2+2) _, _ = encoder(inputs) self.assertEqual(len(encoder.trainable_variables), 2+2+2)
def __init__(self, cell=None, cell_dropout_mode=None, output_layer=None, hparams=None): ClassifierBase.__init__(self, hparams) with tf.variable_scope(self.variable_scope): # Creates the underlying encoder encoder_hparams = utils.dict_fetch( hparams, UnidirectionalRNNEncoder.default_hparams()) if encoder_hparams is not None: encoder_hparams['name'] = None self._encoder = UnidirectionalRNNEncoder( cell=cell, cell_dropout_mode=cell_dropout_mode, output_layer=output_layer, hparams=encoder_hparams) # Creates an additional classification layer if needed self._num_classes = self._hparams.num_classes if self._num_classes <= 0: self._logit_layer = None else: logit_kwargs = self._hparams.logit_layer_kwargs if logit_kwargs is None: logit_kwargs = {} elif not isinstance(logit_kwargs, HParams): raise ValueError( "hparams['logit_layer_kwargs'] must be a dict.") else: logit_kwargs = logit_kwargs.todict() logit_kwargs.update({"units": self._num_classes}) if 'name' not in logit_kwargs: logit_kwargs['name'] = "logit_layer" layer_hparams = {"type": "Dense", "kwargs": logit_kwargs} self._logit_layer = layers.get_layer(hparams=layer_hparams)
def default_hparams(): """Returns a dictionary of hyperparameters with default values. TODO final_time, all_time, time_wise, """ hparams = UnidirectionalRNNEncoder.default_hparams() hparams.update({ "num_classes": 2, "logit_layer_kwargs": None, "clas_strategy": "final_time", "max_seq_length": None, "name": "unidirectional_rnn_classifier" }) return hparams
def test_encode_with_embedder(self): """Tests encoding companioned with :mod:`texar.modules.embedders`. """ embedder = WordEmbedder(vocab_size=20, hparams={"dim": 100}) inputs = tf.ones([64, 16], dtype=tf.int32) encoder = UnidirectionalRNNEncoder() outputs, state = encoder(embedder(inputs)) cell_dim = encoder.hparams.rnn_cell.kwargs.num_units with self.test_session() as sess: sess.run(tf.global_variables_initializer()) outputs_, state_ = sess.run([outputs, state]) self.assertEqual(outputs_.shape, (64, 16, cell_dim)) self.assertEqual(state_[0].shape, (64, cell_dim))
def default_hparams(): """Returns a dictionary of hyperparameters with default values. .. code-block:: python { # (1) Same hyperparameters as in UnidirectionalRNNEncoder ... # (2) Additional hyperparameters "num_classes": 2, "logit_layer_kwargs": None, "clas_strategy": "final_time", "max_seq_length": None, "name": "unidirectional_rnn_classifier" } Here: 1. Same hyperparameters as in :class:`~texar.modules.UnidirectionalRNNEncoder`. See the :meth:`~texar.modules.UnidirectionalRNNEncoder.default_hparams`. An instance of UnidirectionalRNNEncoder is created for feature extraction. 2. Additional hyperparameters: "num_classes" : int Number of classes: - If **`> 0`**, an additional :tf_main:`Dense <layers/Dense>` \ layer is appended to the encoder to compute the logits over \ classes. - If **`<= 0`**, no dense layer is appended. The number of \ classes is assumed to be the final dense layer size of the \ encoder. "logit_layer_kwargs" : dict Keyword arguments for the logit Dense layer constructor, except for argument "units" which is set to "num_classes". Ignored if no extra logit layer is appended. "clas_strategy" : str The classification strategy, one of: - **"final_time"**: Sequence-leve classification based on \ the output of the final time step. One sequence has one class. - **"all_time"**: Sequence-level classification based on \ the output of all time steps. One sequence has one class. - **"time_wise"**: Step-wise classfication, i.e., make \ classification for each time step based on its output. "max_seq_length" : int, optional Maximum possible length of input sequences. Required if "clas_strategy" is "all_time". "name" : str Name of the classifier. """ hparams = UnidirectionalRNNEncoder.default_hparams() hparams.update({ "num_classes": 2, "logit_layer_kwargs": None, "clas_strategy": "final_time", "max_seq_length": None, "name": "unidirectional_rnn_classifier" }) return hparams