hyperparameter_hunter.library_helpers package

Submodules

hyperparameter_hunter.library_helpers.keras_helper module

This module defines utilities for assisting in processing Keras Experiments

hyperparameter_hunter.library_helpers.keras_helper.keras_callback_to_key(callback)

Convert a Keras callback instance to a string that identifies it, along with the parameters

used to create it

Parameters

callback: Child instance of `keras.callbacks.Callback`

A Keras callback for which a key string describing it will be created

Returns

callback_key: String

A string identifying and describing callback

hyperparameter_hunter.library_helpers.keras_helper.keras_callback_to_dict(callback)

Convert a Keras callback instance to a dict that identifies it, along with the parameters used to create it

Parameters

callback: Child instance of `keras.callbacks.Callback`

A Keras callback for which a dict describing it will be created

Returns

callback_dict: Dict

A dict identifying and describing callback

hyperparameter_hunter.library_helpers.keras_helper.reinitialize_callbacks(callbacks)

Ensures the contents of callbacks are valid Keras callbacks

Parameters

callbacks: List

Expected to contain Keras callbacks, or dicts describing callbacks

Returns

callbacks: List

A validated list of Keras callbacks

hyperparameter_hunter.library_helpers.keras_helper.keras_initializer_to_dict(initializer)

hyperparameter_hunter.library_helpers.keras_helper.get_concise_params_dict(params, split_args=False)

hyperparameter_hunter.library_helpers.keras_helper.parameters_by_signature(instance, signature_filter=None)

Get a dict of the parameters used to create an instance of a class. This is only suited for classes whose attributes are named according to their input parameters

Parameters

instance: Class instance

Instance of a class that has attributes named for the class’s input parameters

signature_filter: Callable, or None, default=None

If not None, should be callable that expects as input (<arg_name>, <arg_val>), which are signature parameter names, and values, respectively. The callable should return a boolean: True if the pair should be added to params, or False if it should be ignored. If signature_filter is None, all signature parameters will be added to params

Returns

params: Dict

Mapping of input parameters in class’s __init__ signature to instance attribute values

hyperparameter_hunter.library_helpers.keras_helper.get_keras_attr(model, attr, max_depth=3, default=<object object at 0x7fe863a905d0>)

Retrieve specific Keras model attributes safely across different versions of Keras

Parameters

model: Instance of :class:`keras.wrappers.scikit_learn.<KerasClassifier; KerasRegressor>`

A compiled instance of a Keras model, made using the Keras wrappers.scikit_learn module

attr: String

Name of the attribute to retrieve from model

max_depth: Integer, default=3

Maximum number of times to check the “model” attribute of model for the target attr if attr itself is not in model before returning default or raising AttributeError

default: Object, default=object()

If given, default will be returned once max_depth attempts have been made to find attr in model. If not given and total attempts exceed max_depth, AttributeError is raised

Returns

Object

Value of attr for model (or a nested model if necessary), or None

hyperparameter_hunter.library_helpers.keras_helper.parameterize_compiled_keras_model(model)

Traverse a compiled Keras model to gather critical information about the layers used to construct its architecture, and the parameters used to compile it

Parameters

model: Instance of :class:`keras.wrappers.scikit_learn.<KerasClassifier; KerasRegressor>`

A compiled instance of a Keras model, made using the Keras wrappers.scikit_learn module. This must be a completely valid Keras model, which means that it often must be the result of library_helpers.keras_optimization_helper.initialize_dummy_model(). Using the resulting dummy model ensures the model will pass Keras checks that would otherwise reject instances of space.Space descendants used to provide hyperparameter choices

Returns

layers: List

A list containing a dict for each layer found in the architecture of model. A layer dict should contain the following keys: [‘class_name’, ‘__hh_default_args’, ‘__hh_default_kwargs’, ‘__hh_used_args’, ‘__hh_used_kwargs’]

compile_params: Dict

The parameters used on the call to model.compile(). If a value for a certain parameter was not explicitly provided, its default value will be included in compile_params

hyperparameter_hunter.library_helpers.keras_optimization_helper module

This module performs additional processing necessary when optimizing hyperparameters in the Keras library. Its purpose is twofold: 1) to enable the construction of Keras models while requiring minimal syntactic changes on the user’s end when defining hyperparameter space choices; and 2) to enable thorough collection of all hyperparameters used to define a Keras model - not only those being optimized - in order to ensure the continued usefulness of an Experiment’s result files even under different hyperparameter search constraints

Related

hyperparameter_hunter.importer

Performs interception of Keras import to inject the hyperparameter-recording attributes

hyperparameter_hunter.tracers

Defines the new metaclass used by hyperparameter_hunter.importer to apply to key Keras classes (like Layer)

