agent(
    sweep_id: str,
    function: Optional[Callable] = None,
    entity: Optional[str] = None,
    project: Optional[str] = None,
    count: Optional[int] = None
) -> None

Artifact(
    name: str,
    type: str,
    description: (str | None) = None,
    metadata: (dict[str, Any] | None) = None,
    incremental: bool = (False),
    use_as: (str | None) = None
) -> None

add(
    obj: WBValue,
    name: StrPath,
    overwrite: bool = (False)
) -> ArtifactManifestEntry

add_dir(
    local_path: str,
    name: (str | None) = None,
    skip_cache: (bool | None) = (False),
    policy: (Literal['mutable', 'immutable'] | None) = "mutable"
) -> None

add_file(
    local_path: str,
    name: (str | None) = None,
    is_tmp: (bool | None) = (False),
    skip_cache: (bool | None) = (False),
    policy: (Literal['mutable', 'immutable'] | None) = "mutable",
    overwrite: bool = (False)
) -> ArtifactManifestEntry

add_reference(
    uri: (ArtifactManifestEntry | str),
    name: (StrPath | None) = None,
    checksum: bool = (True),
    max_objects: (int | None) = None
) -> Sequence[ArtifactManifestEntry]

checkout(
    root: (str | None) = None
) -> str

delete(
    delete_aliases: bool = (False)
) -> None

download(
    root: (StrPath | None) = None,
    allow_missing_references: bool = (False),
    skip_cache: (bool | None) = None,
    path_prefix: (StrPath | None) = None
) -> FilePathStr

file(
    root: (str | None) = None
) -> StrPath

files(
    names: (list[str] | None) = None,
    per_page: int = 50
) -> ArtifactFiles

finalize() -> None

get(
    name: str
) -> (WBValue | None)

get_added_local_path_name(
    local_path: str
) -> (str | None)

get_entry(
    name: StrPath
) -> ArtifactManifestEntry

get_path(
    name: StrPath
) -> ArtifactManifestEntry

is_draft() -> bool

json_encode() -> dict[str, Any]

link(
    target_path: str,
    aliases: (list[str] | None) = None
) -> None

logged_by() -> (Run | None)

new_draft() -> Artifact

@contextlib.contextmanager
new_file(
    name: str,
    mode: str = "x",
    encoding: (str | None) = None
) -> Iterator[IO]

remove(
    item: (StrPath | ArtifactManifestEntry)
) -> None

save(
    project: (str | None) = None,
    settings: (wandb.Settings | None) = None
) -> None

unlink() -> None

used_by() -> list[Run]

verify(
    root: (str | None) = None
) -> None

wait(
    timeout: (int | None) = None
) -> Artifact

__getitem__(
    name: str
) -> (WBValue | None)

__setitem__(
    name: str,
    item: WBValue
) -> ArtifactManifestEntry

controller(
    sweep_id_or_config: Optional[Union[str, Dict]] = None,
    entity: Optional[str] = None,
    project: Optional[str] = None
) -> "_WandbController"

import wandb

tuner = wandb.controller(...)
print(tuner.sweep_config)
print(tuner.sweep_id)
tuner.configure_search(...)
tuner.configure_stopping(...)

Audio(
    data_or_path, sample_rate=None, caption=None
)

@classmethod
durations(
    audio_list
)

resolve_ref()

@classmethod
sample_rates(
    audio_list
)

BoundingBoxes2D(
    val: dict,
    key: str
) -> None

import numpy as np
import wandb

run = wandb.init()
image = np.random.randint(low=0, high=256, size=(200, 300, 3))

class_labels = {0: "person", 1: "car", 2: "road", 3: "building"}

img = wandb.Image(
    image,
    boxes={
        "predictions": {
            "box_data": [
                {
                    # 기본 상대/분수 도메인으로 표현된 상자 하나
                    "position": {
                        "minX": 0.1,
                        "maxX": 0.2,
                        "minY": 0.3,
                        "maxY": 0.4,
                    },
                    "class_id": 1,
                    "box_caption": class_labels[1],
                    "scores": {"acc": 0.2, "loss": 1.2},
                },
                {
                    # 픽셀 도메인으로 표현된 다른 상자
                    "position": {
                        "middle": [150, 20],
                        "width": 68,
                        "height": 112,
                    },
                    "domain": "pixel",
                    "class_id": 3,
                    "box_caption": "a building",
                    "scores": {"acc": 0.5, "loss": 0.7},
                },
                # 필요한 만큼 상자를 로깅합니다.
            ],
            "class_labels": class_labels,
        }
    },
)

