open3d.visualization.tensorboard_plugin.summary.SummaryWriter#

class open3d.visualization.tensorboard_plugin.summary.SummaryWriter(log_dir=None, comment='', purge_step=None, max_queue=10, flush_secs=120, filename_suffix='')#

Writes entries directly to event files in the log_dir to be consumed by TensorBoard.

The SummaryWriter class provides a high-level API to create an event file in a given directory and add summaries and events to it. The class updates the file contents asynchronously. This allows a training program to call methods to add data to the file directly from the training loop, without slowing down training.

__init__(log_dir=None, comment='', purge_step=None, max_queue=10, flush_secs=120, filename_suffix='')#

Create a SummaryWriter that will write out events and summaries to the event file.

Parameters:

log_dir (str) – Save directory location. Default is runs/CURRENT_DATETIME_HOSTNAME, which changes after each run. Use hierarchical folder structure to compare between runs easily. e.g. pass in ‘runs/exp1’, ‘runs/exp2’, etc. for each new experiment to compare across them.
comment (str) – Comment log_dir suffix appended to the default log_dir. If log_dir is assigned, this argument has no effect.
purge_step (int) – When logging crashes at step \(T+X\) and restarts at step \(T\), any events whose global_step larger or equal to \(T\) will be purged and hidden from TensorBoard. Note that crashed and resumed experiments should have the same log_dir.
max_queue (int) – Size of the queue for pending events and summaries before one of the ‘add’ calls forces a flush to disk. Default is ten items.
flush_secs (int) – How often, in seconds, to flush the pending events and summaries to disk. Default is every two minutes.
filename_suffix (str) – Suffix added to all event filenames in the log_dir directory. More details on filename construction in tensorboard.summary.writer.event_file_writer.EventFileWriter.

Examples:

from torch.utils.tensorboard import SummaryWriter

# create a summary writer with automatically generated folder name.
writer = SummaryWriter()
# folder location: runs/May04_22-14-54_s-MacBook-Pro.local/

# create a summary writer using the specified folder name.
writer = SummaryWriter("my_experiment")
# folder location: my_experiment

# create a summary writer with comment appended.
writer = SummaryWriter(comment="LR_0.1_BATCH_16")
# folder location: runs/May04_22-14-54_s-MacBook-Pro.localLR_0.1_BATCH_16/

add_3d(tag, data, step, logdir=None, max_outputs=1, label_to_names=None, description=None)#

Write 3D geometry data as TensorBoard summary for visualization with the Open3D for TensorBoard plugin.

Parameters:

name (str) – A name or tag for this summary. The summary tag used for TensorBoard will be this name prefixed by any active name scopes.
data (dict) –
A dictionary of tensors representing 3D data. Tensorflow, PyTorch, Numpy and Open3D tensors are supported. The following keys are supported: - vertex_positions: shape (B, N, 3) where B is the number of point

clouds and must be same for each key. N is the number of 3D points. Will be cast to float32.
- vertex_colors: shape (B, N, 3) Will be converted to uint8.
- vertex_normals: shape (B, N, 3) Will be cast to float32.
- vertex_texture_uvs: shape (B, N, 2) Per vertex UV coordinates for applying material texture maps. Will be cast to float32. Only one of [vertex|triangle]_texture_uvs should be provided.
- vertex_[FEATURE]: shape (B, N, _). Store custom vertex features. Floats will be cast to float32 and integers to int32.
- triangle_indices: shape (B, Nf, 3). Will be cast to uint32.
- triangle_colors: shape (B, Nf, 3) Will be converted to uint8.
- triangle_normals: shape (B, Nf, 3) Will be cast to float32.
- triangle_texture_uvs: shape (B, Nf, 3, 2) Per triangle UV coordinates for applying material texture maps. Will be cast to float32. Only one of [vertex|triangle]_texture_uvs should be provided.
- line_indices: shape (B, Nl, 2). Will be cast to uint32.
- bboxes: shape (B, Nbb). The tensor dtype should be open3d.ml.vis.BoundingBox3D. The boxes will be colored according to their labels in tensorboard. Visualizing confidences is not yet supported. Property references are not supported. Use separate from other 3D data.
- material_name: shape (B,) and dtype str. Base PBR material name is required to specify any material properties. Open3D built-in materials: defaultLit, defaultUnlit, unlitLine, unlitGradient, unlitSolidColor.
- material_scalar_[PROPERTY]: Any material scalar property with float values of shape (B,). e.g. To specify the property metallic, use the key material_scalar_metallic.
- material_vector_[PROPERTY]: Any material 4-vector property with float values of shape (B, 4) e.g. To specify the property baseColor, use the key material_vector_base_color.
- material_texture_map_[PROPERTY]: PBR material texture maps. e.g. material_texture_map_metallic represents a texture map describing the metallic property for rendering. Values are Tensors with shape (B, Nr, Nc, C), corresponding to a batch of texture maps with C channels and shape (Nr, Nc). The geometry must have [vertex|triangle]_texture_uvs coordinates to use any texture map.
For batch_size B=1, the tensors may drop a rank (e.g. (N,3) vertex_positions, (4,) material vector properties or float scalar () material scalar properties.). Variable sized elements in a batch are also supported. In this case, use a sequence of tensors. For example, to save a batch of 2 point clouds with 8 and 16 points each, data should contain {‘vertex_positions’: (pcd1, pcd2)} where pcd1.shape = (8, 3) and pcd2.shape = (16, 3).

