def histogram_raw(name, min, max, num, sum, sum_squares, bucket_limits, bucket_counts): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with a histogram. The generated [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto) has one summary value containing a histogram for `values`. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. min: A float or int min value max: A float or int max value num: Int number of values sum: Float or int sum of all values sum_squares: Float or int sum of squares for all values bucket_limits: A numeric `Tensor` with upper value per bucket bucket_counts: A numeric `Tensor` with number of values per bucket Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ hist = HistogramProto(min=min, max=max, num=num, sum=sum, sum_squares=sum_squares, bucket_limit=bucket_limits, bucket=bucket_counts) return Summary(value=[Summary.Value(tag=name, histo=hist)])
def _add_3d_torch(self, tag, data, step, logdir=None, max_outputs=1, label_to_names=None, description=None): walltime = None if step is None: raise ValueError("Step is not provided or set.") mdata = {} if label_to_names is None else { 'label_to_names': label_to_names } summary_metadata = metadata.create_summary_metadata( description=description, metadata=mdata) writer = self._get_file_writer() if logdir is None: logdir = writer.get_logdir() write_dir = PluginDirectory(logdir, metadata.PLUGIN_NAME) geometry_metadata_string = _write_geometry_data(write_dir, tag, step, data, max_outputs) tensor_proto = TensorProto(dtype='DT_STRING', string_val=[geometry_metadata_string], tensor_shape=TensorShapeProto()) writer.add_summary( Summary(value=[ Summary.Value( tag=tag, tensor=tensor_proto, metadata=summary_metadata) ]), step, walltime)
def text(tag, text): plugin_data = SummaryMetadata.PluginData( plugin_name='text', content=TextPluginData(version=0).SerializeToString()) smd = SummaryMetadata(plugin_data=plugin_data) tensor = TensorProto(dtype='DT_STRING', string_val=[text.encode(encoding='utf_8')], tensor_shape=TensorShapeProto(dim=[TensorShapeProto.Dim(size=1)])) return Summary(value=[Summary.Value(tag=tag + '/text_summary', metadata=smd, tensor=tensor)])
def _ImageSummary(tag, height, width, colorspace, encoded_image): from tensorboard.compat.proto.summary_pb2 import Summary image = Summary.Image( height=height, width=width, colorspace=colorspace, encoded_image_string=encoded_image) return Summary(value=[Summary.Value(tag=tag, image=image)])
def _make_session_start_summary( hparam_values, group_name: Optional[str] = None, start_time_secs: Optional[int] = None, ): """Assign values to the hyperparameters in the context of this session. Args: hparam_values: a dict of ``hp_name`` -> ``hp_value`` mappings group_name: optional group name for this session start_time_secs: optional starting time in seconds Returns: """ if start_time_secs is None: start_time_secs = int(time.time()) session_start_info = SessionStartInfo(group_name=group_name, start_time_secs=start_time_secs) for hp_name, hp_value in hparam_values.items(): # Logging a None would raise an exception when setting session_start_info.hparams[hp_name].number_value = None. # Logging a float.nan instead would work, but that run would not show at all in the tensorboard hparam plugin. # The best thing to do here is to skip that value, it will show as a blank cell in the table view of the # tensorboard plugin. However, that run would not be shown in the parallel coord or in the scatter plot view. if hp_value is None: logger.warning( f"Hyper parameter {hp_name} is `None`: the tensorboard hp plugin " f"will show this run in table view, but not in parallel coordinates " f"view or in scatter plot matrix view") continue if isinstance(hp_value, (str, list, tuple)): session_start_info.hparams[hp_name].string_value = str(hp_value) continue if isinstance(hp_value, bool): session_start_info.hparams[hp_name].bool_value = hp_value continue if not isinstance(hp_value, (int, float)): hp_value = make_np(hp_value)[0] session_start_info.hparams[hp_name].number_value = hp_value session_start_content = HParamsPluginData( session_start_info=session_start_info, version=PLUGIN_DATA_VERSION) session_start_summary_metadata = SummaryMetadata( plugin_data=SummaryMetadata.PluginData( plugin_name=PLUGIN_NAME, content=session_start_content.SerializeToString())) session_start_summary = Summary(value=[ Summary.Value(tag=SESSION_START_INFO_TAG, metadata=session_start_summary_metadata) ]) return session_start_summary
def event(step, values): s = Summary() scalar = [ Summary.Value(tag="{}/{}".format(name, field), simple_value=v) for name, value in zip(names, values) for field, v in value._asdict().items() ] hist = [ Summary.Value(tag="{}/inferred_normal_hist".format(name), histo=inferred_histo(value)) for name, value in zip(names, values) ] s.value.extend(scalar + hist) return Event(wall_time=int(step), step=step, summary=s)
def pr_curve_raw(tag, tp, fp, tn, fn, precision, recall, num_thresholds=127, weights=None): if num_thresholds > 127: # weird, value > 127 breaks protobuf num_thresholds = 127 data = np.stack((tp, fp, tn, fn, precision, recall)) pr_curve_plugin_data = PrCurvePluginData( version=0, num_thresholds=num_thresholds).SerializeToString() plugin_data = SummaryMetadata.PluginData( plugin_name='pr_curves', content=pr_curve_plugin_data) smd = SummaryMetadata(plugin_data=plugin_data) tensor = TensorProto(dtype='DT_FLOAT', float_val=data.reshape(-1).tolist(), tensor_shape=TensorShapeProto( dim=[TensorShapeProto.Dim(size=data.shape[0]), TensorShapeProto.Dim(size=data.shape[1])])) return Summary(value=[Summary.Value(tag=tag, metadata=smd, tensor=tensor)])
def pr_curve(tag, labels, predictions, num_thresholds=127, weights=None): # weird, value > 127 breaks protobuf num_thresholds = min(num_thresholds, 127) data = compute_curve(labels, predictions, num_thresholds=num_thresholds, weights=weights) pr_curve_plugin_data = PrCurvePluginData( version=0, num_thresholds=num_thresholds).SerializeToString() plugin_data = SummaryMetadata.PluginData( plugin_name='pr_curves', content=pr_curve_plugin_data) smd = SummaryMetadata(plugin_data=plugin_data) tensor = TensorProto(dtype='DT_FLOAT', float_val=data.reshape(-1).tolist(), tensor_shape=TensorShapeProto( dim=[TensorShapeProto.Dim(size=data.shape[0]), TensorShapeProto.Dim(size=data.shape[1])])) return Summary(value=[Summary.Value(tag=tag, metadata=smd, tensor=tensor)])
def _write_logs(self, logs, index): """Write log values to the log files :param logs: holds the loss and metric values computed at the most recent interval (batch or epoch) :type logs: dict :param index: if update_freq='batch', the total number of samples that have been seen, else if update_freq='epoch', the epoch index :type index: int """ for name, value in logs.items(): if name in ['batch', 'size']: continue summary = Summary( value=[Summary.Value(tag=name, simple_value=value)]) self.writer.add_summary(summary, index) self.writer.flush()
def _get_tensor_summary( name, display_name, description, tensor, content_type, components, json_config ): """Creates a tensor summary with summary metadata. Args: name: Uniquely identifiable name of the summary op. Could be replaced by combination of name and type to make it unique even outside of this summary. display_name: Will be used as the display name in TensorBoard. Defaults to `name`. description: A longform readable description of the summary data. Markdown is supported. tensor: Tensor to display in summary. content_type: Type of content inside the Tensor. components: Bitmask representing present parts (vertices, colors, etc.) that belong to the summary. json_config: A string, JSON-serialized dictionary of ThreeJS classes configuration. Returns: Tensor summary with metadata. """ import torch from tensorboard.plugins.mesh import metadata tensor = torch.as_tensor(tensor) tensor_metadata = metadata.create_summary_metadata( name, display_name, content_type, components, tensor.shape, description, json_config=json_config, ) tensor = TensorProto( dtype="DT_FLOAT", float_val=tensor.reshape(-1).tolist(), tensor_shape=TensorShapeProto( dim=[ TensorShapeProto.Dim(size=tensor.shape[0]), TensorShapeProto.Dim(size=tensor.shape[1]), TensorShapeProto.Dim(size=tensor.shape[2]), ] ), ) tensor_summary = Summary.Value( tag=metadata.get_instance_name(name, content_type), tensor=tensor, metadata=tensor_metadata, ) return tensor_summary
def scalar(name, scalar, collections=None): """Outputs a `Summary` protocol buffer containing a single scalar value. The generated Summary has a Tensor.proto containing the input Tensor. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A real numeric Tensor containing a single value. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. Returns: A scalar `Tensor` of type `string`. Which contains a `Summary` protobuf. Raises: ValueError: If tensor has the wrong shape or type. """ scalar = make_np(scalar) assert (scalar.squeeze().ndim == 0), 'scalar should be 0D' scalar = float(scalar) return Summary(value=[Summary.Value(tag=name, simple_value=scalar)])
def scalar(name, tensor, collections=None, new_style=False, double_precision=False): """Outputs a `Summary` protocol buffer containing a single scalar value. The generated Summary has a Tensor.proto containing the input Tensor. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A real numeric Tensor containing a single value. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. new_style: Whether to use new style (tensor field) or old style (simple_value field). New style could lead to faster data loading. Returns: A scalar `Tensor` of type `string`. Which contains a `Summary` protobuf. Raises: ValueError: If tensor has the wrong shape or type. """ tensor = make_np(tensor).squeeze() assert ( tensor.ndim == 0 ), f"Tensor should contain one element (0 dimensions). Was given size: {tensor.size} and {tensor.ndim} dimensions." # python float is double precision in numpy scalar = float(tensor) if new_style: tensor_proto = TensorProto(float_val=[scalar], dtype="DT_FLOAT") if double_precision: tensor_proto = TensorProto(double_val=[scalar], dtype="DT_DOUBLE") plugin_data = SummaryMetadata.PluginData(plugin_name="scalars") smd = SummaryMetadata(plugin_data=plugin_data) return Summary( value=[ Summary.Value( tag=name, tensor=tensor_proto, metadata=smd, ) ] ) else: return Summary(value=[Summary.Value(tag=name, simple_value=scalar)])
def _image3_animated_gif(tag: str, image: Union[np.ndarray, torch.Tensor], scale_factor: float = 1.0) -> Summary: """Function to actually create the animated gif. Args: tag: Data identifier image: 3D image tensors expected to be in `HWD` format scale_factor: amount to multiply values by. if the image data is between 0 and 1, using 255 for this value will scale it to displayable range """ assert len(image.shape) == 3, "3D image tensors expected to be in `HWD` format, len(image.shape) != 3" ims = [(np.asarray((image[:, :, i])) * scale_factor).astype(np.uint8) for i in range(image.shape[2])] ims = [GifImage.fromarray(im) for im in ims] img_str = b"" for b_data in PIL.GifImagePlugin.getheader(ims[0])[0]: img_str += b_data img_str += b"\x21\xFF\x0B\x4E\x45\x54\x53\x43\x41\x50" b"\x45\x32\x2E\x30\x03\x01\x00\x00\x00" for i in ims: for b_data in PIL.GifImagePlugin.getdata(i): img_str += b_data img_str += b"\x3B" summary_image_str = Summary.Image(height=10, width=10, colorspace=1, encoded_image_string=img_str) image_summary = Summary.Value(tag=tag, image=summary_image_str) return Summary(value=[image_summary])
def make_video(tensor, fps): try: import moviepy # noqa: F401 except ImportError: print('add_video needs package moviepy') return try: from moviepy import editor as mpy except ImportError: print("moviepy is installed, but can't import moviepy.editor.", "Some packages could be missing [imageio, requests]") return import tempfile t, h, w, c = tensor.shape # encode sequence of images into gif string clip = mpy.ImageSequenceClip(list(tensor), fps=fps) with tempfile.NamedTemporaryFile() as f: filename = f.name + '.gif' try: clip.write_gif(filename, verbose=False, progress_bar=False) except TypeError: clip.write_gif(filename, verbose=False) with open(filename, 'rb') as f: tensor_string = f.read() try: os.remove(filename) except OSError: pass return Summary.Image(height=h, width=w, colorspace=c, encoded_image_string=tensor_string)
def _ScalarSummary(tag, val): from tensorboard.compat.proto.summary_pb2 import Summary return Summary(value=[Summary.Value(tag=tag, simple_value=val)])
def _make_experiment_summary(hparam_infos, metric_infos, experiment): """Define hyperparameters and metrics. Args: hparam_infos: information about all hyperparameters (name, description, type etc.), list of dicts containing 'name' (required), 'type', 'description', 'display_name', 'domain_discrete', 'domain_interval' metric_infos: information about all metrics (tag, description etc.), list of dicts containing 'tag' (required), 'dataset_type', 'description', 'display_name' experiment: dict containing 'name' (required), 'description', 'time_created_secs', 'user' Returns: """ def make_hparam_info(hparam): data_types = { None: DataType.DATA_TYPE_UNSET, str: DataType.DATA_TYPE_STRING, list: DataType.DATA_TYPE_STRING, tuple: DataType.DATA_TYPE_STRING, bool: DataType.DATA_TYPE_BOOL, int: DataType.DATA_TYPE_FLOAT64, float: DataType.DATA_TYPE_FLOAT64, } return HParamInfo( name=hparam["name"], type=data_types[hparam.get("type")], description=hparam.get("description"), display_name=hparam.get("display_name"), domain_discrete=hparam.get("domain_discrete"), domain_interval=hparam.get("domain_interval"), ) def make_metric_info(metric): return MetricInfo( name=MetricName(tag=metric["tag"]), dataset_type=DatasetType.Value( f'DATASET_{metric.get("dataset_type", "UNKNOWN").upper()}'), description=metric.get("description"), display_name=metric.get("display_name"), ) def make_experiment_info(experiment, metric_infos, hparam_infos): return Experiment( name=experiment["name"], description=experiment.get("description"), time_created_secs=experiment.get("time_created_secs"), user=experiment.get("user"), metric_infos=metric_infos, hparam_infos=hparam_infos, ) metric_infos = [make_metric_info(m) for m in metric_infos] hparam_infos = [make_hparam_info(hp) for hp in hparam_infos] experiment = make_experiment_info(experiment, metric_infos, hparam_infos) experiment_content = HParamsPluginData(experiment=experiment, version=PLUGIN_DATA_VERSION) experiment_summary_metadata = SummaryMetadata( plugin_data=SummaryMetadata.PluginData( plugin_name=PLUGIN_NAME, content=experiment_content.SerializeToString())) experiment_summary = Summary(value=[ Summary.Value(tag=EXPERIMENT_TAG, metadata=experiment_summary_metadata) ]) return experiment_summary
def Summary(tag, **kw): from tensorboard.compat.proto.summary_pb2 import Summary return Summary(value=[Summary.Value(tag=tag, **kw)])
def Image(**kw): from tensorboard.compat.proto.summary_pb2 import Summary return Summary.Image(**kw)