run.log({"driving_scene": img})

import numpy as np
import wandb

run = wandb.init()
image = np.random.randint(low=0, high=256, size=(200, 300, 3))

class_labels = {0: "person", 1: "car", 2: "road", 3: "building"}

class_set = wandb.Classes(
    [
        {"name": "person", "id": 0},
        {"name": "car", "id": 1},
        {"name": "road", "id": 2},
        {"name": "building", "id": 3},
    ]
)

img = wandb.Image(
    image,
    boxes={
        "predictions": {
            "box_data": [
                {
                    # 기본 상대/분수 도메인으로 표현된 상자 하나
                    "position": {
                        "minX": 0.1,
                        "maxX": 0.2,
                        "minY": 0.3,
                        "maxY": 0.4,
                    },
                    "class_id": 1,
                    "box_caption": class_labels[1],
                    "scores": {"acc": 0.2, "loss": 1.2},
                },
                {
                    # 픽셀 도메인으로 표현된 다른 상자
                    "position": {
                        "middle": [150, 20],
                        "width": 68,
                        "height": 112,
                    },
                    "domain": "pixel",
                    "class_id": 3,
                    "box_caption": "a building",
                    "scores": {"acc": 0.5, "loss": 0.7},
                },
                # 필요한 만큼 상자를 로깅합니다.
            ],
            "class_labels": class_labels,
        }
    },
    classes=class_set,
)

table = wandb.Table(columns=["image"])
table.add_data(img)
run.log({"driving_scene": table})

@classmethod
type_name() -> str

validate(
    val: dict
) -> bool

Graph(
    format="keras"
)

add_edge(
    from_node, to_node
)

add_node(
    node=None, **node_kwargs
)

@classmethod
from_keras(
    model
)

pprint()

__getitem__(
    nid
)

Histogram(
    sequence: Optional[Sequence] = None,
    np_histogram: Optional['NumpyHistogram'] = None,
    num_bins: int = 64
) -> None

wandb.Histogram([1, 2, 3])

hist = np.histogram(data)
wandb.Histogram(np_histogram=hist)

Html(
    data: Union[str, 'TextIO'],
    inject: bool = (True)
) -> None

inject_head() -> None

Image(
    data_or_path: "ImageDataOrPathType",
    mode: Optional[str] = None,
    caption: Optional[str] = None,
    grouping: Optional[int] = None,
    classes: Optional[Union['Classes', Sequence[dict]]] = None,
    boxes: Optional[Union[Dict[str, 'BoundingBoxes2D'], Dict[str, dict]]] = None,
    masks: Optional[Union[Dict[str, 'ImageMask'], Dict[str, dict]]] = None,
    file_type: Optional[str] = None
) -> None

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})

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})

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})

@classmethod
all_boxes(
    images: Sequence['Image'],
    run: "LocalRun",
    run_key: str,
    step: Union[int, str]
) -> Union[List[Optional[dict]], bool]

@classmethod
all_captions(
    images: Sequence['Media']
) -> Union[bool, Sequence[Optional[str]]]

@classmethod
all_masks(
    images: Sequence['Image'],
    run: "LocalRun",
    run_key: str,
    step: Union[int, str]
) -> Union[List[Optional[dict]], bool]

guess_mode(
    data: "np.ndarray"
) -> str

@classmethod
to_uint8(
    data: "np.ndarray"
) -> "np.ndarray"

ImageMask(
    val: dict,
    key: str
) -> None

import numpy as np
import wandb

run = wandb.init()
image = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)
predicted_mask = np.empty((100, 100), dtype=np.uint8)
ground_truth_mask = np.empty((100, 100), dtype=np.uint8)

predicted_mask[:50, :50] = 0
predicted_mask[50:, :50] = 1
predicted_mask[:50, 50:] = 2
predicted_mask[50:, 50:] = 3

ground_truth_mask[:25, :25] = 0
ground_truth_mask[25:, :25] = 1
ground_truth_mask[:25, 25:] = 2
ground_truth_mask[25:, 25:] = 3

class_labels = {0: "person", 1: "tree", 2: "car", 3: "road"}

masked_image = wandb.Image(
    image,
    masks={
        "predictions": {
            "mask_data": predicted_mask,
            "class_labels": class_labels,
        },
        "ground_truth": {
            "mask_data": ground_truth_mask,
            "class_labels": class_labels,
        },
    },
)
run.log({"img_with_masks": masked_image})