Floating point color and texture map data will be clipped to the range [0,1] and converted to uint8 range [0,255]. uint16 data will be compressed to the range [0,255].

Any data tensor (with ndim>=2 including batch_size), may be replaced by an int scalar referring to a previous step. This allows reusing a previously written property in case that it does not change at different steps. This is not supported for material_name, material_scalar_*PROPERTY* and custom vertex features.

Please see the Filament Materials Guide for a complete description of material properties.
step (int) – Explicit int64-castable monotonic step value for this summary. [TensorFlow: If None, this defaults to tf.summary.experimental.get_step(), which must not be None.]
logdir (str) – The logging directory used to create the SummaryWriter. [PyTorch: This will be automatically inferred if not provided or None.]
max_outputs (int) – Optional integer. At most this many 3D elements will be emitted at each step. When more than max_outputs 3D elements are provided, the first max_outputs 3D elements will be used and the rest silently discarded. Use 0 to save everything.
label_to_names (dict) – Optional mapping from labels (e.g. int used in labels for bboxes or vertices) to category names. Only data from the first step is saved for any tag during a run.
description (str) – Optional long-form description for this summary, as a constant str. Markdown is supported. Defaults to empty. Currently unused.

Returns:

[TensorFlow] True on success, or false if no summary was emitted because no default summary writer was available.

Raises:

ValueError – if a default writer exists, but no step was provided and tf.summary.experimental.get_step() is None. Also raised when used with Tensorflow and logdir is not provided or None.
RuntimeError – Module level function is used without a TensorFlow installation. Use the PyTorch SummaryWriter.add_3d() bound method instead.

Examples

With Tensorflow:

import tensorflow as tf
import open3d as o3d
from open3d.visualization.tensorboard_plugin import summary
from open3d.visualization.tensorboard_plugin.util import to_dict_batch
logdir = "demo_logs/"
writer = tf.summary.create_file_writer(logdir)
cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4)
cube.compute_vertex_normals()
colors = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
with writer.as_default():
    for step in range(3):
        cube.paint_uniform_color(colors[step])
        summary.add_3d('cube',
                       to_dict_batch([cube]),
                       step=step,
                       logdir=logdir)

With PyTorch:

(Note that the import summary is needed to make add_3d() available, even though summary is not used.)

from torch.utils.tensorboard import SummaryWriter
import open3d as o3d
from open3d.visualization.tensorboard_plugin import summary  # noqa
from open3d.visualization.tensorboard_plugin.util import to_dict_batch
writer = SummaryWriter("demo_logs/")
cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4)
cube.compute_vertex_normals()
colors = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
for step in range(3):
    cube.paint_uniform_color(colors[step])
    writer.add_3d('cube', to_dict_batch([cube]), step=step)

Now use tensorboard --logdir demo_logs to visualize the 3D data.

Note

Summary writing works on all platforms, and the visualization can be accessed from a browser on any platform. Running the tensorboard process is not supported on macOS as yet.

add_audio(tag, snd_tensor, global_step=None, sample_rate=44100, walltime=None)#

Add audio data to summary.

Parameters:

tag (str) – Data identifier
snd_tensor (torch.Tensor) – Sound data
global_step (int) – Global step value to record
sample_rate (int) – sample rate in Hz
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event

