class_docstr: Class to hold a set of hyperparameters as name-value pairs.
  
  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:
  
  ```python
  # 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()`](#HParams.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:
  
  ```python
  # 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.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"}')
  ```
docstr: Create an instance of `HParams` from keyword arguments.
  
  The keyword arguments specify name-values pairs for the hyperparameters.
  The parameter types are inferred from the type of the values passed.
  
  The parameter names are added as attributes of `HParams` object, so they
  can be accessed directly with the dot notation `hparams._name_`.
  
  Example:
  
  ```python
  # Define 3 hyperparameters: 'learning_rate' is a float parameter,
  # 'num_hidden_units' an integer parameter, and 'activation' a string
  # parameter.
  hparams = tf.HParams(
      learning_rate=0.1, num_hidden_units=100, activation='relu')
  
  hparams.activation ==> 'relu'
  ```
  
  Note that a few names are reserved and cannot be used as hyperparameter
  names.  If you use one of the reserved name the constructor raises a
  `ValueError`.
  
  Args:
    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.
docstr_tok: ["Create","an","instance","of","`","HParams","`","from","keyword","arguments",".","The","keyword","arguments","specify","name-values","pairs","for","the","hyperparameters",".","The","parameter","types","are","inferred","from","the","type","of","the","values","passed",".","The","parameter","names","are","added","as","attributes","of","`","HParams","`","object",",","so","they","can","be","accessed","directly","with","the","dot","notation","`","hparams._name_","`",".","Example",":","``","`","python","#","Define","3","hyperparameters",":","'learning_rate","'","is","a","float","parameter",",","#","'num_hidden_units","'","an","integer","parameter",",","and","'activation","'","a","string","#","parameter",".","hparams","=","tf.HParams","(","learning_rate=0.1",",","num_hidden_units=100",",","activation='relu","'",")","hparams.activation","==",">","'relu'","``","`","Note","that","a","few","names","are","reserved","and","can","not","be","used","as","hyperparameter","names",".","If","you","use","one","of","the","reserved","name","the","constructor","raises","a","`","ValueError","`",".","Args",":","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","."]
code: def __init__(self, model_structure=None, **kwargs):
      """Create an instance of `HParams` from keyword arguments.
  
      The keyword arguments specify name-values pairs for the hyperparameters.
      The parameter types are inferred from the type of the values passed.
  
      The parameter names are added as attributes of `HParams` object, so they
      can be accessed directly with the dot notation `hparams._name_`.
  
      Example:
  
      ```python
      # Define 3 hyperparameters: 'learning_rate' is a float parameter,
      # 'num_hidden_units' an integer parameter, and 'activation' a string
      # parameter.
      hparams = tf.HParams(
          learning_rate=0.1, num_hidden_units=100, activation='relu')
  
      hparams.activation ==> 'relu'
      ```
  
      Note that a few names are reserved and cannot be used as hyperparameter
      names.  If you use one of the reserved name the constructor raises a
      `ValueError`.
  
      Args:
        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.
  
      """
      # Register the hyperparameters and their type in _hparam_types.
      # This simplifies the implementation of parse().
      # _hparam_types maps the parameter name to a tuple (type, bool).
      # The type value is the type of the parameter for scalar hyperparameters,
      # or the type of the list elements for multidimensional hyperparameters.
      # The bool value is True if the value is a list, False otherwise.
      self._hparam_types = {}
      self._model_structure = model_structure
      for name, value in six.iteritems(kwargs):
          self.add_hparam(name, value)
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import json
  import numbers
  import re
  import six
label_desc: Use image node_id 1 to create a new HParams object from inherited base classes: object with example: obj = HParams(model_structure)