import numpy as np
import wandb

run = wandb.init()
image = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)
predicted_mask = np.empty((100, 100), dtype=np.uint8)
ground_truth_mask = np.empty((100, 100), dtype=np.uint8)

predicted_mask[:50, :50] = 0
predicted_mask[50:, :50] = 1
predicted_mask[:50, 50:] = 2
predicted_mask[50:, 50:] = 3

ground_truth_mask[:25, :25] = 0
ground_truth_mask[25:, :25] = 1
ground_truth_mask[:25, 25:] = 2
ground_truth_mask[25:, 25:] = 3

class_labels = {0: "person", 1: "tree", 2: "car", 3: "road"}

class_set = wandb.Classes(
    [
        {"name": "person", "id": 0},
        {"name": "tree", "id": 1},
        {"name": "car", "id": 2},
        {"name": "road", "id": 3},
    ]
)

masked_image = wandb.Image(
    image,
    masks={
        "predictions": {
            "mask_data": predicted_mask,
            "class_labels": class_labels,
        },
        "ground_truth": {
            "mask_data": ground_truth_mask,
            "class_labels": class_labels,
        },
    },
    classes=class_set,
)

table = wandb.Table(columns=["image"])
table.add_data(masked_image)
run.log({"random_field": table})

@classmethod
type_name() -> str

validate(
    val: dict
) -> bool

Molecule(
    data_or_path: Union[str, 'TextIO'],
    caption: Optional[str] = None,
    **kwargs
) -> None

@classmethod
from_rdkit(
    data_or_path: "RDKitDataType",
    caption: Optional[str] = None,
    convert_to_3d_and_optimize: bool = (True),
    mmff_optimize_molecule_max_iterations: int = 200
) -> "Molecule"

@classmethod
from_smiles(
    data: str,
    caption: Optional[str] = None,
    sanitize: bool = (True),
    convert_to_3d_and_optimize: bool = (True),
    mmff_optimize_molecule_max_iterations: int = 200
) -> "Molecule"

Object3D(
    data_or_path: Union['np.ndarray', str, 'TextIO', dict],
    **kwargs
) -> None

@classmethod
from_file(
    data_or_path: Union['TextIO', str],
    file_type: Optional['FileFormat3D'] = None
) -> "Object3D"

@classmethod
from_numpy(
    data: "np.ndarray"
) -> "Object3D"

@classmethod
from_point_cloud(
    points: Sequence['Point'],
    boxes: Sequence['Box3D'],
    vectors: Optional[Sequence['Vector3D']] = None,
    point_cloud_type: "PointCloudType" = "lidar/beta"
) -> "Object3D"

Plotly(
    val: Union['plotly.Figure', 'matplotlib.artist.Artist']
)

@classmethod
make_plot_media(
    val: Union['plotly.Figure', 'matplotlib.artist.Artist']
) -> Union[Image, 'Plotly']

Table(
    columns=None, data=None, rows=None, dataframe=None, dtype=None, optional=(True),
    allow_mixed_types=(False)
)

add_column(
    name, data, optional=(False)
)

add_computed_columns(
    fn
)

add_data(
    *data
)

add_row(
    *row
)

cast(
    col_name, dtype, optional=(False)
)

get_column(
    name, convert_to=None
)

get_dataframe()

get_index()

index_ref(
    index
)

iterrows()

set_fk(
    col_name, table, table_col
)

set_pk(
    col_name
)

Video(
    data_or_path: Union['np.ndarray', str, 'TextIO', 'BytesIO'],
    caption: Optional[str] = None,
    fps: Optional[int] = None,
    format: Optional[str] = None
)

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)})

encode(
    fps: int = 4
) -> None

WBTraceTree(
    root_span: Span,
    model_dict: typing.Optional[dict] = None
)

finish(
    exit_code: (int | None) = None,
    quiet: (bool | None) = None
) -> None

Api(
    overrides: Optional[Dict[str, Any]] = None,
    timeout: Optional[int] = None,
    api_key: Optional[str] = None
) -> None

artifact(
    name: str,
    type: Optional[str] = None
)

artifact_collection(
    type_name: str,
    name: str
) -> "public.ArtifactCollection"

artifact_collection_exists(
    name: str,
    type: str
) -> bool