Shape:: snd_tensor: \((1, L)\). The values should lie between [-1, 1].

add_custom_scalars(layout)#

Create special chart by collecting charts tags in ‘scalars’.

NOTE: This function can only be called once for each SummaryWriter() object.

Because it only provides metadata to tensorboard, the function can be called before or after the training loop.

Parameters:: layout (dict) – {categoryName: charts}, where charts is also a dictionary {chartName: ListOfProperties}. The first element in ListOfProperties is the chart’s type (one of Multiline or Margin) and the second element should be a list containing the tags you have used in add_scalar function, which will be collected into the new chart.

Examples:

layout = {'Taiwan':{'twse':['Multiline',['twse/0050', 'twse/2330']]},
             'USA':{ 'dow':['Margin',   ['dow/aaa', 'dow/bbb', 'dow/ccc']],
                  'nasdaq':['Margin',   ['nasdaq/aaa', 'nasdaq/bbb', 'nasdaq/ccc']]}}

writer.add_custom_scalars(layout)

add_custom_scalars_marginchart(tags, category='default', title='untitled')#

Shorthand for creating marginchart.

Similar to add_custom_scalars(), but the only necessary argument is tags, which should have exactly 3 elements.

Parameters:: tags (list) – list of tags that have been used in add_scalar()

Examples:

writer.add_custom_scalars_marginchart(['twse/0050', 'twse/2330', 'twse/2006'])

add_custom_scalars_multilinechart(tags, category='default', title='untitled')#

Shorthand for creating multilinechart. Similar to add_custom_scalars(), but the only necessary argument is tags.

Parameters:: tags (list) – list of tags that have been used in add_scalar()

Examples:

writer.add_custom_scalars_multilinechart(['twse/0050', 'twse/2330'])

add_embedding(mat, metadata=None, label_img=None, global_step=None, tag='default', metadata_header=None)#

Add embedding projector data to summary.

Parameters:

mat (torch.Tensor or numpy.ndarray) – A matrix which each row is the feature vector of the data point
metadata (list) – A list of labels, each element will be convert to string
label_img (torch.Tensor) – Images correspond to each data point
global_step (int) – Global step value to record
tag (str) – Name for the embedding

Shape:

mat: \((N, D)\), where N is number of data and D is feature dimension

label_img: \((N, C, H, W)\)

Examples:

import keyword
import torch
meta = []
while len(meta)<100:
    meta = meta+keyword.kwlist # get some strings
meta = meta[:100]

for i, v in enumerate(meta):
    meta[i] = v+str(i)

label_img = torch.rand(100, 3, 10, 32)
for i in range(100):
    label_img[i]*=i/100.0

writer.add_embedding(torch.randn(100, 5), metadata=meta, label_img=label_img)
writer.add_embedding(torch.randn(100, 5), label_img=label_img)
writer.add_embedding(torch.randn(100, 5), metadata=meta)

add_figure(tag: str, figure: Figure | List[Figure], global_step: int | None = None, close: bool = True, walltime: float | None = None) → None#

Render matplotlib figure into an image and add it to summary.

Note that this requires the matplotlib package.

Parameters:

tag – Data identifier
figure – Figure or a list of figures
global_step – Global step value to record
close – Flag to automatically close the figure
walltime – Optional override default walltime (time.time()) seconds after epoch of event

add_graph(model, input_to_model=None, verbose=False, use_strict_trace=True)#

Add graph data to summary.

Parameters:

model (torch.nn.Module) – Model to draw.
input_to_model (torch.Tensor or list of torch.Tensor) – A variable or a tuple of variables to be fed.
verbose (bool) – Whether to print graph structure in console.
use_strict_trace (bool) – Whether to pass keyword argument strict to torch.jit.trace. Pass False when you want the tracer to record your mutable container types (list, dict)

add_histogram(tag, values, global_step=None, bins='tensorflow', walltime=None, max_bins=None)#

Add histogram to summary.

Parameters:

tag (str) – Data identifier
values (torch.Tensor, numpy.ndarray, or string/blobname) – Values to build histogram
global_step (int) – Global step value to record
bins (str) – One of {‘tensorflow’,’auto’, ‘fd’, …}. This determines how the bins are made. You can find other options in: https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event

Examples:

from torch.utils.tensorboard import SummaryWriter
import numpy as np
writer = SummaryWriter()
for i in range(10):
    x = np.random.random(1000)
    writer.add_histogram('distribution centers', x + i, i)
