def _compat_summary_scope(name, family): """Handles `family` argument for v2 op invocation in v1.""" # Get a new summary tag name with the `family` arg. with _summary_op_util.summary_scope(name, family) as (tag, _): # Reset the root name scope with an empty summary_scope. with _summary_op_util.summary_scope(name='', family=None): yield tag
def audio(self, name, tensor, sample_rate, max_outputs, family=None): """Write an audio summary. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 3-D `float32` `Tensor` of shape `[batch_size, frames, channels]` or a 2-D `float32` `Tensor` of shape `[batch_size, frames]`, or compatible value type. sample_rate: A Scalar `float32` `Tensor` indicating the sample rate of the signal in hertz. max_outputs: Max number of batch elements to generate audio for. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_audio_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_cpu(tensor), sample_rate=_maybe_cpu(sample_rate), max_outputs=max_outputs, name=scope)
def scalar(name, tensor, collections=None, family=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]`. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. Which contains a `Summary` protobuf. Raises: ValueError: If tensor has the wrong shape or type. """ if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = _gen_logging_ops.scalar_summary(tags=tag, values=tensor, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def gif_summary(name, paths, max_outputs, collections=None, family=None): """Outputs a `Summary` protocol buffer with gif animations. Args: name: Name of the summary. tensor: A 5-D `uint8` `Tensor` of shape `[batch_size, time, height, width, channels]` where `channels` is 1 or 3. max_outputs: Max number of batch elements to generate gifs for. collections: Optional list of tf.GraphKeys. The collections to add the summary to. Defaults to [tf.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ paths = tf.convert_to_tensor(paths) if summary_op_util.skip_summary(): return tf.constant("") with summary_op_util.summary_scope(name, family, values=[paths]) as (tag, scope): val = tf.py_func(py_gif_summary, [tag, paths, max_outputs], tf.string, stateful=False, name=scope) summary_op_util.collect(val, collections, [tf.GraphKeys.SUMMARIES]) return val
def audio(self, name, tensor, sample_rate, max_outputs, family=None): """Write an audio summary. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 3-D `float32` `Tensor` of shape `[batch_size, frames, channels]` or a 2-D `float32` `Tensor` of shape `[batch_size, frames]`, or compatible value type. sample_rate: A Scalar `float32` `Tensor` indicating the sample rate of the signal in hertz. max_outputs: Max number of batch elements to generate audio for. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_audio_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_cpu(tensor), sample_rate=_maybe_cpu(sample_rate), max_outputs=max_outputs, name=scope)
def scalar(name, tensor, collections=None, family=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]`. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. Which contains a `Summary` protobuf. Raises: ValueError: If tensor has the wrong shape or type. """ with _summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): # pylint: disable=protected-access val = _gen_logging_ops._scalar_summary(tags=tag, values=tensor, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def _tensor_summary_v2( # pylint: disable=invalid-name name, tensor, summary_description=None, collections=None, summary_metadata=None, family=None): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with a serialized tensor.proto. NOTE(chizeng): This method is temporary. It should never make it into TensorFlow 1.3, and nothing should depend on it. This method should be deleted before August 2017 (ideally, earlier). This method exists to unblock the TensorBoard plugin refactoring effort. We will later modify the tensor_summary method to directly make use of the TensorSummaryV2 op. There must be a 3-week difference between adding a new op (C++) and changing a python interface to use it. The generated [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto) has one summary value containing the input tensor. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A tensor of any type and shape to serialize. summary_description: This is currently un-used but must be kept for backwards compatibility. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. summary_metadata: Optional SummaryMetadata proto (which describes which plugins may use the summary value). family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ # pylint: enable=line-too-long # The summary description is unused now. del summary_description serialized_summary_metadata = "" if summary_metadata: serialized_summary_metadata = summary_metadata.SerializeToString() with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = gen_logging_ops._tensor_summary_v2( tensor=tensor, tag=tag, description="", name=scope, serialized_summary_metadata=serialized_summary_metadata) summary_op_util.collect(val, collections, [ops.GraphKeys.SUMMARIES]) return val
def record(): if bad_color is None: bad_color_ = constant_op.constant([255, 0, 0, 255], dtype=dtypes.uint8) with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_image_summary( context.context().summary_writer_resource, training_util.get_global_step(), tag, tensor, bad_color_, max_images, name=scope)
def record(): with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_histogram_summary( context.context().summary_writer_resource, training_util.get_global_step(), tag, tensor, name=scope)
def scalar(name, tensor, collections=None, family=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]`. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. Which contains a `Summary` protobuf. Raises: ValueError: If tensor has the wrong shape or type. @compatibility(TF2) This API is not compatible with eager execution or `tf.function`. To migrate to TF2, please use `tf.summary.scalar` instead. Please check [Migrating tf.summary usage to TF 2.0](https://www.tensorflow.org/tensorboard/migrate#in_tf_1x) for concrete steps for migration. `tf.summary.scalar` can also log training metrics in Keras, you can check [Logging training metrics in Keras](https://www.tensorflow.org/tensorboard/scalars_and_keras) for detials. #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :------------ | :-------------- | :------------------------------------- | | `name` | `name` | - | | `tensor` | `data` | - | | - | `step` | Explicit int64-castable monotonic step | : : : value. If omitted, this defaults to : : : : `tf.summary.experimental.get_step()`. : | `collections` | Not Supported | - | | `family` | Removed | Please use `tf.name_scope` instead to | : : : manage summary name prefix. : | - | `description` | Optional long-form `str` description | : : : for the summary. Markdown is supported.: : : : Defaults to empty. : @end_compatibility """ if _distribute_summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): val = _gen_logging_ops.scalar_summary(tags=tag, values=tensor, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def image(name, tensor, max_outputs=3, collections=None, family=None): """Outputs a `Summary` protocol buffer with images. The summary has up to `max_outputs` summary values containing images. The images are built from `tensor` which must be 4-D with shape `[batch_size, height, width, channels]` and where `channels` can be: * 1: `tensor` is interpreted as Grayscale. * 3: `tensor` is interpreted as RGB. * 4: `tensor` is interpreted as RGBA. The images have the same number of channels as the input tensor. For float input, the values are normalized one image at a time to fit in the range `[0, 255]`. `uint8` values are unchanged. The op uses two different normalization algorithms: * If the input values are all positive, they are rescaled so the largest one is 255. * If any input value is negative, the values are shifted so input value 0.0 is at 127. They are then rescaled so that either the smallest value is 0, or the largest one is 255. The `tag` in the outputted Summary.Value protobufs is generated based on the name, with a suffix depending on the max_outputs setting: * If `max_outputs` is 1, the summary value tag is '*name*/image'. * If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*name*/image/0', '*name*/image/1', etc. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 4-D `uint8` or `float32` `Tensor` of shape `[batch_size, height, width, channels]` where `channels` is 1, 3, or 4. max_outputs: Max number of batch elements to generate images for. collections: Optional list of ops.GraphKeys. The collections to add the summary to. Defaults to [_ops.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): val = _gen_logging_ops.image_summary(tag=tag, tensor=tensor, max_images=max_outputs, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def image(self, name, tensor, bad_color=None, max_images=3, family=None): """Write an image summary.""" with context.device(self._CPU_DEVICE): if bad_color is None: bad_color_ = constant_op.constant([255, 0, 0, 255], dtype=dtypes.uint8) with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_image_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_cpu(tensor), bad_color_, max_images, name=scope)
def record(): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_audio_summary( context.context().summary_writer_resource, training_util.get_global_step(), tag, tensor, sample_rate=sample_rate, max_outputs=max_outputs, name=scope)
def image(self, name, tensor, bad_color=None, max_images=3, family=None): """Write an image summary.""" with context.device(self._CPU_DEVICE): if bad_color is None: bad_color_ = constant_op.constant([255, 0, 0, 255], dtype=dtypes.uint8) with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_image_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_as_cpu_tensor(tensor), bad_color_, max_images, name=scope)
def record(): with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_audio_summary( context.context().summary_writer_resource, training_util.get_global_step(), tag, tensor, sample_rate=sample_rate, max_outputs=max_outputs, name=scope)
def image(name, tensor, max_outputs=3, collections=None, family=None): """Outputs a `Summary` protocol buffer with images. The summary has up to `max_outputs` summary values containing images. The images are built from `tensor` which must be 4-D with shape `[batch_size, height, width, channels]` and where `channels` can be: * 1: `tensor` is interpreted as Grayscale. * 3: `tensor` is interpreted as RGB. * 4: `tensor` is interpreted as RGBA. The images have the same number of channels as the input tensor. For float input, the values are normalized one image at a time to fit in the range `[0, 255]`. `uint8` values are unchanged. The op uses two different normalization algorithms: * If the input values are all positive, they are rescaled so the largest one is 255. * If any input value is negative, the values are shifted so input value 0.0 is at 127. They are then rescaled so that either the smallest value is 0, or the largest one is 255. The `tag` in the outputted Summary.Value protobufs is generated based on the name, with a suffix depending on the max_outputs setting: * If `max_outputs` is 1, the summary value tag is '*name*/image'. * If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*name*/image/0', '*name*/image/1', etc. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 4-D `uint8` or `float32` `Tensor` of shape `[batch_size, height, width, channels]` where `channels` is 1, 3, or 4. max_outputs: Max number of batch elements to generate images for. collections: Optional list of ops.GraphKeys. The collections to add the summary to. Defaults to [_ops.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = _gen_logging_ops.image_summary( tag=tag, tensor=tensor, max_images=max_outputs, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def tensor_summary(name, tensor, summary_description=None, collections=None, summary_metadata=None, family=None, display_name=None): """Outputs a `Summary` protocol buffer with a serialized tensor.proto. Args: name: A name for the generated node. If display_name is not set, it will also serve as the tag name in TensorBoard. (In that case, the tag name will inherit tf name scopes.) tensor: A tensor of any type and shape to serialize. summary_description: A long description of the summary sequence. Markdown is supported. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. summary_metadata: Optional SummaryMetadata proto (which describes which plugins may use the summary value). family: Optional; if provided, used as the prefix of the summary tag, which controls the name used for display on TensorBoard when display_name is not set. display_name: A string used to name this data in TensorBoard. If this is not set, then the node name will be used instead. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ if summary_metadata is None: summary_metadata = _SummaryMetadata() if summary_description is not None: summary_metadata.summary_description = summary_description if display_name is not None: summary_metadata.display_name = display_name serialized_summary_metadata = summary_metadata.SerializeToString() if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = _gen_logging_ops.tensor_summary_v2( tensor=tensor, tag=tag, name=scope, serialized_summary_metadata=serialized_summary_metadata) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def audio(name, tensor, sample_rate, max_outputs=3, collections=None, family=None): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with audio. The summary has up to `max_outputs` summary values containing audio. The audio is built from `tensor` which must be 3-D with shape `[batch_size, frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`. The `tag` in the outputted Summary.Value protobufs is generated based on the name, with a suffix depending on the max_outputs setting: * If `max_outputs` is 1, the summary value tag is '*name*/audio'. * If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*name*/audio/0', '*name*/audio/1', etc Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 3-D `float32` `Tensor` of shape `[batch_size, frames, channels]` or a 2-D `float32` `Tensor` of shape `[batch_size, frames]`. sample_rate: A Scalar `float32` `Tensor` indicating the sample rate of the signal in hertz. max_outputs: Max number of batch elements to generate audio for. collections: Optional list of ops.GraphKeys. The collections to add the summary to. Defaults to [_ops.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope(name, family=family, values=[tensor]) as (tag, scope): sample_rate = _ops.convert_to_tensor(sample_rate, dtype=_dtypes.float32, name='sample_rate') val = _gen_logging_ops.audio_summary_v2(tag=tag, tensor=tensor, max_outputs=max_outputs, sample_rate=sample_rate, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def record(): if bad_color is None: bad_color_ = constant_op.constant([255, 0, 0, 255], dtype=dtypes.uint8) with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_image_summary( context.context().summary_writer_resource, training_util.get_global_step(), tag, tensor, bad_color_, max_images, name=scope)
def gif_summary(name, tensor, max_outputs, fps, collections=None, family=None): tensor = tf.convert_to_tensor(tensor) if tensor.dtype in (tf.float32, tf.float64): tensor = tf.cast(255.0 * tensor, tf.uint8) with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = tf.py_func( py_gif_summary, [tag, tensor, max_outputs, fps], tf.string, stateful=False, name=scope) summary_op_util.collect(val, collections, [tf.GraphKeys.SUMMARIES]) return val
def gif_summary(name, tensor, max_outputs, fps, collections=None, family=None): tensor = tf.image.convert_image_dtype(tensor, dtype=tf.uint8, saturate=True) # tensor = tf.convert_to_tensor(tensor) if summary_op_util.skip_summary(): return tf.constant("") with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): val = tf.py_func(py_gif_summary, [tag, tensor, max_outputs, fps], tf.string, stateful=False, name=scope) summary_op_util.collect(val, collections, [tf.GraphKeys.SUMMARIES]) return val
def histogram(self, name, tensor, family=None): """Write a histogram summary. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A real numeric `Tensor` or compatible value type. Any shape. Values to use to build the histogram. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_histogram_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_as_cpu_tensor(tensor), name=scope)
def gif_summary(name, im_seq, fps, collections=None, family=None): """ im_seq: 4D tensor (TxHxWxC) for which GIF is to be generated. collections: collections to which the summary op is to be added. """ if summary_op_util.skip_summary(): return constant_op.constant('') with summary_op_util.summary_scope(name, family, values=[im_seq]) as (tag, scope): gif_summ = tf.py_func(encode_gif, [im_seq, tag, fps], tf.string, stateful=False) summary_op_util.collect(gif_summ, collections, [tf.GraphKeys.SUMMARIES]) return gif_summ
def histogram(self, name, tensor, family=None): """Write a histogram summary. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A real numeric `Tensor` or compatible value type. Any shape. Values to use to build the histogram. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_histogram_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_cpu(tensor), name=scope)
def audio(name, tensor, sample_rate, max_outputs=3, collections=None, family=None): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with audio. The summary has up to `max_outputs` summary values containing audio. The audio is built from `tensor` which must be 3-D with shape `[batch_size, frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`. The `tag` in the outputted Summary.Value protobufs is generated based on the name, with a suffix depending on the max_outputs setting: * If `max_outputs` is 1, the summary value tag is '*name*/audio'. * If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*name*/audio/0', '*name*/audio/1', etc Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 3-D `float32` `Tensor` of shape `[batch_size, frames, channels]` or a 2-D `float32` `Tensor` of shape `[batch_size, frames]`. sample_rate: A Scalar `float32` `Tensor` indicating the sample rate of the signal in hertz. max_outputs: Max number of batch elements to generate audio for. collections: Optional list of ops.GraphKeys. The collections to add the summary to. Defaults to [_ops.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family=family, values=[tensor]) as (tag, scope): sample_rate = _ops.convert_to_tensor( sample_rate, dtype=_dtypes.float32, name='sample_rate') val = _gen_logging_ops.audio_summary_v2( tag=tag, tensor=tensor, max_outputs=max_outputs, sample_rate=sample_rate, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def add_gif_summary(name, im_thwc, fps=25, collections=None, family=None, timeline=False, attention=[], pred=[]): """ IM_THWC: 4D tensor (TxHxWxC) for which GIF is to be generated. COLLECTION: collections to which the summary op is to be added. """ # if summary_op_util.skip_summary(): return constant_op.constant('') with summary_op_util.summary_scope(name, family, values=[im_thwc]) as (tag, scope): pyfunc_args = [im_thwc, tag, fps, timeline, attention, pred] gif_summ = tf.py_func(py_encode_gif, pyfunc_args, tf.string, stateful=False) summary_op_util.collect(gif_summ, collections, [tf.GraphKeys.SUMMARIES]) return gif_summ
def gif_summary(name, tensor, max_outputs=3, fps=10, collections=None, family=None): """Outputs a `Summary` protocol buffer with gif animations. Args: name: Name of the summary. tensor: A 5-D `uint8` `Tensor` of shape `[batch_size, time, height, width, channels]` where `channels` is 1 or 3. max_outputs: Max number of batch elements to generate gifs for. fps: frames per second of the animation collections: Optional list of tf.GraphKeys. The collections to add the summary to. Defaults to [tf.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. Raises: ValueError: if the given tensor has the wrong shape. """ tensor = tf.convert_to_tensor(tensor) if len(tensor.get_shape()) != 5: raise ValueError("Assuming videos given as tensors in the format " "[batch, time, height, width, channels] but got one " "of shape: %s" % str(tensor.get_shape())) tensor = tf.cast(tensor, tf.uint8) if distribute_summary_op_util.skip_summary(): return tf.constant("") with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): val = tf.py_func(py_gif_summary, [tag, tensor, max_outputs, fps], tf.string, stateful=False, name=scope) summary_op_util.collect(val, collections, [tf.GraphKeys.SUMMARIES]) return val
def tensor_summary( name, tensor, summary_description=None, collections=None, summary_metadata=None, family=None): """Outputs a `Summary` protocol buffer with a serialized tensor.proto. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A tensor of any type and shape to serialize. summary_description: This is currently un-used but must be kept for backwards compatibility. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. summary_metadata: Optional SummaryMetadata proto (which describes which plugins may use the summary value). family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ # The summary description is unused now. del summary_description serialized_summary_metadata = "" if summary_metadata: serialized_summary_metadata = summary_metadata.SerializeToString() with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = gen_logging_ops._tensor_summary_v2( tensor=tensor, tag=tag, name=scope, serialized_summary_metadata=serialized_summary_metadata) summary_op_util.collect(val, collections, [ops.GraphKeys.SUMMARIES]) return val
def scalar(self, name, tensor, family=None): """Write a scalar summary. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A real numeric `Tensor` or compatible value type containing a single value. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A summary writer function for scalars. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_scalar_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_cpu(tensor), name=scope)
def scalar(self, name, tensor, family=None): """Write a scalar summary. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A real numeric `Tensor` or compatible value type containing a single value. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A summary writer function for scalars. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_scalar_summary( self._resource, self._update_global_step_tensor(), tag, _maybe_as_cpu_tensor(tensor), name=scope)
def tensor_summary(name, tensor, summary_description=None, collections=None, summary_metadata=None, family=None): """Outputs a `Summary` protocol buffer with a serialized tensor.proto. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A tensor of any type and shape to serialize. summary_description: This is currently un-used but must be kept for backwards compatibility. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. summary_metadata: Optional SummaryMetadata proto (which describes which plugins may use the summary value). family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ # The summary description is unused now. del summary_description serialized_summary_metadata = "" if summary_metadata: serialized_summary_metadata = summary_metadata.SerializeToString() with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): val = gen_logging_ops._tensor_summary_v2( tensor=tensor, tag=tag, name=scope, serialized_summary_metadata=serialized_summary_metadata) summary_op_util.collect(val, collections, [ops.GraphKeys.SUMMARIES]) return val
def gif_summary(name, tensor, max_outputs=3, fps=10, collections=None, family=None): """Outputs a `Summary` protocol buffer with gif animations. Args: name: Name of the summary. tensor: A 5-D `uint8` `Tensor` of shape `[batch_size, time, height, width, channels]` where `channels` is 1 or 3. max_outputs: Max number of batch elements to generate gifs for. fps: frames per second of the animation collections: Optional list of tf.GraphKeys. The collections to add the summary to. Defaults to [tf.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. Raises: ValueError: if the given tensor has the wrong shape. """ tensor = tf.convert_to_tensor(tensor) if len(tensor.get_shape()) != 5: raise ValueError("Assuming videos given as tensors in the format " "[batch, time, height, width, channels] but got one " "of shape: %s" % str(tensor.get_shape())) tensor = tf.cast(tensor, tf.uint8) if summary_op_util.skip_summary(): return tf.constant("") with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = tf.py_func( py_gif_summary, [tag, tensor, max_outputs, fps], tf.string, stateful=False, name=scope) summary_op_util.collect(val, collections, [tf.GraphKeys.SUMMARIES]) return val
def generic(self, name, tensor, metadata, family=None): """Write a generic-type summary. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A `Tensor` or compatible value type containing the value of the summary. metadata: Metadata about the summary. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_summary( self._resource, self._update_global_step_tensor(), _maybe_as_cpu_tensor(tensor), tag, _maybe_as_cpu_tensor(metadata), name=scope)
def histogram(name, values, collections=None, family=None): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with a histogram. Adding a histogram summary makes it possible to visualize your data's distribution in TensorBoard. You can see a detailed explanation of the TensorBoard histogram dashboard [here](https://www.tensorflow.org/get_started/tensorboard_histograms). The generated [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto) has one summary value containing a histogram for `values`. This op reports an `InvalidArgument` error if any value is not finite. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. values: A real numeric `Tensor`. Any shape. Values to use to build the histogram. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[values], default_name='HistogramSummary') as (tag, scope): val = _gen_logging_ops.histogram_summary(tag=tag, values=values, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def generic(self, name, tensor, metadata, family=None): """Write a generic-type summary. Args: name: A name for the generated node. Will also serve as the series name in TensorBoard. tensor: A `Tensor` or compatible value type containing the value of the summary. metadata: Metadata about the summary. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. """ with context.device(self._CPU_DEVICE): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_summary( self._resource, self._update_global_step_tensor(), _maybe_cpu(tensor), tag, _maybe_cpu(metadata), name=scope)
def histogram(name, values, collections=None, family=None): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with a histogram. Adding a histogram summary makes it possible to visualize your data's distribution in TensorBoard. You can see a detailed explanation of the TensorBoard histogram dashboard [here](https://www.tensorflow.org/get_started/tensorboard_histograms). The generated [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto) has one summary value containing a histogram for `values`. This op reports an `InvalidArgument` error if any value is not finite. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. values: A real numeric `Tensor`. Any shape. Values to use to build the histogram. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ if _summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[values], default_name='HistogramSummary') as (tag, scope): val = _gen_logging_ops.histogram_summary( tag=tag, values=values, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def gif_summary(name, tensor, max_outputs=3, fps=10, collections=None, family=None): """Outputs a `Summary` protocol buffer with gif animations. Args: name: Name of the summary. tensor: A 5-D `uint8` `Tensor` of shape `[batch_size, time, height, width, channels]` where `channels` is 1 or 3. max_outputs: Max number of batch elements to generate gifs for. fps: frames per second of the animation collections: Optional list of tf.GraphKeys. The collections to add the summary to. Defaults to [tf.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. """ # print('GIF SUMMARY', tensor.shape, type(tensor)) # rescaled_tensor = np.empty(tensor.shape) # for i in range(tensor.shape[0]): # rescaled_tensor[i] = utils.rescale_if_negative(tensor[i]) tensor = tf.convert_to_tensor(tensor) if summary_op_util.skip_summary(): return tf.constant("") with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): val = tf.py_func(py_gif_summary, [tag, tensor, max_outputs, fps], tf.string, stateful=False, name=scope) summary_op_util.collect(val, collections, [tf.GraphKeys.SUMMARIES]) return val
def audio(name, tensor, sample_rate, max_outputs=3, collections=None, family=None): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with audio. The summary has up to `max_outputs` summary values containing audio. The audio is built from `tensor` which must be 3-D with shape `[batch_size, frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`. The `tag` in the outputted Summary.Value protobufs is generated based on the name, with a suffix depending on the max_outputs setting: * If `max_outputs` is 1, the summary value tag is '*name*/audio'. * If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*name*/audio/0', '*name*/audio/1', etc Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 3-D `float32` `Tensor` of shape `[batch_size, frames, channels]` or a 2-D `float32` `Tensor` of shape `[batch_size, frames]`. sample_rate: A Scalar `float32` `Tensor` indicating the sample rate of the signal in hertz. max_outputs: Max number of batch elements to generate audio for. collections: Optional list of ops.GraphKeys. The collections to add the summary to. Defaults to [_ops.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. @compatibility(TF2) This API is not compatible with eager execution or `tf.function`. To migrate to TF2, please use `tf.summary.audio` instead. Please check [Migrating tf.summary usage to TF 2.0](https://www.tensorflow.org/tensorboard/migrate#in_tf_1x) for concrete steps for migration. #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :------------ | :-------------- | :------------------------------------- | | `name` | `name` | - | | `tensor` | `data` | Input for this argument now must be | : : : three-dimensional `[k, t, c]`, where : : : : `k` is the number of audio clips, `t` : : : : is the number of frames, and `c` is : : : : the number of channels. Two-dimensional: : : : input is no longer supported. : | `sample_rate` | `sample_rate` | - | | - | `step` | Explicit int64-castable monotonic step | : : : value. If omitted, this defaults to : : : : `tf.summary.experimental.get_step()`. : | `max_outputs` | `max_outputs` | - | | `collections` | Not Supported | - | | `family` | Removed | Please use `tf.name_scope` instead to | : : : manage summary name prefix. : | - | `encoding` | Optional constant str for the desired | : : : encoding. Check the docs for : : : : `tf.summary.audio` for latest supported: : : : audio formats. : | - | `description` | Optional long-form `str` description | : : : for the summary. Markdown is supported.: : : : Defaults to empty. : @end_compatibility """ if _distribute_summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family=family, values=[tensor]) as (tag, scope): sample_rate = _ops.convert_to_tensor( sample_rate, dtype=_dtypes.float32, name='sample_rate') val = _gen_logging_ops.audio_summary_v2( tag=tag, tensor=tensor, max_outputs=max_outputs, sample_rate=sample_rate, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def record(): with ops.name_scope(name_scope), summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): with ops.control_dependencies([function(tag, scope)]): return constant_op.constant(True)
def record(): with summary_op_util.summary_scope(name, family, values=[tensor]) as (tag, scope): function(tag, scope) return True
def record(): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): function(tag, scope) return True
def record(): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): gen_summary_ops.write_summary(context.context().summary_writer_resource, training_util.get_global_step(), tensor, tag, metadata, name=scope)
def image(name, tensor, max_outputs=3, collections=None, family=None): """Outputs a `Summary` protocol buffer with images. The summary has up to `max_outputs` summary values containing images. The images are built from `tensor` which must be 4-D with shape `[batch_size, height, width, channels]` and where `channels` can be: * 1: `tensor` is interpreted as Grayscale. * 3: `tensor` is interpreted as RGB. * 4: `tensor` is interpreted as RGBA. The images have the same number of channels as the input tensor. For float input, the values are normalized one image at a time to fit in the range `[0, 255]`. `uint8` values are unchanged. The op uses two different normalization algorithms: * If the input values are all positive, they are rescaled so the largest one is 255. * If any input value is negative, the values are shifted so input value 0.0 is at 127. They are then rescaled so that either the smallest value is 0, or the largest one is 255. The `tag` in the outputted Summary.Value protobufs is generated based on the name, with a suffix depending on the max_outputs setting: * If `max_outputs` is 1, the summary value tag is '*name*/image'. * If `max_outputs` is greater than 1, the summary value tags are generated sequentially as '*name*/image/0', '*name*/image/1', etc. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. tensor: A 4-D `uint8` or `float32` `Tensor` of shape `[batch_size, height, width, channels]` where `channels` is 1, 3, or 4. max_outputs: Max number of batch elements to generate images for. collections: Optional list of ops.GraphKeys. The collections to add the summary to. Defaults to [_ops.GraphKeys.SUMMARIES] family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. @compatibility(TF2) For compatibility purposes, when invoked in TF2 where the outermost context is eager mode, this API will check if there is a suitable TF2 summary writer context available, and if so will forward this call to that writer instead. A "suitable" writer context means that the writer is set as the default writer, and there is an associated non-empty value for `step` (see `tf.summary.SummaryWriter.as_default`, or alternatively `tf.summary.experimental.set_step`). For the forwarded call, the arguments here will be passed to the TF2 implementation of `tf.summary.image`, and the return value will be an empty bytestring tensor, to avoid duplicate summary writing. This forwarding is best-effort and not all arguments will be preserved. Additionally: * The TF2 op does not do any of the normalization steps described above. Rather than rescaling data that's outside the expected range, it simply clips it. * The TF2 op just outputs the data under a single tag that contains multiple samples, rather than multiple tags (i.e. no "/0" or "/1" suffixes). To migrate to TF2, please use `tf.summary.image` instead. Please check [Migrating tf.summary usage to TF 2.0](https://www.tensorflow.org/tensorboard/migrate#in_tf_1x) for concrete steps for migration. #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :------------ | :-------------- | :------------------------------------- | | `name` | `name` | - | | `tensor` | `data` | - | | - | `step` | Explicit int64-castable monotonic step | : : : value. If omitted, this defaults to : : : : `tf.summary.experimental.get_step()`. : | `max_outputs` | `max_outputs` | - | | `collections` | Not Supported | - | | `family` | Removed | Please use `tf.name_scope` instead | : : : to manage summary name prefix. : | - | `description` | Optional long-form `str` description | : : : for the summary. Markdown is supported.: : : : Defaults to empty. : @end_compatibility """ # Special case: invoke v2 op for TF2 users who have a v2 writer. if _should_invoke_v2_op(): # Defer the import to happen inside the symbol to prevent breakage due to # missing dependency. from tensorboard.summary.v2 import image as image_v2 # pylint: disable=g-import-not-at-top with _compat_summary_scope(name, family) as tag: image_v2( name=tag, data=tensor, step=_get_step_for_v2(), max_outputs=max_outputs) # Return an empty Tensor, which will be acceptable as an input to the # `tf.compat.v1.summary.merge()` API. return _constant_op.constant(b'') if _distribute_summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = _gen_logging_ops.image_summary( tag=tag, tensor=tensor, max_images=max_outputs, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def histogram(name, values, collections=None, family=None): # pylint: disable=line-too-long """Outputs a `Summary` protocol buffer with a histogram. Adding a histogram summary makes it possible to visualize your data's distribution in TensorBoard. You can see a detailed explanation of the TensorBoard histogram dashboard [here](https://www.tensorflow.org/get_started/tensorboard_histograms). The generated [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto) has one summary value containing a histogram for `values`. This op reports an `InvalidArgument` error if any value is not finite. Args: name: A name for the generated node. Will also serve as a series name in TensorBoard. values: A real numeric `Tensor`. Any shape. Values to use to build the histogram. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[GraphKeys.SUMMARIES]`. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. The serialized `Summary` protocol buffer. @compatibility(TF2) This API is not compatible with eager execution and `tf.function`. To migrate to TF2, please use `tf.summary.histogram` instead. Please check [Migrating tf.summary usage to TF 2.0](https://www.tensorflow.org/tensorboard/migrate#in_tf_1x) for concrete steps for migration. #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :------------ | :-------------- | :------------------------------------- | | `name` | `name` | - | | `values` | `data` | - | | - | `step` | Explicit int64-castable monotonic step | : : : value. If omitted, this defaults to : : : : `tf.summary.experimental.get_step()` : | - | `buckets` | Optional positive `int` specifying | : : : the histogram bucket number. : | `collections` | Not Supported | - | | `family` | Removed | Please use `tf.name_scope` instead | : : : to manage summary name prefix. : | - | `description` | Optional long-form `str` description | : : : for the summary. Markdown is supported.: : : : Defaults to empty. : @end_compatibility """ if _distribute_summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[values], default_name='HistogramSummary') as (tag, scope): val = _gen_logging_ops.histogram_summary( tag=tag, values=values, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val
def record(): with summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): with ops.control_dependencies([function(tag, scope)]): return constant_op.constant(True)
def scalar(name, tensor, collections=None, family=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]`. family: Optional; if provided, used as the prefix of the summary tag name, which controls the tab name used for display on Tensorboard. Returns: A scalar `Tensor` of type `string`. Which contains a `Summary` protobuf. Raises: ValueError: If tensor has the wrong shape or type. @compatibility(TF2) For compatibility purposes, when invoked in TF2 where the outermost context is eager mode, this API will check if there is a suitable TF2 summary writer context available, and if so will forward this call to that writer instead. A "suitable" writer context means that the writer is set as the default writer, and there is an associated non-empty value for `step` (see `tf.summary.SummaryWriter.as_default`, or alternatively `tf.summary.experimental.set_step`). For the forwarded call, the arguments here will be passed to the TF2 implementation of `tf.summary.scalar`, and the return value will be an empty bytestring tensor, to avoid duplicate summary writing. This forwarding is best-effort and not all arguments will be preserved. To migrate to TF2, please use `tf.summary.scalar` instead. Please check [Migrating tf.summary usage to TF 2.0](https://www.tensorflow.org/tensorboard/migrate#in_tf_1x) for concrete steps for migration. `tf.summary.scalar` can also log training metrics in Keras, you can check [Logging training metrics in Keras](https://www.tensorflow.org/tensorboard/scalars_and_keras) for detials. #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :------------ | :-------------- | :------------------------------------- | | `name` | `name` | - | | `tensor` | `data` | - | | - | `step` | Explicit int64-castable monotonic step | : : : value. If omitted, this defaults to : : : : `tf.summary.experimental.get_step()`. : | `collections` | Not Supported | - | | `family` | Removed | Please use `tf.name_scope` instead to | : : : manage summary name prefix. : | - | `description` | Optional long-form `str` description | : : : for the summary. Markdown is supported.: : : : Defaults to empty. : @end_compatibility """ # Special case: invoke v2 op for TF2 users who have a v2 writer. if _should_invoke_v2_op(): # Defer the import to happen inside the symbol to prevent breakage due to # missing dependency. from tensorboard.summary.v2 import scalar as scalar_v2 # pylint: disable=g-import-not-at-top with _compat_summary_scope(name, family) as tag: scalar_v2(name=tag, data=tensor, step=_get_step_for_v2()) # Return an empty Tensor, which will be acceptable as an input to the # `tf.compat.v1.summary.merge()` API. return _constant_op.constant(b'') # Fall back to legacy v1 scalar implementation. if _distribute_summary_op_util.skip_summary(): return _constant_op.constant('') with _summary_op_util.summary_scope( name, family, values=[tensor]) as (tag, scope): val = _gen_logging_ops.scalar_summary(tags=tag, values=tensor, name=scope) _summary_op_util.collect(val, collections, [_ops.GraphKeys.SUMMARIES]) return val