def begin(self):
if isinstance(self.monitor, six.string_types):
self.monitor = _as_graph_element(self.monitor)
else:
self.monitor = _as_graph_element(self.monitor.name)
self._global_step_tensor = tf.train.get_global_step()
def begin(self):
if self._use_all_reduce:
self._avg_ops = OrderedDict({
'{}'.format(tag): hvd.allreduce(
basic_session_run_hooks._as_graph_element(tensor))
for (tag, tensor) in self._named_tensor.items()
})
else:
self._avg_ops = OrderedDict({
'{}'.format(tag):
basic_session_run_hooks._as_graph_element(tensor)
for (tag, tensor) in self._named_tensor.items()
})
self._global_step_tensor = tf.train.get_or_create_global_step()
self._avg_ops['step'] = self._global_step_tensor
def begin(self):
self._global_episode_tensor = get_global_episode()
if self._global_episode_tensor is None:
raise RuntimeError("Global episode should be created to use StopAtEpisodeHook.")
# Convert names to tensors if given
self._current_tensors = {tag: basic_session_run_hooks._as_graph_element(tensor)
for (tag, tensor) in self._tensors.items()}
self._current_tensors['global_episode'] = self._global_episode_tensor
def begin(self):
self._global_episode_tensor = get_global_episode()
if self._global_episode_tensor is None:
raise RuntimeError("Global episode should be created to use StopAtEpisodeHook.")
# Convert names to tensors if given
self._current_tensors = {tag: basic_session_run_hooks._as_graph_element(tensor)
for (tag, tensor) in self._tensors.items()}
self._current_tensors['global_episode'] = self._global_episode_tensor
def begin(self):
self._global_step_tensor = training_util._get_global_step_read() # pylint: disable=protected-access
if self._global_step_tensor is None:
raise RuntimeError(
"Global step should be created to use ProgressBarHook")
# Convert names to tensors if given
if self._tensors:
self._current_tensors = {tag: _as_graph_element(tensor)
for (tag, tensor) in self._tensors.items()}
def __init__(self, layer_names, data_path, k=100):
'''
Initialize the model to be tested
:param k: the number of sections to cover for each neuron
:param layer_names: Only these layers are considered for neuron coverage
:param data_path: the path of binary data containing neurons' bounds information
'''
self.data_path = data_path
# the layers that are considered in neuron coverage computation
self.layer_names = layer_names
for layer_name in self.layer_names:
layer_tensor = _as_graph_element(layer_name)
self.tensors.append(layer_tensor)
def __init__(self, layer_names, threshold=0.25):
'''
Initialize the model to be tested
:param threshold: threshold to determine if the neuron is activated
:param layer_names: Only these layers are considered for neuron coverage
'''
self.threshold = threshold
# the layers that are considered in neuron coverage computation
self.layer_names = layer_names
self.tensors = []
# init coverage table
self.neurons_data = {}
for layer_name in self.layer_names:
layer_tensor = _as_graph_element(layer_name)
self.tensors.append(layer_tensor)
dims = layer_tensor.get_shape()[1:]
neuron_indexes = []
for dim in dims:
neuron_indexes.append([i for i in range(dim)])
for neuron_idx in itertools.product(*neuron_indexes):
self.neurons_data[(layer_name, neuron_idx)] = False
def before_run(self, run_context):
self._run_begin = time.time()
if self._step > 0 and self._step % self._every_n_steps == 0:
arg_map = {}
for name in [
self._images_name, self._labels_name, self._filenames_name,
self._raw_images_name, self._heat_map_features_name,
self._probs_name
]:
if name is not None:
try:
arg_map[
name] = basic_session_run_hooks._as_graph_element(
name)
except Exception as e:
if not self.is_logged:
tf.logging.error('{} error {}'.format(name, e))
self.is_logged = True
arg_map['global_step'] = self._global_step_tensor
return SessionRunArgs(arg_map)
def begin(self):
self._iter_count = 0
# Convert names to tensors if given
self._current_tensors = {tag: _as_graph_element(tensor)
for (tag, tensor) in self._tensors.items()}
def begin(self):
self._loss_tensor = _as_graph_element('cross_entropy')