writer.close()

Expected result:

python_api/_static/img/tensorboard/add_histogram.png

add_histogram_raw(tag, min, max, num, sum, sum_squares, bucket_limits, bucket_counts, global_step=None, walltime=None)#

Add histogram with raw data.

Parameters:

tag (str) – Data identifier
min (float or int) – Min value
max (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 (torch.Tensor, numpy.ndarray) – Upper value per bucket. The number of elements of it should be the same as bucket_counts.
bucket_counts (torch.Tensor, numpy.ndarray) – Number of values per bucket
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event
see – https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/histogram/README.md

Examples:

from torch.utils.tensorboard import SummaryWriter
import numpy as np
writer = SummaryWriter()
dummy_data = []
for idx, value in enumerate(range(50)):
    dummy_data += [idx + 0.001] * value

bins = list(range(50+2))
bins = np.array(bins)
values = np.array(dummy_data).astype(float).reshape(-1)
counts, limits = np.histogram(values, bins=bins)
sum_sq = values.dot(values)
writer.add_histogram_raw(
    tag='histogram_with_raw_data',
    min=values.min(),
    max=values.max(),
    num=len(values),
    sum=values.sum(),
    sum_squares=sum_sq,
    bucket_limits=limits[1:].tolist(),
    bucket_counts=counts.tolist(),
    global_step=0)
writer.close()

Expected result:

python_api/_static/img/tensorboard/add_histogram_raw.png

add_hparams(hparam_dict, metric_dict, hparam_domain_discrete=None, run_name=None, global_step=None)#

Add a set of hyperparameters to be compared in TensorBoard.

Parameters:

hparam_dict (dict) – Each key-value pair in the dictionary is the name of the hyper parameter and it’s corresponding value. The type of the value can be one of bool, string, float, int, or None.
metric_dict (dict) – Each key-value pair in the dictionary is the name of the metric and it’s corresponding value. Note that the key used here should be unique in the tensorboard record. Otherwise the value you added by add_scalar will be displayed in hparam plugin. In most cases, this is unwanted.
hparam_domain_discrete – (Optional[Dict[str, List[Any]]]) A dictionary that contains names of the hyperparameters and all discrete values they can hold
run_name (str) – Name of the run, to be included as part of the logdir. If unspecified, will use current timestamp.
global_step (int) – Global step value to record

Examples:

from torch.utils.tensorboard import SummaryWriter
with SummaryWriter() as w:
    for i in range(5):
        w.add_hparams({'lr': 0.1*i, 'bsize': i},
                      {'hparam/accuracy': 10*i, 'hparam/loss': 10*i})

Expected result:

python_api/_static/img/tensorboard/add_hparam.png

add_image(tag, img_tensor, global_step=None, walltime=None, dataformats='CHW')#

Add image data to summary.

Note that this requires the pillow package.

Parameters:

tag (str) – Data identifier
img_tensor (torch.Tensor, numpy.ndarray, or string/blobname) – Image data
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event
dataformats (str) – Image data format specification of the form CHW, HWC, HW, WH, etc.

Shape:: img_tensor: Default is \((3, H, W)\). You can use torchvision.utils.make_grid() to convert a batch of tensor into 3xHxW format or call add_images and let us do the job. Tensor with \((1, H, W)\), \((H, W)\), \((H, W, 3)\) is also suitable as long as corresponding dataformats argument is passed, e.g. CHW, HWC, HW.

Examples:

from torch.utils.tensorboard import SummaryWriter
import numpy as np
img = np.zeros((3, 100, 100))
img[0] = np.arange(0, 10000).reshape(100, 100) / 10000
img[1] = 1 - np.arange(0, 10000).reshape(100, 100) / 10000

img_HWC = np.zeros((100, 100, 3))
img_HWC[:, :, 0] = np.arange(0, 10000).reshape(100, 100) / 10000
img_HWC[:, :, 1] = 1 - np.arange(0, 10000).reshape(100, 100) / 10000

writer = SummaryWriter()
writer.add_image('my_image', img, 0)

# If you have non-default dimension setting, set the dataformats argument.
writer.add_image('my_image_HWC', img_HWC, 0, dataformats='HWC')
writer.close()

Expected result:

python_api/_static/img/tensorboard/add_image.png

add_image_with_boxes(tag, img_tensor, box_tensor, global_step=None, walltime=None, rescale=1, dataformats='CHW', labels=None)#

Add image and draw bounding boxes on the image.

Parameters:

tag (str) – Data identifier
img_tensor (torch.Tensor, numpy.ndarray, or string/blobname) – Image data
box_tensor (torch.Tensor, numpy.ndarray, or string/blobname) – Box data (for detected objects) box should be represented as [x1, y1, x2, y2].
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event
rescale (float) – Optional scale override
dataformats (str) – Image data format specification of the form NCHW, NHWC, CHW, HWC, HW, WH, etc.
labels (list of string) – The label to be shown for each bounding box.

Shape:

img_tensor: Default is \((3, H, W)\). It can be specified with dataformats argument. e.g. CHW or HWC

box_tensor: (torch.Tensor, numpy.ndarray, or string/blobname): NX4, where N is the number of boxes and each 4 elements in a row represents (xmin, ymin, xmax, ymax).

add_images(tag, img_tensor, global_step=None, walltime=None, dataformats='NCHW')#

Add batched image data to summary.

Note that this requires the pillow package.

Parameters:

tag (str) – Data identifier
img_tensor (torch.Tensor, numpy.ndarray, or string/blobname) – Image data
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event
dataformats (str) – Image data format specification of the form NCHW, NHWC, CHW, HWC, HW, WH, etc.

Shape:: img_tensor: Default is \((N, 3, H, W)\). If dataformats is specified, other shape will be accepted. e.g. NCHW or NHWC.

Examples:

from torch.utils.tensorboard import SummaryWriter
import numpy as np

img_batch = np.zeros((16, 3, 100, 100))
for i in range(16):
    img_batch[i, 0] = np.arange(0, 10000).reshape(100, 100) / 10000 / 16 * i
    img_batch[i, 1] = (1 - np.arange(0, 10000).reshape(100, 100) / 10000) / 16 * i

writer = SummaryWriter()
writer.add_images('my_image_batch', img_batch, 0)
writer.close()

Expected result:

python_api/_static/img/tensorboard/add_images.png

add_mesh(tag, vertices, colors=None, faces=None, config_dict=None, global_step=None, walltime=None)#

Add meshes or 3D point clouds to TensorBoard.

The visualization is based on Three.js, so it allows users to interact with the rendered object. Besides the basic definitions such as vertices, faces, users can further provide camera parameter, lighting condition, etc. Please check https://threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene for advanced usage.

Parameters:

tag (str) – Data identifier
vertices (torch.Tensor) – List of the 3D coordinates of vertices.
colors (torch.Tensor) – Colors for each vertex
faces (torch.Tensor) – Indices of vertices within each triangle. (Optional)
config_dict – Dictionary with ThreeJS classes names and configuration.
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event

Shape:

vertices: \((B, N, 3)\). (batch, number_of_vertices, channels)

colors: \((B, N, 3)\). The values should lie in [0, 255] for type uint8 or [0, 1] for type float.

faces: \((B, N, 3)\). The values should lie in [0, number_of_vertices] for type uint8.

Examples:

from torch.utils.tensorboard import SummaryWriter
vertices_tensor = torch.as_tensor([
    [1, 1, 1],
    [-1, -1, 1],
    [1, -1, -1],
    [-1, 1, -1],
], dtype=torch.float).unsqueeze(0)
colors_tensor = torch.as_tensor([
    [255, 0, 0],
    [0, 255, 0],
    [0, 0, 255],
    [255, 0, 255],
], dtype=torch.int).unsqueeze(0)
faces_tensor = torch.as_tensor([
    [0, 2, 3],
    [0, 3, 1],
    [0, 1, 2],
    [1, 3, 2],
], dtype=torch.int).unsqueeze(0)

writer = SummaryWriter()
writer.add_mesh('my_mesh', vertices=vertices_tensor, colors=colors_tensor, faces=faces_tensor)

writer.close()

add_onnx_graph(prototxt)#

add_pr_curve(tag, labels, predictions, global_step=None, num_thresholds=127, weights=None, walltime=None)#

Add precision recall curve.

Plotting a precision-recall curve lets you understand your model’s performance under different threshold settings. With this function, you provide the ground truth labeling (T/F) and prediction confidence (usually the output of your model) for each target. The TensorBoard UI will let you choose the threshold interactively.

Parameters:

tag (str) – Data identifier
labels (torch.Tensor, numpy.ndarray, or string/blobname) – Ground truth data. Binary label for each element.
predictions (torch.Tensor, numpy.ndarray, or string/blobname) – The probability that an element be classified as true. Value should be in [0, 1]
global_step (int) – Global step value to record
num_thresholds (int) – Number of thresholds used to draw the curve.
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event

Examples:

from torch.utils.tensorboard import SummaryWriter
import numpy as np
labels = np.random.randint(2, size=100)  # binary label
predictions = np.random.rand(100)
writer = SummaryWriter()
writer.add_pr_curve('pr_curve', labels, predictions, 0)
writer.close()

add_pr_curve_raw(tag, true_positive_counts, false_positive_counts, true_negative_counts, false_negative_counts, precision, recall, global_step=None, num_thresholds=127, weights=None, walltime=None)#

Add precision recall curve with raw data.

Parameters:

tag (str) – Data identifier
true_positive_counts (torch.Tensor, numpy.ndarray, or string/blobname) – true positive counts
false_positive_counts (torch.Tensor, numpy.ndarray, or string/blobname) – false positive counts
true_negative_counts (torch.Tensor, numpy.ndarray, or string/blobname) – true negative counts
false_negative_counts (torch.Tensor, numpy.ndarray, or string/blobname) – false negative counts
precision (torch.Tensor, numpy.ndarray, or string/blobname) – precision
recall (torch.Tensor, numpy.ndarray, or string/blobname) – recall
global_step (int) – Global step value to record
num_thresholds (int) – Number of thresholds used to draw the curve.
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event
see – https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/pr_curve/README.md

add_scalar(tag, scalar_value, global_step=None, walltime=None, new_style=False, double_precision=False)#

Add scalar data to summary.

Parameters:

tag (str) – Data identifier
scalar_value (float or string/blobname) – Value to save
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) with seconds after epoch of event
new_style (boolean) – Whether to use new style (tensor field) or old style (simple_value field). New style could lead to faster data loading.

