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 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 __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 test_encode_with_embedder(self):
"""Tests encoding companioned with :mod:`texar.tf.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.tf.modules.UnidirectionalRNNEncoder`.
See the :meth:`~texar.tf.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