Defines Data Types for logging interactive visualizations to W&B.
1 - Audio
class Audio
W&B class for audio clips.
Attributes:
data_or_path(string or numpy array): A path to an audio file or a numpy array of audio data.sample_rate(int): Sample rate, required when passing in raw numpy array of audio data.caption(string): Caption to display with audio.
method Audio.__init__
__init__(
data_or_path: Union[str, pathlib.Path, list, ForwardRef('np.ndarray')],
sample_rate: Optional[int] = None,
caption: Optional[str] = None
)
Accept a path to an audio file or a numpy array of audio data.
2 - box3d()
function box3d
box3d(
center: 'npt.ArrayLike',
size: 'npt.ArrayLike',
orientation: 'npt.ArrayLike',
color: 'RGBColor',
label: 'Optional[str]' = None,
score: 'Optional[numeric]' = None
) → Box3D
Returns a Box3D.
Args:
center: The center point of the box as a length-3 ndarray.size: The box’s X, Y and Z dimensions as a length-3 ndarray.orientation: The rotation transforming global XYZ coordinates into the box’s local XYZ coordinates, given as a length-4 ndarray [r, x, y, z] corresponding to the non-zero quaternion r + xi + yj + zk.color: The box’s color as an (r, g, b) tuple with 0 <= r,g,b <= 1.label: An optional label for the box.score: An optional score for the box.
3 - Html
class Html
W&B class for logging HTML content to W&B.
Args:
data: HTML to display in wandbinject: Add a stylesheet to the HTML object. If set to False the HTML will pass through unchanged.
method Html.__init__
__init__(
data: Union[str, pathlib.Path, ForwardRef('TextIO')],
inject: bool = True,
data_is_not_path: bool = False
) → None
Creates a W&B HTML object.
It can be initialized by providing a path to a file:
with wandb.init() as run:
run.log({"html": wandb.Html("./index.html")})
Alternatively, it can be initialized by providing literal HTML, in either a string or IO object:
with wandb.init() as run:
run.log({"html": wandb.Html("<h1>Hello, world!</h1>")})
Args: data: A string that is a path to a file with the extension “.html”, or a string or IO object containing literal HTML.
inject: Add a stylesheet to the HTML object. If set to False the HTML will pass through unchanged.data_is_not_path: If set to False, the data will be treated as a path to a file.
4 - Image
class Image
A class for logging images to W&B.
See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for more information on modes.
Args:
data_or_path: Accepts numpy array of image data, or a PIL image. The class attempts to infer the data format and converts it.mode: The PIL mode for an image. Most common are “L”, “RGB”, “RGBA”.caption: Label for display of image.
When logging a torch.Tensor as a wandb.Image, images are normalized. If you do not want to normalize your images, convert your tensors to a PIL Image.
Examples:
# Create a wandb.Image from a numpy array
import numpy as np
import wandb
with wandb.init() as run:
examples = []
for i in range(3):
pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
image = wandb.Image(pixels, caption=f"random field {i}")
examples.append(image)
run.log({"examples": examples})
# Create a wandb.Image from a PILImage
import numpy as np
from PIL import Image as PILImage
import wandb
with wandb.init() as run:
examples = []
for i in range(3):
pixels = np.random.randint(
low=0, high=256, size=(100, 100, 3), dtype=np.uint8
)
pil_image = PILImage.fromarray(pixels, mode="RGB")
image = wandb.Image(pil_image, caption=f"random field {i}")
examples.append(image)
run.log({"examples": examples})
# log .jpg rather than .png (default)
import numpy as np
import wandb
with wandb.init() as run:
examples = []
for i in range(3):
pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
image = wandb.Image(pixels, caption=f"random field {i}", file_type="jpg")
examples.append(image)
run.log({"examples": examples})
method Image.__init__
__init__(
data_or_path: 'ImageDataOrPathType',
mode: Optional[str] = None,
caption: Optional[str] = None,
grouping: Optional[int] = None,
classes: Optional[ForwardRef('Classes'), Sequence[dict]] = None,
boxes: Optional[Dict[str, ForwardRef('BoundingBoxes2D')], Dict[str, dict]] = None,
masks: Optional[Dict[str, ForwardRef('ImageMask')], Dict[str, dict]] = None,
file_type: Optional[str] = None,
normalize: bool = True
) → None
Initialize a wandb.Image object.
Args:
data_or_path: Accepts numpy array/pytorch tensor of image data, a PIL image object, or a path to an image file.
If a numpy array or pytorch tensor is provided, the image data will be saved to the given file type. If the values are not in the range [0, 255] or all values are in the range [0, 1], the image pixel values will be normalized to the range [0, 255] unless normalize is set to False.
- pytorch tensor should be in the format (channel, height, width)
- numpy array should be in the format (height, width, channel)
mode: The PIL mode for an image. Most common are “L”, “RGB”,"RGBA". Full explanation at https: //pillow.readthedocs.io/en/stable/handbook/concepts.html#modescaption: Label for display of image.grouping: The grouping number for the image.classes: A list of class information for the image, used for labeling bounding boxes, and image masks.boxes: A dictionary containing bounding box information for the image.see: https://docs.wandb.ai/ref/python/data-types/boundingboxes2d/masks: A dictionary containing mask information for the image.see: https://docs.wandb.ai/ref/python/data-types/imagemask/file_type: The file type to save the image as. This parameter has no effect if data_or_path is a path to an image file.normalize: If True, normalize the image pixel values to fall within the range of [0, 255]. Normalize is only applied if data_or_path is a numpy array or pytorch tensor.
Examples:
Create a wandb.Image from a numpy array ```python
import numpy as np
import wandb
with wandb.init() as run:
examples = []
for i in range(3):
pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
image = wandb.Image(pixels, caption=f"random field {i}")
examples.append(image)
run.log({"examples": examples})
```
Create a wandb.Image from a PILImage ```python
import numpy as np
from PIL import Image as PILImage
import wandb
with wandb.init() as run:
examples = []
for i in range(3):
pixels = np.random.randint(
low=0, high=256, size=(100, 100, 3), dtype=np.uint8
)
pil_image = PILImage.fromarray(pixels, mode="RGB")
image = wandb.Image(pil_image, caption=f"random field {i}")
examples.append(image)
run.log({"examples": examples})
```
log .jpg rather than .png (default) ```python
import numpy as np
import wandb
with wandb.init() as run:
examples = []
for i in range(3):
pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
image = wandb.Image(
pixels, caption=f"random field {i}", file_type="jpg"
)
examples.append(image)
run.log({"examples": examples})
```
method Image.guess_mode
guess_mode(
data: Union[ForwardRef('np.ndarray'), ForwardRef('torch.Tensor')],
file_type: Optional[str] = None
) → str
Guess what type of image the np.array is representing.
5 - Molecule
class Molecule
W&B class for 3D Molecular data.
Args:
data_or_path: (pathlib.Path, string, io) Molecule can be initialized from a file name or an io object.caption: (string) Caption associated with the molecule for display.
method Molecule.__init__
__init__(
data_or_path: Union[str, pathlib.Path, ForwardRef('TextIO')],
caption: Optional[str] = None,
**kwargs: str
) → None
6 - Object3D
class Object3D
W&B class for 3D point clouds.
Args:
data_or_path: (numpy array, pathlib.Path, string, io) Object3D can be initialized from a file or a numpy array.
Examples: The shape of the numpy array must be one of either
[[x y z], ...] nx3
[[x y z c], ...] nx4 where c is a category with supported range [1, 14]
[[x y z r g b], ...] nx6 where is rgb is color
method Object3D.__init__
__init__(
data_or_path: Union[ForwardRef('np.ndarray'), str, pathlib.Path, ForwardRef('TextIO'), dict],
caption: Optional[str] = None,
**kwargs: Optional[str, ForwardRef('FileFormat3D')]
) → None
7 - Plotly
class Plotly
W&B class for Plotly plots.
Args:
val: Matplotlib or Plotly figure.
method Plotly.__init__
__init__(
val: Union[ForwardRef('plotly.Figure'), ForwardRef('matplotlib.artist.Artist')]
)
classmethod Plotly.get_media_subdir
get_media_subdir() → str
classmethod Plotly.make_plot_media
make_plot_media(
val: Union[ForwardRef('plotly.Figure'), ForwardRef('matplotlib.artist.Artist')]
) → Union[wandb.sdk.data_types.image.Image, ForwardRef('Plotly')]
method Plotly.to_json
to_json(
run_or_artifact: Union[ForwardRef('LocalRun'), ForwardRef('Artifact')]
) → dict
8 - Table
class Table
The Table class used to display and analyze tabular data.
Unlike traditional spreadsheets, Tables support numerous types of data: scalar values, strings, numpy arrays, and most subclasses of wandb.data_types.Media. This means you can embed Images, Video, Audio, and other sorts of rich, annotated media directly in Tables, alongside other traditional scalar values.
This class is the primary class used to generate the Table Visualizer in the UI: https://docs.wandb.ai/guides/data-vis/tables.
Attributes:
columns(List[str]): Names of the columns in the table. Defaults to [“Input”, “Output”, “Expected”].data: (List[List[any]]) 2D row-oriented array of values.dataframe(pandas.DataFrame): DataFrame object used to create the table. When set,dataandcolumnsarguments are ignored.optional(Union[bool,List[bool]]): Determines ifNonevalues are allowed. Default toTrue. - If a singular bool value, then the optionality is enforced for all columns specified at construction time. - If a list of bool values, then the optionality is applied to each column - should be the same length ascolumns. applies to all columns. A list of bool values applies to each respective column.allow_mixed_types(bool): Determines if columns are allowed to have mixed types (disables type validation). Defaults to False.
method Table.__init__
__init__(
columns=None,
data=None,
rows=None,
dataframe=None,
dtype=None,
optional=True,
allow_mixed_types=False,
log_mode: Optional[Literal['IMMUTABLE', 'MUTABLE', 'INCREMENTAL']] = 'IMMUTABLE'
)
Initializes a Table object.
The rows is available for legacy reasons and should not be used. The Table class uses data to mimic the Pandas API.
Args:
columns: (List[str]) Names of the columns in the table. Defaults to [“Input”, “Output”, “Expected”].data: (List[List[any]]) 2D row-oriented array of values.dataframe: (pandas.DataFrame) DataFrame object used to create the table. When set,dataandcolumnsarguments are ignored.optional: (Union[bool,List[bool]]) Determines ifNonevalues are allowed. Default to True - If a singular bool value, then the optionality is enforced for all columns specified at construction time - If a list of bool values, then the optionality is applied to each column - should be the same length ascolumnsapplies to all columns. A list of bool values applies to each respective column.allow_mixed_types: (bool) Determines if columns are allowed to have mixed types (disables type validation). Defaults to Falselog_mode: Optional[str] Controls how the Table is logged when mutations occur. Options: - “IMMUTABLE” (default): Table can only be logged once; subsequent logging attempts after the table has been mutated will be no-ops. - “MUTABLE”: Table can be re-logged after mutations, creating a new artifact version each time it’s logged. - “INCREMENTAL”: Table data is logged incrementally, with each log creating a new artifact entry containing the new data since the last log.
method Table.add_column
add_column(name, data, optional=False)
Adds a column of data to the table.
Args:
name: (str) - the unique name of the columndata: (list | np.array) - a column of homogeneous dataoptional: (bool) - if null-like values are permitted
method Table.add_computed_columns
add_computed_columns(fn)
Adds one or more computed columns based on existing data.
Args:
fn: A function which accepts one or two parameters, ndx (int) and row (dict), which is expected to return a dict representing new columns for that row, keyed by the new column names.
ndx is an integer representing the index of the row. Only included if include_ndx is set to True.
row is a dictionary keyed by existing columns
method Table.add_data
add_data(*data)
Adds a new row of data to the table.
The maximum amount ofrows in a table is determined by wandb.Table.MAX_ARTIFACT_ROWS.
The length of the data should match the length of the table column.
method Table.add_row
add_row(*row)
Deprecated; use add_data instead.
method Table.cast
cast(col_name, dtype, optional=False)
Casts a column to a specific data type.
This can be one of the normal python classes, an internal W&B type, or an example object, like an instance of wandb.Image or wandb.Classes.
Args:
col_name(str): The name of the column to cast.dtype(class, wandb.wandb_sdk.interface._dtypes.Type, any): The target dtype.optional(bool): If the column should allow Nones.
method Table.get_column
get_column(name, convert_to=None)
Retrieves a column from the table and optionally converts it to a NumPy object.
Args:
name: (str) - the name of the columnconvert_to: (str, optional) - “numpy”: will convert the underlying data to numpy object
method Table.get_dataframe
get_dataframe()
Returns a pandas.DataFrame of the table.
method Table.get_index
get_index()
Returns an array of row indexes for use in other tables to create links.
9 - Video
class Video
A class for logging videos to W&B.
Args:
data_or_path: Video can be initialized with a path to a file or an io object. The format must be “gif”, “mp4”, “webm” or “ogg”. The format must be specified with the format argument. Video can be initialized with a numpy tensor. The numpy tensor must be either 4 dimensional or 5 dimensional. Channels should be (time, channel, height, width) or (batch, time, channel, height width)caption: Caption associated with the video for display.fps: The frame rate to use when encoding raw video frames. Default value is 4. This parameter has no effect when data_or_path is a string, or bytes.format: Format of video, necessary if initializing with path or io object.
Examples: Log a numpy array as a video
import numpy as np
import wandb
run = wandb.init()
# axes are (time, channel, height, width)
frames = np.random.randint(low=0, high=256, size=(10, 3, 100, 100), dtype=np.uint8)
run.log({"video": wandb.Video(frames, fps=4)})
method Video.__init__
__init__(
data_or_path: Union[str, pathlib.Path, ForwardRef('np.ndarray'), ForwardRef('TextIO'), ForwardRef('BytesIO')],
caption: Optional[str] = None,
fps: Optional[int] = None,
format: Optional[Literal['gif', 'mp4', 'webm', 'ogg']] = None
)
Initialize a W&B Video object.
Args: data_or_path: Video can be initialized with a path to a file or an io object. Video can be initialized with a numpy tensor. The numpy tensor must be either 4 dimensional or 5 dimensional. The dimensions should be (number of frames, channel, height, width) or (batch, number of frames, channel, height, width) The format parameter must be specified with the format argument when initializing with a numpy array or io object.
caption: Caption associated with the video for display. fps: The frame rate to use when encoding raw video frames. Default value is 4. This parameter has no effect when data_or_path is a string, or bytes. format: Format of video, necessary if initializing with a numpy array or io object. This parameter will be used to determine the format to use when encoding the video data. Accepted values are “gif”, “mp4”, “webm”, or “ogg”. If no value is provided, the default format will be “gif”.
Examples: Log a numpy array as a video ```python import numpy as np import wandb
with wandb.init() as run: # axes are (number of frames, channel, height, width) frames = np.random.randint( low=0, high=256, size=(10, 3, 100, 100), dtype=np.uint8 ) run.log({“video”: wandb.Video(frames, format=“mp4”, fps=4)})
---