def __init__(self, num_params, layer_dims, layer_activations,
train_threshold_ratio, batch_size, keep_prob,
regularisation_coefficient, losses_list):
self.log = logging.getLogger(__name__)
start = time.time()
self.save_archive_filename = (
mlu.archive_foldername + "neural_net_archive_" +
mlu.datetime_to_string(datetime.datetime.now()) + "_"
# We include 6 random bytes for deduplication in case multiple nets
# are created at the same time.
+ base64.urlsafe_b64encode(nr.bytes(6)).decode() + ".ckpt")
self.log.info("Constructing net")
self.graph = tf.Graph()
self.tf_session = tf.Session(graph=self.graph)
if not len(layer_dims) == len(layer_activations):
self.log.error('len(layer_dims) != len(layer_activations)')
raise ValueError
# Hyperparameters for the net. These are all constant.
self.num_params = num_params
self.train_threshold_ratio = train_threshold_ratio
self.batch_size = batch_size
self.keep_prob = keep_prob
self.regularisation_coefficient = regularisation_coefficient
self.losses_list = losses_list
with self.graph.as_default():
## Inputs
self.input_placeholder = tf.placeholder(
tf.float32, shape=[None, self.num_params])
self.output_placeholder = tf.placeholder(tf.float32,
shape=[None, 1])
self.keep_prob_placeholder = tf.placeholder_with_default(1.,
shape=[])
self.regularisation_coefficient_placeholder = tf.placeholder_with_default(
0., shape=[])
## Initialise the network
weights = []
biases = []
# Input + internal nodes
prev_layer_dim = self.num_params
bias_stddev = 0.5
for (i, dim) in enumerate(layer_dims):
weights.append(
tf.Variable(tf.random_normal([prev_layer_dim, dim],
stddev=1.4 /
np.sqrt(prev_layer_dim)),
name="weight_" + str(i)))
biases.append(
tf.Variable(tf.random_normal([dim], stddev=bias_stddev),
name="bias_" + str(i)))
prev_layer_dim = dim
# Output node
weights.append(
tf.Variable(tf.random_normal([prev_layer_dim, 1],
stddev=1.4 /
np.sqrt(prev_layer_dim)),
name="weight_out"))
biases.append(
tf.Variable(tf.random_normal([1], stddev=bias_stddev),
name="bias_out"))
# Get the output var given an input var
def get_output_var(input_var):
prev_h = input_var
for w, b, act in zip(weights[:-1], biases[:-1],
layer_activations):
prev_h = tf.nn.dropout(
act(tf.matmul(prev_h, w) + b),
keep_prob=self.keep_prob_placeholder)
return tf.matmul(prev_h, weights[-1]) + biases[-1]
## Define tensors for evaluating the output var and gradient on the full input
self.output_var = get_output_var(self.input_placeholder)
self.output_var_gradient = tf.gradients(self.output_var,
self.input_placeholder)
## Declare common loss functions
# Get the raw loss given the expected and actual output vars
def get_loss_raw(expected, actual):
return tf.reduce_mean(
tf.reduce_sum(tf.square(expected - actual),
reduction_indices=[1]))
# Regularisation component of the loss.
loss_reg = (self.regularisation_coefficient_placeholder *
tf.reduce_mean([tf.nn.l2_loss(W) for W in weights]))
## Define tensors for evaluating the loss on the full input
self.loss_raw = get_loss_raw(self.output_placeholder,
self.output_var)
self.loss_total = self.loss_raw + loss_reg
## Training
self.train_step = tf.train.AdamOptimizer().minimize(
self.loss_total)
# Initialiser for ... initialising
self.initialiser = tf.global_variables_initializer()
# Saver for saving and restoring params
self.saver = tf.train.Saver(write_version=tf.train.SaverDef.V2)
self.log.debug("Finished constructing net in: " +
str(time.time() - start))
def __init__(self, interface,
max_num_runs = float('+inf'),
target_cost = float('-inf'),
max_num_runs_without_better_params = float('+inf'),
controller_archive_filename=default_controller_archive_filename,
controller_archive_file_type=default_controller_archive_file_type,
archive_extra_dict = None,
start_datetime = None,
**kwargs):
#Make logger
self.remaining_kwargs = mlu._config_logger(**kwargs)
self.log = logging.getLogger(__name__)
#Variable that are included in archive
self.num_in_costs = 0
self.num_out_params = 0
self.num_last_best_cost = 0
self.out_params = []
self.out_type = []
self.out_extras = []
self.in_costs = []
self.in_uncers = []
self.in_bads = []
self.in_extras = []
self.best_cost = float('inf')
self.best_uncer = float('nan')
self.best_index = float('nan')
self.best_params = float('nan')
#Variables that used internally
self.last_out_params = None
self.curr_params = None
self.curr_cost = None
self.curr_uncer = None
self.curr_bad = None
self.curr_extras = None
#Constants
self.controller_wait = float(1)
#Learner related variables
self.learner_params_queue = None
self.learner_costs_queue = None
self.end_learner = None
self.learner = None
#Variables set by user
#save interface and extract important variables
if isinstance(interface, mli.Interface):
self.interface = interface
else:
self.log.error('interface is not a Interface as defined in the MLOOP package.')
raise TypeError
self.params_out_queue = interface.params_out_queue
self.costs_in_queue = interface.costs_in_queue
self.end_interface = interface.end_event
#Other options
if start_datetime is None:
self.start_datetime = datetime.datetime.now()
else:
self.start_datetime = datetime.datetime(start_datetime)
self.max_num_runs = float(max_num_runs)
if self.max_num_runs<=0:
self.log.error('Number of runs must be greater than zero. max_num_runs:'+repr(self.max_num_run))
raise ValueError
self.target_cost = float(target_cost)
self.max_num_runs_without_better_params = float(max_num_runs_without_better_params)
if self.max_num_runs_without_better_params<=0:
self.log.error('Max number of repeats must be greater than zero. max_num_runs:'+repr(max_num_runs_without_better_params))
raise ValueError
if mlu.check_file_type_supported(controller_archive_file_type):
self.controller_archive_file_type = controller_archive_file_type
else:
self.log.error('File in type is not supported:' + repr(controller_archive_file_type))
raise ValueError
if controller_archive_filename is None:
self.controller_archive_filename = None
else:
if not os.path.exists(mlu.archive_foldername):
os.makedirs(mlu.archive_foldername)
self.controller_archive_filename =str(controller_archive_filename)
self.total_archive_filename = mlu.archive_foldername + self.controller_archive_filename + '_' + mlu.datetime_to_string(self.start_datetime) + '.' + self.controller_archive_file_type
self.archive_dict = {'archive_type':'controller',
'num_out_params':self.num_out_params,
'out_params':self.out_params,
'out_type':self.out_type,
'out_extras':self.out_extras,
'in_costs':self.in_costs,
'in_uncers':self.in_uncers,
'in_bads':self.in_bads,
'in_extras':self.in_extras,
'max_num_runs':self.max_num_runs,
'start_datetime':mlu.datetime_to_string(self.start_datetime)}
if archive_extra_dict is not None:
self.archive_dict.update(archive_extra_dict)
self.log.debug('Controller init completed.')
def __init__(
self,
interface,
max_num_runs=float('+inf'),
target_cost=float('-inf'),
max_num_runs_without_better_params=float('+inf'),
controller_archive_filename=default_controller_archive_filename,
controller_archive_file_type=default_controller_archive_file_type,
archive_extra_dict=None,
start_datetime=None,
**kwargs):
#Make logger
self.remaining_kwargs = mlu._config_logger(**kwargs)
self.log = logging.getLogger(__name__)
#Variable that are included in archive
self.num_in_costs = 0
self.num_out_params = 0
self.num_last_best_cost = 0
self.out_params = []
self.out_type = []
self.out_extras = []
self.in_costs = []
self.in_uncers = []
self.in_bads = []
self.in_extras = []
self.best_cost = float('inf')
self.best_uncer = float('nan')
self.best_index = float('nan')
self.best_params = float('nan')
#Variables that used internally
self.last_out_params = None
self.curr_params = None
self.curr_cost = None
self.curr_uncer = None
self.curr_bad = None
self.curr_extras = None
#Constants
self.controller_wait = float(1)
#Learner related variables
self.learner_params_queue = None
self.learner_costs_queue = None
self.end_learner = None
self.learner = None
#Variables set by user
#save interface and extract important variables
if isinstance(interface, mli.Interface):
self.interface = interface
else:
self.log.error(
'interface is not a Interface as defined in the M-LOOP package.'
)
raise TypeError
self.params_out_queue = interface.params_out_queue
self.costs_in_queue = interface.costs_in_queue
self.end_interface = interface.end_event
#Other options
if start_datetime is None:
self.start_datetime = datetime.datetime.now()
else:
self.start_datetime = datetime.datetime(start_datetime)
self.max_num_runs = float(max_num_runs)
if self.max_num_runs <= 0:
self.log.error(
'Number of runs must be greater than zero. max_num_runs:' +
repr(self.max_num_run))
raise ValueError
self.target_cost = float(target_cost)
self.max_num_runs_without_better_params = float(
max_num_runs_without_better_params)
if self.max_num_runs_without_better_params <= 0:
self.log.error(
'Max number of repeats must be greater than zero. max_num_runs:'
+ repr(max_num_runs_without_better_params))
raise ValueError
if mlu.check_file_type_supported(controller_archive_file_type):
self.controller_archive_file_type = controller_archive_file_type
else:
self.log.error('File in type is not supported:' +
repr(controller_archive_file_type))
raise ValueError
if controller_archive_filename is None:
self.controller_archive_filename = None
else:
# Store self.controller_archive_filename without any path, but
# include any path components in controller_archive_filename when
# constructing the full path.
controller_archive_filename = str(controller_archive_filename)
self.controller_archive_filename = os.path.basename(
controller_archive_filename)
filename_suffix = mlu.generate_filename_suffix(
self.controller_archive_file_type,
file_datetime=self.start_datetime,
)
filename = controller_archive_filename + filename_suffix
self.total_archive_filename = os.path.join(mlu.archive_foldername,
filename)
# Include any path info from controller_archive_filename when
# creating directory for archive files.]
archive_dir = os.path.dirname(self.total_archive_filename)
if not os.path.exists(archive_dir):
os.makedirs(archive_dir)
self.archive_dict = {
'mloop_version': __version__,
'archive_type': 'controller',
'num_out_params': self.num_out_params,
'out_params': self.out_params,
'out_type': self.out_type,
'out_extras': self.out_extras,
'in_costs': self.in_costs,
'in_uncers': self.in_uncers,
'in_bads': self.in_bads,
'in_extras': self.in_extras,
'max_num_runs': self.max_num_runs,
'start_datetime': mlu.datetime_to_string(self.start_datetime)
}
if archive_extra_dict is not None:
self.archive_dict.update(archive_extra_dict)
self.log.debug('Controller init completed.')