hyperparameter_hunter.utils.parsing_utils

Defines utilities to assist in parsing source code provided by users to declare Keras model-building functions

hyperparameter_hunter.library_helpers.keras_helper

Defines utilities to assist in characterizing Keras models

hyperparameter_hunter.library_helpers.keras_optimization_helper.keras_prep_workflow(model_initializer, build_fn, extra_params, source_script)

Conduct preparation steps necessary before hyperparameter optimization on a Keras model. Such steps include parsing and modifying build_fn to be of the form used by hyperparameter_hunter.optimization.protocol_core.BaseOptPro, compiling a dummy model to identify universal locations of given hyperparameter choices, and creating a simplified characterization of the models to be built during optimization in order to enable similar Experiment collection

Parameters

model_initializer: :class:`keras.wrappers.scikit_learn.<KerasClassifier; KerasRegressor>`

A descendant of keras.wrappers.scikit_learn.BaseWrapper used to build a Keras model

build_fn: Callable

The build_fn value provided to keras.wrappers.scikit_learn.BaseWrapper.__init__(). Expected to return a compiled Keras model. May contain hyperparameter space choices

extra_params: Dict

The parameters expected to be passed to the extra methods of the compiled Keras model. Such methods include (but are not limited to) fit, predict, and predict_proba. Some of the common parameters given here include epochs, batch_size, and callbacks

source_script: Str

Absolute path to a Python file. Should end with one of following extensions: “.py”, “.ipynb”

Returns

reusable_build_fn: Callable

Modified build_fn in which hyperparameter space choices are replaced by dict lookups, and the signature is given a standard name, and additional input parameters necessary for reuse

reusable_wrapper_params: Dict

The parameters expected to be passed to the extra methods of the compiled Keras model. Such methods include (but are not limited to) fit, predict, and predict_proba. Some of the common parameters given here include epochs, batch_size, and callbacks

dummy_layers: List

The layers of a compiled dummy Keras model constructed according to the given hyperparameters, in which each layer is a dict containing at least the following: the name of the layer class, allowed and used args, and default and used kwargs

dummy_compile_params: Dict

The parameters used on the compile call for the dummy model. If a parameter is accepted by the compile method, but is not explicitly given, its default value is included in dummy_compile_params

hyperparameter_hunter.library_helpers.keras_optimization_helper.consolidate_layers(layers, class_name_key=True, split_args=False)

For each of the layer dicts in layers, merge the dict’s keys to reflect the end value of the key, rather than its default value, and whether a value was explicitly given

Parameters

layers: List

A list of dicts, wherein each dict represents a layer in a Keras model, and contains information about its arguments

class_name_key: Boolean, default=True

If True, “class_name” is added as a key to the dict describing each layer. Else, it will be used as a key to create an outer dict containing the rest of the keys describing each layer

split_args: Boolean, default=False

If True, each layer dict will be given two keys: “arg_vals”, and “kwarg_vals”, which are both dicts containing their respective values. Else, each layer dict will directly contain all the keys of “arg_vals”, and “kwarg_vals”, removing any indication of whether the parameter was a positional or keyword argument, aside from order

Returns

consolidated_layers: List

A list of the same length as layers, except each element has fewer keys than it did in layers. The new keys are as follows: [“class_name”, “arg_vals”, “kwarg_vals”]

hyperparameter_hunter.library_helpers.keras_optimization_helper.merge_compile_params(compile_params, dummified_params)

Update compile_params to reflect those values that were given hyperparameter space choices, as specified by dummified_params

Parameters

compile_params: Dict

All the compile parameters provided to a dummy model’s compile method, or their default values if they were not explicitly given. If the original value of one of the keys in compile_params was a hyperparameter space choice, its current value will be the dummy chosen for it, and this change will be reflected by the contents of dummified_params

dummified_params: Dict

A mapping of keys in compile_params (possibly nested keys) to a tuple pair of (<original hyperparameter space choice>, <tuple path to key>)

Returns

merged_params: Dict

A dictionary that mirrors compile_params, except where an element of dummified_params has the same path/key, in which case the hyperparameter space choice value in dummified_params is used

hyperparameter_hunter.library_helpers.keras_optimization_helper.check_dummy_params(params)

Locate and dummify hyperparameter space choices in params, if the hyperparameter is used for model compilation

Parameters

params: Dict

A dictionary of hyperparameters, in which values may be hyperparameter space choices

Returns

checked_params: Dict

A replica of params, in which instances of hyperparameter space choices are replaced with dummy values

dummified_params: Dict

A record of keys that were found whose values were hyperparameter space choices, mapped to tuple pairs of (<original value>, <path to key>)

hyperparameter_hunter.library_helpers.keras_optimization_helper.link_choice_ids(layers, compile_params, extra_params, dimensions)