Examples:

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()
x = range(100)
for i in x:
    writer.add_scalar('y=2x', i * 2, i)
writer.close()

Expected result:

python_api/_static/img/tensorboard/add_scalar.png

add_scalars(main_tag, tag_scalar_dict, global_step=None, walltime=None)#

Add many scalar data to summary.

Parameters:

main_tag (str) – The parent name for the tags
tag_scalar_dict (dict) – Key-value pair storing the tag and corresponding values
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event

Examples:

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()
r = 5
for i in range(100):
    writer.add_scalars('run_14h', {'xsinx':i*np.sin(i/r),
                                    'xcosx':i*np.cos(i/r),
                                    'tanx': np.tan(i/r)}, i)
writer.close()
# This call adds three values to the same scalar plot with the tag
# 'run_14h' in TensorBoard's scalar section.

Expected result:

python_api/_static/img/tensorboard/add_scalars.png

add_tensor(tag, tensor, global_step=None, walltime=None)#

Add tensor data to summary.

Parameters:

tag (str) – Data identifier
tensor (torch.Tensor) – tensor to save
global_step (int) – Global step value to record

Examples:

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()
x = torch.tensor([1,2,3])
writer.add_scalar('x', x)
writer.close()

Expected result:

Summary::tensor::float_val [1,2,3]: ::tensor::shape [3] ::tag ‘x’

add_text(tag, text_string, global_step=None, walltime=None)#

Add text data to summary.

Parameters:

tag (str) – Data identifier
text_string (str) – String to save
global_step (int) – Global step value to record
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event

Examples:

writer.add_text('lstm', 'This is an lstm', 0)
writer.add_text('rnn', 'This is an rnn', 10)

add_video(tag, vid_tensor, global_step=None, fps=4, walltime=None)#

Add video data to summary.

Note that this requires the moviepy package.

Parameters:

tag (str) – Data identifier
vid_tensor (torch.Tensor) – Video data
global_step (int) – Global step value to record
fps (float or int) – Frames per second
walltime (float) – Optional override default walltime (time.time()) seconds after epoch of event

Shape:: vid_tensor: \((N, T, C, H, W)\). The values should lie in [0, 255] for type uint8 or [0, 1] for type float.

close()#

flush()#

Flushes the event file to disk.

Call this method to make sure that all pending events have been written to disk.

get_logdir()#: Return the directory where event files will be written.