uisrnn.arguments

  1# Copyright 2018 Google LLC
  2#
  3# Licensed under the Apache License, Version 2.0 (the "License");
  4# you may not use this file except in compliance with the License.
  5# You may obtain a copy of the License at
  6#
  7#     https://www.apache.org/licenses/LICENSE-2.0
  8#
  9# Unless required by applicable law or agreed to in writing, software
 10# distributed under the License is distributed on an "AS IS" BASIS,
 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12# See the License for the specific language governing permissions and
 13# limitations under the License.
 14"""Arguments for UISRNN."""
 15
 16import argparse
 17
 18_DEFAULT_OBSERVATION_DIM = 256
 19
 20
 21def str2bool(value):
 22  """A function to convert string to bool value."""
 23  if value.lower() in {'yes', 'true', 't', 'y', '1'}:
 24    return True
 25  if value.lower() in {'no', 'false', 'f', 'n', '0'}:
 26    return False
 27  raise argparse.ArgumentTypeError('Boolean value expected.')
 28
 29
 30def parse_arguments():
 31  """Parse arguments.
 32
 33  Returns:
 34    A tuple of:
 35
 36      - `model_args`: model arguments
 37      - `training_args`: training arguments
 38      - `inference_args`: inference arguments
 39  """
 40  # model configurations
 41  model_parser = argparse.ArgumentParser(
 42      description='Model configurations.', add_help=False)
 43
 44  model_parser.add_argument(
 45      '--observation_dim',
 46      default=_DEFAULT_OBSERVATION_DIM,
 47      type=int,
 48      help='The dimension of the embeddings (e.g. d-vectors).')
 49
 50  model_parser.add_argument(
 51      '--rnn_hidden_size',
 52      default=512,
 53      type=int,
 54      help='The number of nodes for each RNN layer.')
 55  model_parser.add_argument(
 56      '--rnn_depth',
 57      default=1,
 58      type=int,
 59      help='The number of RNN layers.')
 60  model_parser.add_argument(
 61      '--rnn_dropout',
 62      default=0.2,
 63      type=float,
 64      help='The dropout rate for all RNN layers.')
 65  model_parser.add_argument(
 66      '--transition_bias',
 67      default=None,
 68      type=float,
 69      help='The value of p0, corresponding to Eq. (6) in the '
 70           'paper. If the value is given, we will fix to this value. If the '
 71           'value is None, we will estimate it from training data '
 72           'using Eq. (13) in the paper.')
 73  model_parser.add_argument(
 74      '--crp_alpha',
 75      default=1.0,
 76      type=float,
 77      help='The value of alpha for the Chinese restaurant process (CRP), '
 78           'corresponding to Eq. (7) in the paper. In this open source '
 79           'implementation, currently we only support using a given value '
 80           'of crp_alpha.')
 81  model_parser.add_argument(
 82      '--sigma2',
 83      default=None,
 84      type=float,
 85      help='The value of sigma squared, corresponding to Eq. (11) in the '
 86           'paper. If the value is given, we will fix to this value. If the '
 87           'value is None, we will estimate it from training data.')
 88  model_parser.add_argument(
 89      '--verbosity',
 90      default=3,
 91      type=int,
 92      help='How verbose will the logging information be. Higher value '
 93      'represents more verbose information. A general guideline: '
 94      '0 for fatals; 1 for errors; 2 for finishing important steps; '
 95      '3 for finishing less important steps; 4 or above for debugging '
 96      'information.')
 97  model_parser.add_argument(
 98      '--enable_cuda',
 99      default=True,
100      type=str2bool,
101      help='Whether we should use CUDA if it is avaiable. If False, we will '
102      'always use CPU.')
103
104  # training configurations
105  training_parser = argparse.ArgumentParser(
106      description='Training configurations.', add_help=False)
107
108  training_parser.add_argument(
109      '--optimizer',
110      '-o',
111      default='adam',
112      choices=['adam'],
113      help='The optimizer for training.')
114  training_parser.add_argument(
115      '--learning_rate',
116      '-l',
117      default=1e-3,
118      type=float,
119      help='The leaning rate for training.')
120  training_parser.add_argument(
121      '--train_iteration',
122      '-t',
123      default=20000,
124      type=int,
125      help='The total number of training iterations.')
126  training_parser.add_argument(
127      '--batch_size',
128      '-b',
129      default=10,
130      type=int,
131      help='The batch size for training.')
132  training_parser.add_argument(
133      '--num_permutations',
134      default=10,
135      type=int,
136      help='The number of permutations per utterance sampled in the training '
137           'data.')
138  training_parser.add_argument(
139      '--sigma_alpha',
140      default=1.0,
141      type=float,
142      help='The inverse gamma shape for estimating sigma2. This value is only '
143           'meaningful when sigma2 is not given, and estimated from data.')
144  training_parser.add_argument(
145      '--sigma_beta',
146      default=1.0,
147      type=float,
148      help='The inverse gamma scale for estimating sigma2. This value is only '
149           'meaningful when sigma2 is not given, and estimated from data.')
150  training_parser.add_argument(
151      '--regularization_weight',
152      '-r',
153      default=1e-5,
154      type=float,
155      help='The network regularization multiplicative.')
156  training_parser.add_argument(
157      '--grad_max_norm',
158      default=5.0,
159      type=float,
160      help='Max norm of the gradient.')
161  training_parser.add_argument(
162      '--enforce_cluster_id_uniqueness',
163      default=True,
164      type=str2bool,
165      help='Whether to enforce cluster ID uniqueness across different '
166           'training sequences. Only effective when the first input to fit() '
167           'is a list of sequences. In general, assume the cluster IDs for two '
168           'sequences are [a, b] and [a, c]. If the `a` from the two sequences '
169           'are not the same label, then this arg should be True.')
170
171  # inference configurations
172  inference_parser = argparse.ArgumentParser(
173      description='Inference configurations.', add_help=False)
174
175  inference_parser.add_argument(
176      '--beam_size',
177      '-s',
178      default=10,
179      type=int,
180      help='The beam search size for inference.')
181  inference_parser.add_argument(
182      '--look_ahead',
183      default=1,
184      type=int,
185      help='The number of look ahead steps during inference.')
186  inference_parser.add_argument(
187      '--test_iteration',
188      default=2,
189      type=int,
190      help='During inference, we concatenate M duplicates of the test '
191           'sequence, and run inference on this concatenated sequence. '
192           'Then we return the inference results on the last duplicate as the '
193           'final prediction for the test sequence.')
194
195  # a super parser for sanity checks
196  super_parser = argparse.ArgumentParser(
197      parents=[model_parser, training_parser, inference_parser])
198
199  # get arguments
200  super_parser.parse_args()
201  model_args, _ = model_parser.parse_known_args()
202  training_args, _ = training_parser.parse_known_args()
203  inference_args, _ = inference_parser.parse_known_args()
204
205  return (model_args, training_args, inference_args)