Update extra_params to include a “location” attribute on any descendants of space.Dimension, specifying its position among all hyperparameters

Parameters

layers: List

A list of dicts, in which each dict describes a network layer

compile_params: Dict

A dict containing the hyperparameters supplied to the model’s compile call

extra_params: Dict

A dict containing the hyperparameters for the model’s extra methods, such as fit, predict, and predict_proba

dimensions: List

A list containing descendants of space.Dimension, representing the entire hyperparameter search space

Returns

extra_params: Dict

Mirrors the given extra_params, except any descendants of space.Dimension now have a “location” attribute

hyperparameter_hunter.library_helpers.keras_optimization_helper.initialize_dummy_model(model_initializer, build_fn, wrapper_params)

Creates a dummy model with placeholder values wherever hyperparameter options are provided via hyperparameter_hunter.space classes in order to produce a valid Keras model, albeit one with semi-useless values, which also contains attributes injected by hyperparameter_hunter.importer, and hyperparameter_hunter.tracers in order to keep a record of given hyperparameter choices

Parameters

model_initializer: :class:`keras.wrappers.scikit_learn.<KerasClassifier; KerasRegressor>`

A descendant of keras.wrappers.scikit_learn.BaseWrapper used to build a Keras model

build_fn: Callable

The build_fn value provided to keras.wrappers.scikit_learn.BaseWrapper.__init__()

wrapper_params: Dict

Additional parameters given to keras.wrappers.scikit_learn.BaseWrapper.__init__(), as sk_params. Some acceptable values include arguments of build_fn; and arguments for the fit, predict, predict_proba, and score methods. For further information on acceptable values see the Keras documentation

Returns

dummy: Instance of keras.wrappers.scikit_learn.

An initialized, compiled descendant of keras.wrappers.scikit_learn.BaseWrapper

hyperparameter_hunter.library_helpers.keras_optimization_helper.rewrite_model_builder(build_fn_source)

Convert the build function used to construct a Keras model to a reusable format by replacing usages of hyperparameter_hunter.space classes (Real, Integer, Categorical) with key lookups to a new build_fn input dict containing keys for each of the hyperparameter search space choices found in the original source code

Parameters

build_fn_source: String

The stringified source code of a callable (assumed to be Keras build_fn)

Returns

reusable_build_fn: String

The given build_fn_source, in which any usages of hyperparameter_hunter.space classes (Real, Integer, Categorical) are replaced with key lookups to a new build_fn input dict containing keys for each of the hyperparameter search space choices found in the original build_fn_source,

expected_params: collections.OrderedDict instance

A mapping of the names of the located hyperparameter choices to their given ranges (as described by hyperparameter_hunter.space classes)

hyperparameter_hunter.library_helpers.keras_optimization_helper.find_space_fragments(string)

Locate and name all hyperparameter choice declaration fragments in string

Parameters

string: String

A string assumed to be the source code of a Keras model-building function, in which hyperparameter choice declaration strings may be found

Returns

clipped_choices: List

All hyperparameter choice declaration strings found in string - in order of appearance

names: List

The names of all hyperparameter choice declarations in string - in order of appearance

start_indexes: List

The indexes at which each hyperparameter choice declaration string was found in string - in order of appearance

Examples

>>> find_space_fragments("foo")
([], [], [])

hyperparameter_hunter.library_helpers.keras_optimization_helper.is_space_match(string)

Determine whether string consists of a hyperparameter space declaration

Parameters

string: String

Str assumed to be source code fragment, which may contain a hyperparameter space declaration

Returns

Boolean

True if string begins with a valid hyperparameter space declaration. Else, False

hyperparameter_hunter.library_helpers.keras_optimization_helper.iter_fragments(string, is_match=None)

Yield fragments of string that are of a desired form as dictated by is_match

Parameters

string: String

A string containing fragments, which, when passed to is_match return True

is_match: Callable, or None, default=lambda _: False

Callable given a single string input that is a fragment of string, starting at any index. Expected to return boolean, which is truthy when the given fragment is of the desired form

Yields

String

Fragment of string starting at an index and continuing to the end, for which is_match returned a truthy value

Int

The index at which the aforementioned string fragment begins

hyperparameter_hunter.library_helpers.keras_optimization_helper.clean_parenthesized_string(string)

Produce a clipped substring of string comprising all characters from the beginning of string through the closing paren that matches the first opening paren in string

Parameters

string: String

A string that contains a parenthesized statement in its entirety, along with extra content to be removed. The target parenthesized statement may contain additional parentheses

Returns

clean_string: String

A substring of string, extending from the beginning of string, through the closing paren that matches the first opening paren found, producing a valid parenthesized statement

Module contents