artifact_collections(
    project_name: str,
    type_name: str,
    per_page: Optional[int] = 50
) -> "public.ArtifactCollections"

artifact_exists(
    name: str,
    type: Optional[str] = None
) -> bool

artifact_type(
    type_name: str,
    project: Optional[str] = None
) -> "public.ArtifactType"

artifact_types(
    project: Optional[str] = None
) -> "public.ArtifactTypes"

artifact_versions(
    type_name, name, per_page=50
)

artifacts(
    type_name: str,
    name: str,
    per_page: Optional[int] = 50,
    tags: Optional[List[str]] = None
) -> "public.Artifacts"

create_project(
    name: str,
    entity: str
) -> None

create_run(
    *,
    run_id: Optional[str] = None,
    project: Optional[str] = None,
    entity: Optional[str] = None
) -> "public.Run"

create_run_queue(
    name: str,
    type: "public.RunQueueResourceType",
    entity: Optional[str] = None,
    prioritization_mode: Optional['public.RunQueuePrioritizationMode'] = None,
    config: Optional[dict] = None,
    template_variables: Optional[dict] = None
) -> "public.RunQueue"

create_team(
    team, admin_username=None
)

create_user(
    email, admin=(False)
)

flush()

from_path(
    path
)

job(
    name: Optional[str],
    path: Optional[str] = None
) -> "public.Job"

list_jobs(
    entity: str,
    project: str
) -> List[Dict[str, Any]]

project(
    name: str,
    entity: Optional[str] = None
) -> "public.Project"

projects(
    entity: Optional[str] = None,
    per_page: Optional[int] = 200
) -> "public.Projects"

queued_run(
    entity, project, queue_name, run_queue_item_id, project_queue=None,
    priority=None
)

registries(
    organization: Optional[str] = None,
    filter: Optional[Dict[str, Any]] = None
) -> Registries

import wandb

api = wandb.Api()  # entity가 여러 조직에 속한 경우 조직을 지정합니다.
api.registries(filter={"name": {"$regex": "model"}})

api.registries().collections(filter={"name": "my_collection", "tag": "my_tag"})

api.registries().collections(
    filter={"name": {"$regex": "my_collection"}}
).versions(filter={"alias": "best"})

api.registries(filter={"name": {"$regex": "model"}}).versions(
    filter={"$or": [{"tag": "prod"}, {"alias": "best"}]}
)

reports(
    path: str = "",
    name: Optional[str] = None,
    per_page: Optional[int] = 50
) -> "public.Reports"

run(
    path=""
)

run_queue(
    entity, name
)

runs(
    path: Optional[str] = None,
    filters: Optional[Dict[str, Any]] = None,
    order: str = "+created_at",
    per_page: int = 50,
    include_sweeps: bool = (True)
)

sweep(
    path=""
)

sync_tensorboard(
    root_dir, run_id=None, project=None, entity=None
)

team(
    team: str
) -> "public.Team"

upsert_run_queue(
    name: str,
    resource_config: dict,
    resource_type: "public.RunQueueResourceType",
    entity: Optional[str] = None,
    template_variables: Optional[dict] = None,
    external_links: Optional[dict] = None,
    prioritization_mode: Optional['public.RunQueuePrioritizationMode'] = None
)

user(
    username_or_email: str
) -> Optional['public.User']

users(
    username_or_email: str
) -> List['public.User']

File(
    client, attrs, run=None
)

delete()

display(
    height=420, hidden=(False)
) -> bool

download(
    root: str = ".",
    replace: bool = (False),
    exist_ok: bool = (False),
    api: Optional[Api] = None
) -> io.TextIOWrapper

snake_to_camel(
    string
)

to_html(
    *args, **kwargs
)

Files(
    client, run, names=None, per_page=50, upload=(False)
)

convert_objects()

next()

update_variables()

__getitem__(
    index
)

__iter__()

__len__()

Job(
    api: "Api",
    name,
    path: Optional[str] = None
) -> None

call(
    config, project=None, entity=None, queue=None, resource="local-container",
    resource_args=None, template_variables=None, project_queue=None, priority=None
)

set_entrypoint(
    entrypoint: List[str]
)

Project(
    client, entity, project, attrs
)

artifacts_types(
    per_page=50
)

display(
    height=420, hidden=(False)
) -> bool

snake_to_camel(
    string
)

sweeps()

to_html(
    height=420, hidden=(False)
)

Projects(
    client, entity, per_page=50
)

