def _outer_loop(self):
hub = self.th
rnd = 0
for _ in range(hub.total_outer_loops):
rnd += 1
if hub.progress_bar:
console.section('{} {}'.format(hub.round_name, rnd))
hub.tic()
# Begin round (RNN states will be reset here) # TODO
# self.model.begin_round(th=self.th)
# Do inner loop
self._inner_loop(rnd)
# End of round
if hub.progress_bar:
console.show_status(
'End of {}. Elapsed time is {:.1f} secs'.format(
hub.round_name, hub.toc()))
# Maybe give a report on metric
if hub.validation_on:
self.model.end_round(rnd)
if self.metric.get_idle_rounds(rnd) > self.th.patience:
self.th.raise_stop_flag()
# Advanced strategy
self._advanced_strategy(rnd)
# Export monitor info
if tfr.monitor.activated: tfr.monitor.export()
# Maybe save model
if self._save_model_at_round_end: self._save_model()
# Early stop
if hub.stop and self.model.bust(rnd): break
return rnd
def identify(self, train_set, val_set=None):
# Sanity check
if not isinstance(train_set, DataSet):
raise TypeError('!! train_set must be a DataSet')
if val_set is not None and not isinstance(val_set, DataSet):
raise TypeError('!! val_set must be a DataSet')
if train_set.intensity is None:
raise TypeError('!! Intensity must not be None')
# Begin iteration
console.section('[Wiener] Begin Identification')
truth_norm, val_input, val_output = None, None, None
if val_set is not None:
val_input = val_set.signls[0]
val_output = val_set.responses[0]
truth_norm = val_output.norm
for i in range(len(train_set.signls)):
input_ = train_set.signls[i]
output = train_set.responses[i]
self.cross_correlation(input_, output, train_set.intensity)
status = 'Round {} finished. '.format(i + 1)
if val_set is not None:
pred = self(val_input)
delta = pred - val_output
err = delta.norm / truth_norm * 100
status += 'Error Ratio = {:.3f} %'.format(err)
console.show_status(status)
time.sleep(0.2)
console.show_status('Identification done.')
def run(self, strategy='grid', rehearsal=False, **kwargs):
"""Run script using the given 'strategy'. This method is compatible with
old version of tframe script_helper, and should be deprecated in the
future. """
# Show section
console.section('Script Information')
# Show pot configs
self._show_dict('Pot Configurations', self.configs)
# Hyper-parameter info will be showed when scroll is set
self.configure(**kwargs)
# Do some auto configuring, e.g., set greater_is_better based on the given
# criterion
self._auto_config()
self.pot.set_scroll(self.configs.get('strategy', strategy),
**self.configs)
# Show common parameters
self._show_dict('Common Settings', self.common_parameters)
# >>>>>>> 2c2bb62db734310d5ab5fa0cb66e970e161ddebc
# Begin iteration
for i, hyper_params in enumerate(self.pot.scroll.combinations()):
# Show hyper-parameters
console.show_info('Hyper-parameters:')
for k, v in hyper_params.items():
console.supplement('{}: {}'.format(k, v), level=2)
# Run process if not rehearsal
if rehearsal: continue
console.split()
# Export log if necessary
if self.pot.logging_is_needed: self._export_log()
# Run
self._run_process(hyper_params, i)
def _show_parameters(self):
console.section('Parameters')
def _show_config(name, od):
assert isinstance(od, OrderedDict)
if len(od) == 0: return
console.show_info(name)
for k, v in od.items():
console.supplement('{}: {}'.format(k, v), level=2)
_show_config('Common Settings', self.common_parameters)
_show_config('Hyper Parameters', self.hyper_parameters)
_show_config('Constraints', self.constraints)
print()
def _outer_loop(self):
hub = self.th
rnd = 0
for _ in range(hub.total_outer_loops):
rnd += 1
if self.is_online: console.section('Iterations Begin')
else: console.section('{} {}'.format(hub.round_name, rnd))
hub.tic()
# Do inner loop
self._inner_loop(rnd)
# End of round
if hub.progress_bar:
console.show_status(
'End of {}. Elapsed time is {:.1f} secs'.format(
hub.round_name, hub.toc()))
# Inc rounds for models training in epochs
if self.model.rounds is not None:
self.model.rounds += 1.0
# Maybe give a report on metric
if not self.is_online and hub.validation_on:
self.model.end_round(rnd)
if self.key_metric.get_idle_rounds(rnd) > self.th.patience:
self.th.raise_stop_flag()
# Maybe save model (model.rounds var has been increased)
if self._save_model_at_round_end: self._save_model()
break_flag = False
# Early stop via stop flag TODO: needed to be unified
if hub.stop and self.model.bust(rnd): break_flag = True
# Force terminate
if hub.force_terminate: break_flag = True
# Resurrect if possible
if break_flag and self._lives > 0:
self.resurrect(rnd)
if not self.metrics_manager.resurrected:
self.metrics_manager.resurrected = True
self.metrics_manager.rar0 = self.metrics_manager.early_stop_criterion
hub.force_terminate = False
break_flag = False
# Break if needed to
if break_flag: break
# Out of loop
if hub.gather_note:
if self.is_online:
self.model.agent.put_down_criterion('Total Iterations',
self.counter)
else:
self.model.agent.put_down_criterion('Total Rounds', rnd)
# Put down final weight fraction if etch is on
if self.th.etch_on:
frac = context.pruner.weights_fraction
self.model.agent.take_notes(
'Final weight fraction: {:.2f}%'.format(frac))
self.model.agent.put_down_criterion('Weight Fraction', frac)
# Evaluate the best model if necessary
ds_dict = OrderedDict()
if hub.evaluate_train_set: ds_dict['Train'] = self.training_set
if hub.evaluate_val_set: ds_dict['Val'] = self.validation_set
if hub.evaluate_test_set: ds_dict['Test'] = self.test_set
if len(ds_dict) > 0:
# Load the best model
if hub.save_model:
flag, _, _ = self.model.agent.load()
assert flag
# Evaluate the specified data sets
for name, data_set in ds_dict.items():
if not isinstance(data_set, TFRData):
raise TypeError('!! {} set is not a TFRData'.format(name))
# TODO
value = self.model.evaluate_model(
data_set, batch_size=hub.eval_batch_size)
title = '{} {}'.format(name,
self.metrics_manager.eval_slot.name)
self.model.agent.put_down_criterion(title, value)
self.model.agent.take_notes('{}: {}'.format(
title, hub.decimal_str(value, hub.val_decimals)))
# Save model here if necessary
if self._save_model_at_training_end:
assert len(ds_dict) == 0
self._save_model()
return rnd
def show_notes(self):
console.section('Notes')
console.write_line(self._note.content)
def train(self,
agent,
episodes=500,
print_cycle=0,
snapshot_cycle=0,
match_cycle=0,
rounds=100,
rate_thresh=1.0,
shadow=None,
save_cycle=100,
snapshot_function=None):
# Validate agent
if not isinstance(agent, FMDPAgent):
raise TypeError('Agent should be a FMDP-agent')
# Check settings TODO: codes should be reused
if snapshot_function is not None:
if not callable(snapshot_function):
raise ValueError('snapshot_function must be callable')
self._snapshot_function = snapshot_function
print_cycle = FLAGS.print_cycle if FLAGS.print_cycle >= 0 else print_cycle
snapshot_cycle = (FLAGS.snapshot_cycle
if FLAGS.snapshot_cycle >= 0 else snapshot_cycle)
match_cycle = FLAGS.match_cycle if FLAGS.match_cycle >= 0 else match_cycle
# Show configurations
console.show_status('Configurations:')
console.supplement('episodes: {}'.format(episodes))
# Do some preparation
if self._session is None:
self.launch_model()
assert isinstance(self._graph, tf.Graph)
with self._graph.as_default():
if self._merged_summary is None:
self._merged_summary = tf.summary.merge_all()
# Set opponent
if match_cycle > 0:
if shadow is None:
self._opponent = FMDRandomPlayer()
self._opponent.player_name = 'Random Player'
elif isinstance(shadow, TDPlayer):
self._opponent = shadow
self._opponent.player_name = 'Shadow_{}'.format(
self._opponent.counter)
else:
raise TypeError('Opponent should be an instance of TDPlayer')
# Begin training iteration
assert isinstance(agent, FMDPAgent)
console.section('Begin episodes')
for epi in range(1, episodes + 1):
# Initialize variable
agent.restart()
if hasattr(agent, 'default_first_move'):
agent.default_first_move()
# Record episode start time
start_time = time.time()
steps = 0
state = agent.state
summary = None
# Begin current episode
while not agent.terminated:
# Make a move
next_value = self.next_step(agent)
steps += 1
# Update model
state = np.reshape(state, (1, ) + state.shape)
next_value = np.reshape(np.array(next_value), (1, 1))
feed_dict = {
self.input_[0]: state,
self._next_value: next_value
}
feed_dict.update(self._get_status_feed_dict(is_training=True))
assert isinstance(self._session, tf.Session)
summary, _ = self._session.run(
[self._merged_summary, self._update_op], feed_dict)
state = agent.state
# End of current episode
self.counter += 1
assert isinstance(self._summary_writer, tf.summary.FileWriter)
self._summary_writer.add_summary(summary, self.counter)
if print_cycle > 0 and np.mod(self.counter, print_cycle) == 0:
self._print_progress(epi, start_time, steps, total=episodes)
if snapshot_cycle > 0 and np.mod(self.counter,
snapshot_cycle) == 0:
self._snapshot(epi / episodes)
if match_cycle > 0 and np.mod(self.counter, match_cycle) == 0:
self._training_match(agent, rounds, epi / episodes,
rate_thresh)
if np.mod(self.counter, save_cycle) == 0:
self._save(self.counter)
# End training
console.clear_line()
self._summary_writer.flush()
self.shutdown()
def train(self,
epoch=1,
batch_size=128,
training_set=None,
validation_set=None,
print_cycle=0,
snapshot_cycle=0,
snapshot_function=None,
probe=None,
**kwargs):
# Check data
if training_set is not None:
self._training_set = training_set
if validation_set is not None:
self._validation_set = validation_set
if self._training_set is None:
raise ValueError('!! Data for training not found')
elif not isinstance(training_set, TFData):
raise TypeError(
'!! Data for training must be an instance of TFData')
if probe is not None and not callable(probe):
raise TypeError('!! Probe must be callable')
if snapshot_function is not None:
if not callable(snapshot_function):
raise ValueError('!! snapshot_function must be callable')
self._snapshot_function = snapshot_function
self._init_smart_train(validation_set)
epoch_tol = FLAGS.epoch_tol
# Get epoch and batch size
epoch = FLAGS.epoch if FLAGS.epoch > 0 else epoch
batch_size = FLAGS.batch_size if FLAGS.batch_size > 0 else batch_size
assert isinstance(self._training_set, TFData)
self._training_set.set_batch_size(batch_size)
# Get print and snapshot cycles
print_cycle = FLAGS.print_cycle if FLAGS.print_cycle >= 0 else print_cycle
snapshot_cycle = (FLAGS.snapshot_cycle
if FLAGS.snapshot_cycle >= 0 else snapshot_cycle)
# Run pre-train method
self._pretrain(**kwargs)
# Show configurations
console.show_status('Configurations:')
console.supplement('Training set feature shape: {}'.format(
self._training_set.features.shape))
console.supplement('epochs: {}'.format(epoch))
console.supplement('batch size: {}'.format(batch_size))
# Do some preparation
if self._session is None:
self.launch_model()
if self._merged_summary is None:
self._merged_summary = tf.summary.merge_all()
# Begin iteration
with self._session.as_default():
for epc in range(epoch):
console.section('Epoch {}'.format(epc + 1))
# Add a new list to metric log if smart_train is on
if self._train_status['metric_on']: self._metric_log.append([])
# Record epoch start time
start_time = time.time()
while True:
# Get data batch
data_batch, end_epoch_flag = self._training_set.next_batch(
shuffle=FLAGS.shuffle and FLAGS.train)
# Increase counter, counter may be used in _update_model
self._counter += 1
# Update model
loss_dict = self._update_model(data_batch, **kwargs)
# Print status
if print_cycle > 0 and np.mod(self._counter - 1,
print_cycle) == 0:
loss_dict, new_record = self._update_loss_dict(
loss_dict, probe)
self._print_progress(epc,
start_time,
loss_dict,
data_batch=data_batch)
if new_record:
self._last_epoch = epc
if FLAGS.save_best and epc + 1 >= FLAGS.dont_save_until:
if FLAGS.save_model:
self._save(self._counter)
self._inter_cut('[New Record] Model saved')
# Snapshot
if (FLAGS.snapshot and snapshot_cycle > 0 and np.mod(
self._counter - 1, snapshot_cycle) == 0):
self._snapshot()
# Check flag
if end_epoch_flag:
if FLAGS.progress_bar: console.clear_line()
console.show_status('End of epoch. Elapsed time is '
'{:.1f} secs'.format(time.time() -
start_time))
break
# End of epoch
break_flag = False
since_last = epc - self._last_epoch
if since_last == 0: self._train_status['bad_apples'] = 0
else: self._train_status['bad_apples'] += 1
save_flag = self._apply_smart_train(
) if FLAGS.smart_train else True
if self._train_status['metric_on']:
best_metric = self._session.run(self._best_metric)
console.supplement(
'[Best {:.3f}] {} epochs since last record appears.'.
format(best_metric, since_last))
if not FLAGS.save_best and save_flag and FLAGS.save_model:
self._save(self._counter)
console.show_status('Model saved')
elif since_last >= epoch_tol:
break_flag = True
# Early stop if break flag is true
if break_flag: break
# End training
if FLAGS.progress_bar: console.clear_line()
# Write HP-tuning metric
if FLAGS.hpt:
summary = self._session.run(self._best_metric_sum)
self._summary_writer.add_summary(summary, self._counter)
if FLAGS.summary or FLAGS.hpt: self._summary_writer.flush()
return {1: 'linear', 2: 'quadratic', 3: 'cubic',
4: 'quartic', 5: 'quintic', 6: 'sixtic',
7: 'septic'}[self.order]
@single_input
def _link(self, input_, **kwargs):
assert isinstance(input_, tf.Tensor)
if self.coefs is not None: tf.get_variable_scope().reuse_variables()
# Get input dimension
D = input_.get_shape().as_list()[1]
self.neuron_scale = [D] * self.order
# Get variable
self.coefs = tf.get_variable('coefs', shape=(D,) * self.order)
# Calculate output
result = self.coefs
for dim in range(self.order - 1, -1, -1):
shape = [-1, D] + [1] * dim
result = tf.reshape(input_, shape=shape) * result
name = ('d{}'.format(dim) if dim > 0
else '{}_output'.format(self.poly_name))
result = tf.reduce_sum(result, axis=1, name=name, keep_dims=dim is 0)
return result
if __name__ == '__main__':
from tframe import console
console.section('homogeneous.py test')
