def before_run(self, run_context): layer = 'hidden1' tensors = { 'weights': tfutils._as_graph_element('%s/kernel:0' % layer), 'biases': tfutils._as_graph_element('%s/bias:0' % layer), } return SessionRunArgs(tensors)
def before_run(self, run_context): # pylint: disable=unused-argument self._should_trigger = self._timer.should_trigger_for_step( self._iter_count) if self._should_trigger: return SessionRunArgs(self._current_tensors) else: return None
def before_run(self, run_context): self._request_summary = (self._next_step is None or self._timer.should_trigger_for_step( self._next_step)) requests = {"global_step": self._global_step_tensor} opts = (tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) if self._request_summary else None) return SessionRunArgs(requests, options=opts)
def before_run(self, run_context): # pylint: disable=unused-argument requests = {"global_step": self._global_step_tensor} for n, t in self._tensors.items(): requests[n] = t self._generate = (self._next_step is None or self._timer.should_trigger_for_step(self._next_step)) return SessionRunArgs(requests)
def before_run(self, run_context): # pylint: disable=unused-argument requests = {"global_step": self._global_step_tensor} if self._request_summary: if self._summary_op is not None: requests["summary"] = self._summary_op elif self._scaffold.summary_op is not None: requests["summary"] = self._scaffold.summary_op return SessionRunArgs(requests)
def before_run(self, run_context): # pylint: disable=unused-argument if self._last_saved_time is None: # Write graph in the first call. training_util.write_graph( ops.get_default_graph().as_graph_def(add_shapes=True), self._checkpoint_dir, "graph.pbtxt") self._summary_writer.add_graph(ops.get_default_graph()) return SessionRunArgs(self._global_step_tensor)
def before_run(self, run_context): # pylint: disable=unused-argument global task_type global task_index global name global is_training if is_training == 0: xml_server.serverStarted(task_type, task_index, name) is_training = 1 return SessionRunArgs(self._global_step_tensor)
def before_run(self, run_context): # pylint: disable=unused-argument self._request_summary = not self._done requests = {"global_step": self._global_step_tensor} if self._request_summary: if self._get_summary_op() is not None: # print(self._iter_count) requests["summary"] = self._get_summary_op() return SessionRunArgs(requests)
def before_run(self, run_context): # pylint: disable=unused-argument self._request_summary = ( self._next_step is None or self._timer.should_trigger_for_step(self._next_step)) requests = {"global_step": self._global_step_tensor} if self._request_summary: if self._get_summary_op() is not None: requests["summary"] = self._get_summary_op() return SessionRunArgs(requests)
def before_run(self, run_context): """Essentially a copy of before_run as defined in the base class, except we don't add the default graph or any meta-graph data to the SummaryWriter""" if self._timer.last_triggered_step() is None: training_util.write_graph( ops.get_default_graph().as_graph_def(add_shapes=True), self._checkpoint_dir, "graph.pbtxt") saver_def = self._get_saver().saver_def if self._get_saver() else None return SessionRunArgs(self._global_step_tensor)
def before_run(self, run_context): self._request_summary = (self._next_step is None or self._timer.should_trigger_for_step( self._next_step)) requests = {} #{"global_step": self._global_step_tensor} opts = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) self.start_time = time.time() date_time = datetime.datetime.utcfromtimestamp( self.start_time).strftime('%Y-%m-%d %H:%M:%S') tf.logging.info(f'Before Run: {date_time}') return SessionRunArgs(requests, options=opts)
def before_run(self, run_context): # pylint: disable=unused-argument if self._timer.last_triggered_step() is None: # Write graph in the first call. training_util.write_graph( ops.get_default_graph().as_graph_def(add_shapes=True), self._checkpoint_dir, "graph.pbtxt") saver_def = self._saver.saver_def if self._saver else None graph = ops.get_default_graph() meta_graph_def = meta_graph.create_meta_graph_def( graph_def=graph.as_graph_def(add_shapes=True), saver_def=saver_def) self._summary_writer.add_graph(graph) self._summary_writer.add_meta_graph(meta_graph_def) return SessionRunArgs(self._global_step_tensor)
def before_run(self, run_context): # pylint: disable=unused-argument requests = run_context.original_args.fetches #requests = {"global_steps":self._global_step_tensor} self._global_steps = run_context.session.run(self._global_step_tensor) self._should_sum = self._timer_sum.should_trigger_for_step( self._global_steps + 1) self._should_debug = self._timer_debug.should_trigger_for_step( self._global_steps + 1) if self._timer_sum and self._should_sum and self._summary_op != None: requests["summary"] = self._summary_op if self._timer_debug and self._should_debug and self._debug_outputs_map != None: requests["debug_outputs"] = self._debug_outputs_map self._last_time = time.time() return SessionRunArgs(requests)
def before_run(self, run_context): # pylint: disable=unused-argument if self._timer.last_triggered_step() is None: # We do write graph and saver_def at the first call of before_run. # We cannot do this in begin, since we let other hooks to change graph and # add variables in begin. Graph is finalized after all begin calls. training_util.write_graph( ops.get_default_graph().as_graph_def(add_shapes=True), self._checkpoint_dir, "graph.pbtxt") saver_def = self._get_saver().saver_def if self._get_saver( ) else None graph = ops.get_default_graph() meta_graph_def = meta_graph.create_meta_graph_def( graph_def=graph.as_graph_def(add_shapes=True), saver_def=saver_def) return SessionRunArgs(self._global_step_tensor)
def before_run(self, run_context): session_args = run_context.original_args fetches = session_args.fetches feed_dict = session_args.feed_dict options = session_args.options # does this work? if options: options.report_tensor_allocations_upon_oom = True else: options = tf.RunOptions(report_tensor_allocations_upon_oom=True) session_args = SessionRunArgs(fetches=fetches, feed_dict=feed_dict, options=options) return session_args
def before_run(self, run_context): if self._timer.last_triggered_step() is None: # We do write graph and saver_def at the first call of before_run. # We cannot do this in begin, since we let other hooks to change graph and # add variables in begin. Graph is finalized after all begin calls. training_util.write_graph( ops.get_default_graph().as_graph_def(add_shapes=True), self._checkpoint_dir, "graph.pbtxt") graph = ops.get_default_graph() meta_graph_def = meta_graph.create_meta_graph_def( graph_def=graph.as_graph_def(add_shapes=True), saver_def=self._saver.saver_def) self._summary_writer.add_graph(graph) self._summary_writer.add_meta_graph(meta_graph_def) requests = {"global_steps": self._global_step_tensor} return SessionRunArgs(requests)
def before_run(self, run_context): # pylint: disable=unused-argument if self._first_run is True: self._curr_epoch += 1 print('Epoch %s/%s:' % (self._curr_epoch, self._epochs)) self.progbar = Progbar(target=self._step_per_epoch) self._first_run = False elif self._curr_step % self._step_per_epoch == 0: self._curr_epoch += 1 self._curr_step = 0 print('Epoch %s/%s:' % (self._curr_epoch, self._epochs)) self.progbar = Progbar(target=self._step_per_epoch) if self._tensors: return SessionRunArgs(self._current_tensors) return None
def before_run(self, run_context): # pylint: disable=unused-argument if S("optimizer.use_custom") and S("optimizer.memory_size") > 1: self._request_summary = ( self._iter_count % S("optimizer.memory_size") == S("optimizer.memory_size") - 1 ) # and self._timer.should_trigger_for_step(self._next_step) else: self._request_summary = (self._next_step is None or self._timer.should_trigger_for_step( self._next_step)) requests = {"global_step": self._global_step_tensor} if self._request_summary: if self._get_summary_op() is not None: # print(self._iter_count) requests["summary"] = self._get_summary_op() return SessionRunArgs(requests)
def before_run(self, run_context): # For the first run, record a SessionLog.START at the pre-run global step. if self._current_step is None: self._current_step = run_context.session.run( self._global_step_tensor) with ops.default_session(run_context.session): self._summary_writer.add_session_log( SessionLog(status=SessionLog.START), self._current_step) requests = {"global_step": self._global_step_tensor} self._request_summary = self._timer.should_trigger_for_step( self._current_step) if self._request_summary: self._timer.update_last_triggered_step(self._current_step) if self._get_summary_op() is not None: requests["summary"] = self._get_summary_op() feeds = {} if self._placeholder is not None and self._request_summary: feeds[self._placeholder] = self._request_summary args = SessionRunArgs(fetches=requests, feed_dict=feeds) return args
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 before_run(self, run_context): # pylint: disable=unused-argument if self._iter_count % self._every_n_iter == 0: return SessionRunArgs(self._current_tensors) else: return None
def before_run(self, run_context): return SessionRunArgs(fetches=self._fetches)
def before_run(self, run_context): return SessionRunArgs([self._global_step_tensor, self.tensor])
def before_run(self, run_context): # pylint: disable=unused-argument self._tic = time.time() if self._step % self._every_n_iter == 0: return SessionRunArgs(fetches=self._avg_ops)
def before_run(self, run_context): # pylint: disable=unused-argument return SessionRunArgs([ self.global_step_tensor, self.fake_seq, self.labels, self.d_score ])
def before_run(self, run_context): del run_context return SessionRunArgs( fetches={KMeansClustering.LOSS_OP_NAME: self._loss_tensor})
def before_run(self, run_context): feed_dict = self.build_feed_dict(graph=run_context.session.graph) return SessionRunArgs(fetches=None, feed_dict=feed_dict)
def before_run(self, run_context): return SessionRunArgs(self.early_stop_tensor)
def before_run(self, run_context): # pylint: disable=unused-argument return SessionRunArgs(self._loss_tensor)
def before_run(self, run_context): return SessionRunArgs( fetches=[], # no extra fetches options=tf.RunOptions(report_tensor_allocations_upon_oom=True))