def testWriteRawPb(self): logdir = self.get_temp_dir() pb = summary_pb2.Summary() pb.value.add().simple_value = 42.0 with context.eager_mode(): with summary_ops.create_file_writer_v2(logdir).as_default(): output = summary_ops.write_raw_pb(pb.SerializeToString(), step=12) self.assertTrue(output.numpy()) events = events_from_logdir(logdir) self.assertEqual(2, len(events)) self.assertEqual(12, events[1].step) self.assertProtoEquals(pb, events[1].summary)
def testScalarSummary(self): with self.cached_session() as s: i = constant_op.constant(3) with ops.name_scope('outer'): im = summary_lib.scalar('inner', i) summary_str = s.run(im) summary = summary_pb2.Summary() summary.ParseFromString(summary_str) values = summary.value self.assertEqual(len(values), 1) self.assertEqual(values[0].tag, 'outer/inner') self.assertEqual(values[0].simple_value, 3.0)
def add_summary(self, summary, current_global_step): """Add summary.""" if isinstance(summary, bytes): summary_proto = summary_pb2.Summary() summary_proto.ParseFromString(summary) summary = summary_proto if current_global_step in self._summaries: step_summaries = self._summaries[current_global_step] else: step_summaries = [] self._summaries[current_global_step] = step_summaries step_summaries.append(summary)
def WriteScalarSeries(writer, tag, f, n=5): """Write a series of scalar events to writer, using f to create values.""" step = 0 wall_time = _start_time for i in xrange(n): v = f(i) value = summary_pb2.Summary.Value(tag=tag, simple_value=v) summary = summary_pb2.Summary(value=[value]) event = event_pb2.Event(wall_time=wall_time, step=step, summary=summary) writer.add_event(event) step += 1 wall_time += 10
def make_encoded_image_summary(name, encoded_image_string, height, width, colorspace=3): image = summary_pb2.Summary.Image( height=height, width=width, colorspace=colorspace, encoded_image_string=encoded_image_string) return summary_pb2.Summary( value=[summary_pb2.Summary.Value(tag=name, image=image)])
def _AddRateToSummary(tag, rate, step, sw): """Adds the given rate to the summary with the given tag. Args: tag: Name for this value. rate: Value to add to the summary. Perhaps an error rate. step: Global step of the graph for the x-coordinate of the summary. sw: Summary writer to which to write the rate value. """ sw.add_summary( summary_pb2.Summary(value=[summary_pb2.Summary.Value( tag=tag, simple_value=rate)]), step)
def _parse_summary_if_needed(summary): """ Parses the summary if it is provided in serialized form (bytes). This code is copied from tensorflow's SummaryToEventTransformer::add_summary :param summary: :return: """ if isinstance(summary, bytes): summ = summary_pb2.Summary() summ.ParseFromString(summary) summary = summ return summary
def _image_summary(self, tf_name, images, step=None): """ Log a list of images. References: https://github.com/yunjey/pytorch-tutorial/blob/master/tutorials/04-utils/tensorboard/logger.py#L22 Example: >>> tf_name = 'foo' >>> value = ([0, 1, 2, 3, 4, 5], [1, 20, 10, 22, 11]) >>> self = Logger(None, is_dummy=True) >>> images = [np.random.rand(10, 10), np.random.rand(10, 10)] >>> summary = self._image_summary(tf_name, images, step=None) >>> assert len(summary.value) == 2 >>> assert summary.value[0].image.width == 10 """ img_summaries = [] for i, img in enumerate(images): # Write the image to a string try: s = StringIO() except: s = BytesIO() scipy.misc.toimage(img).save(s, format="png") # Create an Image object img_sum = summary_pb2.Summary.Image( encoded_image_string=s.getvalue(), height=img.shape[0], width=img.shape[1]) # Create a Summary value img_value = summary_pb2.Summary.Value(tag='{}/{}'.format( tf_name, i), image=img_sum) img_summaries.append(img_value) summary = summary_pb2.Summary() summary.value.add(tag=tf_name, image=img_sum) summary = summary_pb2.Summary(value=img_summaries) return summary
def _histogram_summary(self, tf_name, value, step=None): """ Args: tf_name (str): name of tensorflow variable value (tuple or list): either a tuple of bin_edges and bincounts or a list of values to summarize in a histogram. References: https://github.com/yunjey/pytorch-tutorial/blob/master/tutorials/04-utils/tensorboard/logger.py#L45 Example: >>> tf_name = 'foo' >>> value = ([0, 1, 2, 3, 4, 5], [1, 20, 10, 22, 11]) >>> self = Logger(None, is_dummy=True) >>> summary = self._histogram_summary(tf_name, value, step=None) >>> assert summary.value[0].histo.max == 5 Example: >>> tf_name = 'foo' >>> value = [0.72, 0.18, 0.34, 0.66, 0.11, 0.70, 0.23] >>> self = Logger(None, is_dummy=True) >>> summary = self._histogram_summary(tf_name, value, step=None) >>> assert summary.value[0].histo.num == 7.0 """ if isinstance(value, tuple): bin_edges, bincounts = value assert len(bin_edges) == len(bincounts) + 1, ( 'must have one more edge than count') hist = summary_pb2.HistogramProto() hist.min = float(min(bin_edges)) hist.max = float(max(bin_edges)) else: values = np.array(value) bincounts, bin_edges = np.histogram(values) hist = summary_pb2.HistogramProto() hist.min = float(np.min(values)) hist.max = float(np.max(values)) hist.num = int(np.prod(values.shape)) hist.sum = float(np.sum(values)) hist.sum_squares = float(np.sum(values**2)) # Add bin edges and counts for edge in bin_edges[1:]: hist.bucket_limit.append(edge) for v in bincounts: hist.bucket.append(v) summary = summary_pb2.Summary() summary.value.add(tag=tf_name, histo=hist) return summary
def to_summary_proto(summary_str): """Create summary based on latest stats. Args: summary_str: Serialized summary. Returns: summary_pb2.Summary. Raises: ValueError: if tensor is not a valid summary tensor. """ summary = summary_pb2.Summary() summary.ParseFromString(summary_str) return summary
def testImageSummary(self): with self.test_session() as s: i = array_ops.ones((5, 4, 4, 3)) with ops.name_scope('outer'): im = summary_lib.image('inner', i, max_outputs=3) summary_str = s.run(im) summary = summary_pb2.Summary() summary.ParseFromString(summary_str) values = summary.value self.assertEqual(len(values), 3) tags = sorted(v.tag for v in values) expected = sorted('outer/inner/image/{}'.format(i) for i in xrange(3)) self.assertEqual(tags, expected)
def on_validation_end(self): predicted_labels = np.argmax(np.vstack(self.logits), axis=1) labels = np.hstack(self.labels) acc = np.mean(np.equal(predicted_labels, labels)) self.model.info('\n > Accuracy: %0.2f\n ' % (acc * 100)) self.model.history['accuracy'] += [acc] value = summary_pb2.Summary.Value(tag="accuracy", simple_value=acc) global_step = self.model.epoch * self.model.data.validation_steps + self.model.valid_step self.model.valid_writer.add_summary(summary_pb2.Summary(value=[value]), global_step=global_step) self.model.valid_writer.flush()
def py_gif_event(step, tag, tensor, max_outputs, fps): summary = py_gif_summary(tag, tensor, max_outputs, fps) if isinstance(summary, bytes): summ = summary_pb2.Summary() summ.ParseFromString(summary) summary = summ event = event_pb2.Event(summary=summary) event.wall_time = time.time() event.step = step event_pb = event.SerializeToString() return event_pb
def testAudioSummary(self): with self.cached_session() as s: i = array_ops.ones((5, 3, 4)) with ops.name_scope('outer'): aud = summary_lib.audio('inner', i, 0.2, max_outputs=3) summary_str = s.run(aud) summary = summary_pb2.Summary() summary.ParseFromString(summary_str) values = summary.value self.assertEqual(len(values), 3) tags = sorted(v.tag for v in values) expected = sorted('outer/inner/audio/{}'.format(i) for i in xrange(3)) self.assertEqual(tags, expected)
def tb_callback(res): # A callback function saving results to TensorBoard. print("Loss of the last generation (lower is better): %.3f" % res.fun) val = summary_pb2.Summary.Value(tag="Training loss rand%d" % config.oneplus_params["random_state"], simple_value=res.fun) summary = summary_pb2.Summary(value=[val]) tb_writer.add_summary(summary, tb_callback.cntr) tb_callback.cntr += 1 global best_loss if res.fun < best_loss: best_loss = res.fun save_result(res)
def eval_once(self, sess, iterator_init_list, writer, step, caller): """ Eval the model once """ start_time = time.time() # initialize data set iterators: for init in iterator_init_list: sess.run(init) total_sup_loss = 0 total_dice_score = 0 total_unsup_loss = 0 n_batches = 0 try: while True: caller.on_batch_begin(training_state=False, **self.callbacks_kwargs) sup_loss, dice_score, unsup_loss = self._eval_all_op( sess, writer, step) total_dice_score += dice_score total_sup_loss += sup_loss total_unsup_loss += unsup_loss step += 1 n_batches += 1 caller.on_batch_end(training_state=False, **self.callbacks_kwargs) except tf.errors.OutOfRangeError: # End of the validation set. Compute statistics here: total_loss = total_sup_loss + total_unsup_loss avg_loss = total_loss / n_batches avg_dice = total_dice_score / n_batches dice_loss = 1.0 - avg_dice delta_t = time.time() - start_time value = summary_pb2.Summary.Value( tag="Dice_1/validation/dice_3channels_avg", simple_value=avg_dice) summary = summary_pb2.Summary(value=[value]) writer.add_summary(summary, global_step=step) pass # update global epoch counter: sess.run(self.update_g_valid_step, feed_dict={'update_value:0': step}) print( '\033[31m VALIDATION\033[0m: average loss = {1:.4f} {0} Took: {2:.3f} seconds' .format(' ' * 3, avg_loss, delta_t)) return step, dice_loss
def write_tensorboard_results( results, epsilon_value, networks, actions_made_histogram, actions_made_placeholder, episode_number ): # TODO: replace episode_number with Debug.EPISODE_NUMBER ?? if Debug.USE_TENSORBOARD and Debug.EPISODE_NUMBER % Debug.OUTPUT_TO_TENSORBOARD_EVERY_N_EPISODES == 0: value = summary_pb2.Summary.Value(tag="score_per_episode", simple_value=results['score']) summary = summary_pb2.Summary(value=[value]) Debug.WRITER.add_summary(summary, episode_number) value = summary_pb2.Summary.Value(tag="epsilon_value", simple_value=epsilon_value) summary = summary_pb2.Summary(value=[value]) Debug.WRITER.add_summary(summary, episode_number) value = summary_pb2.Summary.Value( tag="total reward per episode", simple_value=results['total_reward']) summary = summary_pb2.Summary(value=[value]) Debug.WRITER.add_summary(summary, episode_number) # log['actions_made'] += results['actions_made'] summary = Debug.SESSION.run( actions_made_histogram, feed_dict={ actions_made_placeholder: np.reshape(results['actions_made'], (len(results['actions_made']), 1)) } ) # TODO: why reshape results['actions_made']? maybe it isnt useful anymore Debug.WRITER.add_summary(summary, episode_number) # log['actions_made'] = [] for network in networks: if network.is_training: network.model.write_weights_tb_histograms() if Debug.SAY_WHEN_HISTOGRAMS_ARE_PRINTED: print("weights histograms printed")
def write_to_summary(output_dir, summary_tag, summary_value, current_global_step): summary_writer = tf.summary.FileWriterCache.get(output_dir) summary_proto = summary_pb2.Summary() value = summary_proto.value.add() value.tag = summary_tag if isinstance(summary_value, np.float32) or isinstance( summary_value, float): value.simple_value = float(summary_value) elif isinstance(summary_value, int) or isinstance( summary_value, np.int64) or isinstance(summary_value, np.int32): value.simple_value = int(summary_value) summary_writer.add_summary(summary_proto, current_global_step) summary_writer.flush()
def testUseAfterClose(self): test_dir = self._CleanTestDir("use_after_close") sw = self._FileWriter(test_dir) sw.close() with warnings.catch_warnings(record=True) as triggered: warnings.simplefilter("always") self.assertFalse(triggered) sw.add_summary(summary_pb2.Summary()) sw.add_session_log(event_pb2.SessionLog()) sw.add_graph(ops.Graph()) self.assertEqual(len(triggered), 3) for w in triggered: self.assertEqual(w.category, UserWarning)
def testSummarizingVariable(self): with self.test_session() as s: c = constant_op.constant(42.0) v = variables.Variable(c) ss = summary_lib.scalar('summary', v) init = variables.global_variables_initializer() s.run(init) summ_str = s.run(ss) summary = summary_pb2.Summary() summary.ParseFromString(summ_str) self.assertEqual(len(summary.value), 1) value = summary.value[0] self.assertEqual(value.tag, 'summary') self.assertEqual(value.simple_value, 42.0)
def WriteHistogramSeries(writer, tag, mu_sigma_tuples, n=20): """Write a sequence of normally distributed histograms to writer.""" step = 0 wall_time = _start_time for [mean, stddev] in mu_sigma_tuples: data = [random.normalvariate(mean, stddev) for _ in xrange(n)] histo = _MakeHistogram(data) summary = summary_pb2.Summary( value=[summary_pb2.Summary.Value( tag=tag, histo=histo)]) event = event_pb2.Event(wall_time=wall_time, step=step, summary=summary) writer.add_event(event) step += 10 wall_time += 100
def add_summary(self, summary, global_step): summary_obj = summary_pb2.Summary() # ensure a valid Summary proto is being sent if isinstance(summary, bytes): summary_obj.ParseFromString(summary) else: assert isinstance(summary, summary_pb2.Summary) summary_obj = summary # keep track of steps seen for the merged_summary op, # which contains the histogram summaries if len(summary_obj.value) > 1: self.steps_seen.append(global_step)
def test_once(self, sess, iterator_init_list, writer, step, caller): """ Test the model once """ start_time = time.time() # initialize data set iterators: for init in iterator_init_list: sess.run(init) total_disc_loss = 0 total_unsup_loss = 0 total_dice = 0 total_miou = 0 n_batches = 0 try: while True: caller.on_batch_begin(training_state=False, **self.callbacks_kwargs) unsup_loss, disc_loss, dice, miou = self._eval_all_op( sess, writer, step) total_disc_loss += disc_loss total_unsup_loss += unsup_loss total_dice += dice total_miou += miou step += 1 n_batches += 1 except tf.errors.OutOfRangeError: # End of the test set. Compute statistics here: avg_loss = (total_unsup_loss + total_disc_loss) / n_batches avg_dice = total_dice / n_batches avg_miou = total_miou / n_batches delta_t = time.time() - start_time step += 1 value = summary_pb2.Summary.Value(tag="y_TEST/test/loss_avg", simple_value=avg_loss) summary = summary_pb2.Summary(value=[value]) writer.add_summary(summary, global_step=step) pass # update global epoch counter: sess.run(self.update_g_test_step, feed_dict={'update_value:0': step}) print( '\033[31m TEST\033[0m:{0}{0} \033[1;33m average loss = {1:.4f} {0}, average dice = {2:.4f} {0}, ' 'average miou = {3:.4f} {0}. Took: {4:.3f} seconds'.format( ' ' * 3, avg_loss, avg_dice, avg_miou, delta_t)) return step
def parse(bytes, wall_time, step, visit): summary = summary_pb2.Summary() summary.ParseFromString(bytes) for value in summary.value: if value.HasField('tensor') and value.tag == HEALTH_PILL_EVENT_TAG: continue for summary_type, summary_func in _SUMMARY_TYPES.items(): if value.HasField(summary_type): datum = getattr(value, summary_type) tag = value.node_name if summary_type == 'tensor' else value.tag parsed = summary_func(tag, wall_time, step, datum) visit(summary_type, parsed)
def testWriteRawPb_multipleValues(self): logdir = self.get_temp_dir() pb1 = summary_pb2.Summary() pb1.value.add().simple_value = 1.0 pb1.value.add().simple_value = 2.0 pb2 = summary_pb2.Summary() pb2.value.add().simple_value = 3.0 pb3 = summary_pb2.Summary() pb3.value.add().simple_value = 4.0 pb3.value.add().simple_value = 5.0 pb3.value.add().simple_value = 6.0 pbs = [pb.SerializeToString() for pb in (pb1, pb2, pb3)] with context.eager_mode(): with summary_ops.create_file_writer_v2(logdir).as_default(): output = summary_ops.write_raw_pb(pbs, step=12) self.assertTrue(output.numpy()) events = events_from_logdir(logdir) self.assertEqual(2, len(events)) self.assertEqual(12, events[1].step) expected_pb = summary_pb2.Summary() for i in range(6): expected_pb.value.add().simple_value = i + 1.0 self.assertProtoEquals(expected_pb, events[1].summary)
def _assert_simple_summaries(test_case, expected_summaries, summary_str, tol=1e-6): """Assert summary the specified simple values. Args: test_case: test case. expected_summaries: Dict of expected tags and simple values. summary_str: Serialized `summary_pb2.Summary`. tol: Tolerance for relative and absolute. """ summary = summary_pb2.Summary() summary.ParseFromString(summary_str) test_case.assertAllClose(expected_summaries, { v.tag: v.simple_value for v in summary.value }, rtol=tol, atol=tol)
def testFileWriterWithSuffix(self): test_dir = self._CleanTestDir("test_suffix") sw = self._FileWriter(test_dir, filename_suffix="_test_suffix") for _ in range(10): sw.add_summary( summary_pb2.Summary(value=[ summary_pb2.Summary.Value(tag="float_ten", simple_value=10.0) ]), 10) sw.close() sw.reopen() sw.close() event_filenames = glob.glob(os.path.join(test_dir, "event*")) for filename in event_filenames: self.assertTrue(filename.endswith("_test_suffix"))
def _assertSummaryHasCount(self, summary_str, tag, expected_value, greater_than=False): summary_proto = summary_pb2.Summary() summary_proto.ParseFromString(summary_str) for value in summary_proto.value: if re.match(tag, value.tag): if greater_than: self.assertGreaterEqual(value.histo.num, expected_value) else: self.assertEqual(expected_value, value.histo.num) return self.fail("Expected tag %r not found in summary %r" % (tag, summary_proto))
def _run_val_metrics(self, X_val): val_msres, val_n_mf_updates = [], [] for X_vb in batch_iter(X_val, batch_size=self.batch_size): msre, n_mf_upds = self._tf_session.run([self._msre, self._n_mf_updates], feed_dict=self._make_tf_feed_dict(X_vb)) val_msres.append(msre) val_n_mf_updates.append(n_mf_upds) mean_msre = np.mean(val_msres) mean_n_mf_updates = np.mean(val_n_mf_updates) s = summary_pb2.Summary(value=[ summary_pb2.Summary.Value(tag='mean_squared_recon_error', simple_value=mean_msre), summary_pb2.Summary.Value(tag='n_mf_updates', simple_value=mean_n_mf_updates), ]) self._tf_val_writer.add_summary(s, self.iter_) return mean_msre, mean_n_mf_updates
def _write_summary_results(output_dir, eval_results, current_global_step): """Writes eval results into summary file in given dir.""" logging.info('Saving evaluation summary for %d step: %s' % (current_global_step, _eval_results_to_str(eval_results))) summary_writer = get_summary_writer(output_dir) summary = summary_pb2.Summary() for key in eval_results: if eval_results[key] is None: continue value = summary.value.add() value.tag = key if (isinstance(eval_results[key], np.float32) or isinstance(eval_results[key], float)): value.simple_value = float(eval_results[key]) summary_writer.add_summary(summary, current_global_step) summary_writer.close()