convert_objects()

next()

update_variables()

__getitem__(
    index
)

__iter__()

__len__()

QueuedRun(
    client, entity, project, queue_name, run_queue_item_id,
    project_queue=LAUNCH_DEFAULT_PROJECT, priority=None
)

delete(
    delete_artifacts=(False)
)

wait_until_finished()

wait_until_running()

Run(
    client: "RetryingClient",
    entity: str,
    project: str,
    run_id: str,
    attrs: Optional[Mapping] = None,
    include_sweeps: bool = (True)
)

@classmethod
create(
    api, run_id=None, project=None, entity=None
)

delete(
    delete_artifacts=(False)
)

display(
    height=420, hidden=(False)
) -> bool

file(
    name
)

files(
    names=None, per_page=50
)

history(
    samples=500, keys=None, x_axis="_step", pandas=(True), stream="default"
)

load(
    force=(False)
)

log_artifact(
    artifact: "wandb.Artifact",
    aliases: Optional[Collection[str]] = None,
    tags: Optional[Collection[str]] = None
)

logged_artifacts(
    per_page: int = 100
) -> public.RunArtifacts

save()

scan_history(
    keys=None, page_size=1000, min_step=None, max_step=None
)

run = api.run("l2k2/examples-numpy-boston/i0wt6xua")
history = run.scan_history(keys=["Loss"])
losses = [row["Loss"] for row in history]

snake_to_camel(
    string
)

to_html(
    height=420, hidden=(False)
)

update()

upload_file(
    path, root="."
)

use_artifact(
    artifact, use_as=None
)

used_artifacts(
    per_page: int = 100
) -> public.RunArtifacts

wait_until_finished()

RunQueue(
    client: "RetryingClient",
    name: str,
    entity: str,
    prioritization_mode: Optional[RunQueuePrioritizationMode] = None,
    _access: Optional[RunQueueAccessType] = None,
    _default_resource_config_id: Optional[int] = None,
    _default_resource_config: Optional[dict] = None
) -> None

@classmethod
create(
    name: str,
    resource: "RunQueueResourceType",
    entity: Optional[str] = None,
    prioritization_mode: Optional['RunQueuePrioritizationMode'] = None,
    config: Optional[dict] = None,
    template_variables: Optional[dict] = None
) -> "RunQueue"

delete()

Runs(
    client: "RetryingClient",
    entity: str,
    project: str,
    filters: Optional[Dict[str, Any]] = None,
    order: Optional[str] = None,
    per_page: int = 50,
    include_sweeps: bool = (True)
)

convert_objects()

histories(
    samples: int = 500,
    keys: Optional[List[str]] = None,
    x_axis: str = "_step",
    format: Literal['default', 'pandas', 'polars'] = "default",
    stream: Literal['default', 'system'] = "default"
)

next()

update_variables()

__getitem__(
    index
)

__iter__()

__len__()

Sweep(
    client, entity, project, sweep_id, attrs=None
)

best_run(
    order=None
)

display(
    height=420, hidden=(False)
) -> bool

@classmethod
get(
    client, entity=None, project=None, sid=None, order=None, query=None, **kwargs
)

load(
    force: bool = (False)
)

snake_to_camel(
    string
)

to_html(
    height=420, hidden=(False)
)

init(
    entity: (str | None) = None,
    project: (str | None) = None,
    dir: (StrPath | None) = None,
    id: (str | None) = None,
    name: (str | None) = None,
    notes: (str | None) = None,
    tags: (Sequence[str] | None) = None,
    config: (dict[str, Any] | str | None) = None,
    config_exclude_keys: (list[str] | None) = None,
    config_include_keys: (list[str] | None) = None,
    allow_val_change: (bool | None) = None,
    group: (str | None) = None,
    job_type: (str | None) = None,
    mode: (Literal['online', 'offline', 'disabled'] | None) = None,
    force: (bool | None) = None,
    anonymous: (Literal['never', 'allow', 'must'] | None) = None,
    reinit: (bool | None) = None,
    resume: (bool | Literal['allow', 'never', 'must', 'auto'] | None) = None,
    resume_from: (str | None) = None,
    fork_from: (str | None) = None,
    save_code: (bool | None) = None,
    tensorboard: (bool | None) = None,
    sync_tensorboard: (bool | None) = None,
    monitor_gym: (bool | None) = None,
    settings: (Settings | dict[str, Any] | None) = None
) -> Run