tf.contrib.training.HParams

Class to hold a set of hyperparameters as name-value pairs.

tf.contrib.training.HParams(
    hparam_def=None, model_structure=None, **kwargs
)

A HParams object holds hyperparameters used to build and train a model, such as the number of hidden units in a neural net layer or the learning rate to use when training.

You first create a HParams object by specifying the names and values of the hyperparameters.

To make them easily accessible the parameter names are added as direct attributes of the class. A typical usage is as follows:

# Create a HParams object specifying names and values of the model
# hyperparameters:
hparams = HParams(learning_rate=0.1, num_hidden_units=100)

# The hyperparameter are available as attributes of the HParams object:
hparams.learning_rate ==> 0.1
hparams.num_hidden_units ==> 100

Hyperparameters have type, which is inferred from the type of their value passed at construction type. The currently supported types are: integer, float, boolean, string, and list of integer, float, boolean, or string.

You can override hyperparameter values by calling the parse() method, passing a string of comma separated name=value pairs. This is intended to make it possible to override any hyperparameter values from a single command-line flag to which the user passes 'hyper-param=value' pairs. It avoids having to define one flag for each hyperparameter.

The syntax expected for each value depends on the type of the parameter. See parse() for a description of the syntax.

Example:

# Define a command line flag to pass name=value pairs.
# For example using argparse:
import argparse
parser = argparse.ArgumentParser(description='Train my model.')
parser.add_argument('--hparams', type=str,
                    help='Comma separated list of "name=value" pairs.')
args = parser.parse_args()
...
def my_program():
  # Create a HParams object specifying the names and values of the
  # model hyperparameters:
  hparams = tf.contrib.training.HParams(
      learning_rate=0.1,
      num_hidden_units=100,
      activations=['relu', 'tanh'])

  # Override hyperparameters values by parsing the command line
  hparams.parse(args.hparams)

  # If the user passed `--hparams=learning_rate=0.3` on the command line
  # then 'hparams' has the following attributes:
  hparams.learning_rate ==> 0.3
  hparams.num_hidden_units ==> 100
  hparams.activations ==> ['relu', 'tanh']

  # If the hyperparameters are in json format use parse_json:
  hparams.parse_json('{"learning_rate": 0.3, "activations": "relu"}')

Args
`hparam_def`	Serialized hyperparameters, encoded as a hparam_pb2.HParamDef protocol buffer. If provided, this object is initialized by deserializing hparam_def. Otherwise **kwargs is used.
`model_structure`	An instance of ModelStructure, defining the feature crosses to be used in the Trial.
`**kwargs`	Key-value pairs where the key is the hyperparameter name and the value is the value for the parameter.

Raises
`ValueError`	If both `hparam_def` and initialization values are provided, or if one of the arguments is invalid.

Args
`name`	Name of the hyperparameter.
`value`	Value of the hyperparameter. Can be one of the following types: int, float, string, int list, float list, or string list.

Raises
`KeyError`	If a hyperparameter in `values_dict` doesn't exist.
`ValueError`	If `values_dict` cannot be parsed.

Raises
`KeyError`	If a hyperparameter in `values_json` doesn't exist.
`ValueError`	If `values_json` cannot be parsed.

Raises
`KeyError`	If the hyperparameter doesn't exist.
`ValueError`	If there is a type mismatch.

Args
`indent`	If a non-negative integer, JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0, or negative, will only insert newlines. `None` (the default) selects the most compact representation.
`separators`	Optional `(item_separator, key_separator)` tuple. Default is `(', ', ': ')`.
`sort_keys`	If `True`, the output dictionaries will be sorted by key.

tf.contrib.training.HParams

Example:

Args

Raises

Methods

add_hparam

del_hparam

from_proto

get

get_model_structure

override_from_dict

parse

parse_json

set_from_map

set_hparam

set_model_structure

to_json

to_proto

values

__contains__

`add_hparam`

`del_hparam`

`from_proto`

`get`

`get_model_structure`

`override_from_dict`

`parse`

`parse_json`

`set_from_map`

`set_hparam`

`set_model_structure`

`to_json`

`to_proto`

`values`

`contains`