Run

import wandb

# 새 run을 시작하고 데이터를 로깅하세요
# 컨텍스트 관리자(`with` 문)를 사용하여 run을 자동으로 종료하세요
with wandb.init(entity="entity", project="project") as run:
    run.log({"accuracy": acc, "loss": loss})

self,
title: 'str',
text: 'str',
level: 'str | AlertLevel | None' = None,
wait_duration: 'int | float | timedelta | None' = None

self,
name: 'str',
step_metric: 'str | wandb_metric.Metric | None' = None,
step_sync: 'bool | None' = None,
hidden: 'bool | None' = None,
summary: 'str | None' = None,
overwrite: 'bool | None' = None

self,
height: 'int' = 420,
hidden: 'bool' = False

self,
exit_code: 'int | None' = None

self,
artifact_or_path: 'Artifact | str',
name: 'str | None' = None,
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
distributed_id: 'str | None' = None

self,
artifact: 'Artifact',
target_path: 'str',
aliases: 'list[str] | None' = None

import wandb

entity = "team_entity"
project = "project_name"

artifact_name = "artifact_name"
artifact_type = "artifact_type"
local_path = "path/to/local/file"

registry_name = "registry_name"
collection_name = "collection_name"
target_path = f"wandb-registry-{registry_name}/{collection_name}"

with wandb.init(entity=entity, project=project) as run:
    # 아티팩트 객체를 생성하세요
    artifact = wandb.Artifact(name=artifact_name, type=artifact_type)

    # 아티팩트 객체에 파일을 추가하세요.
    artifact.add_file(local_path=local_path)

    # 아티팩트를 컬렉션에 연결하세요
    run.link_artifact(artifact=artifact, target_path=target_path)

self,
path: 'StrPath',
registered_model_name: 'str',
name: 'str | None' = None,
aliases: 'list[str] | None' = None

self,
data: 'dict[str, Any]',
step: 'int | None' = None,
commit: 'bool | None' = None

import wandb

with wandb.init() as run:
    run.log({"train-loss": 0.5, "accuracy": 0.9})

with wandb.init() as run:
    # "train" 섹션에 메트릭을 로깅합니다.
    run.log(
        {
            "train/accuracy": 0.9,
            "train/loss": 30,
            "validate/accuracy": 0.8,
            "validate/loss": 20,
        }
    )

with wandb.init() as run:
    # 예시: X축으로 사용할 "epoch" 메트릭을 로깅합니다.
    run.log({"epoch": 40, "train-loss": 0.5})

with wandb.init() as run:
    # 일반적인 사용:
    run.log({"train-loss": 0.5, "accuracy": 0.8})
    run.log({"train-loss": 0.4, "accuracy": 0.9})

    # 자동 증가 없는 암시적 step:
    run.log({"train-loss": 0.5}, commit=False)
    run.log({"accuracy": 0.8})
    run.log({"train-loss": 0.4}, commit=False)
    run.log({"accuracy": 0.9})

    # 명시적 step:
    run.log({"train-loss": 0.5}, step=current_step)
    run.log({"accuracy": 0.8}, step=current_step)
    current_step += 1
    run.log({"train-loss": 0.4}, step=current_step)
    run.log({"accuracy": 0.9}, step=current_step, commit=True)

import wandb

with wandb.init() as run:
    run.log({"train-loss": 0.5, "accuracy": 0.9

import wandb

with wandb.init() as run:
    run.log({"loss": 0.2}, commit=False)
    # 다른 위치에서 이 step을 로깅할 준비가 되었을 때:
    run.log({"accuracy": 0.8})

import numpy as np
import wandb

# 정규 분포에서 그라디언트를 무작위로 샘플링합니다
gradients = np.random.randn(100, 100)
with wandb.init() as run:
    run.log({"gradients": wandb.Histogram(gradients)})

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:
    # 축은 (시간, 채널, 높이, 너비)입니다
    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)})

from matplotlib import pyplot as plt
import numpy as np
import wandb

with wandb.init() as run:
    fig, ax = plt.subplots()
    x = np.linspace(0, 10)
    y = x * x
    ax.plot(x, y)  # y = x^2 그래프 그리기
    run.log({"chart": fig})

import wandb

with wandb.init() as run:
    run.log({"pr": wandb.plot.pr_curve(y_test, y_probas, labels)})

import wandb

with wandb.init() as run:
    run.log(
        {
            "generated_samples": [
                wandb.Object3D(open("sample.obj")),
                wandb.Object3D(open("sample.gltf")),
                wandb.Object3D(open("sample.glb")),
            ]
        }
    )

self,
artifact_or_path: 'Artifact | StrPath',
name: 'str | None' = None,
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
tags: 'list[str] | None' = None

self,
root: 'str | None' = '.',
name: 'str | None' = None,
include_fn: 'Callable[[str, str], bool] | Callable[[str], bool]' = _is_py_requirements_or_dockerfile,
exclude_fn: 'Callable[[str, str], bool] | Callable[[str], bool]' = exclude_wandb_fn

import wandb

with wandb.init() as run:
    run.log_code()

import wandb

with wandb.init() as run:
    run.log_code(
        root="../",
        include_fn=lambda path: path.endswith(".py") or path.endswith(".ipynb"),
        exclude_fn=lambda path, root: os.path.relpath(path, root).startswith(
            "cache/"
        ),
    )

self,
path: 'StrPath',
name: 'str | None' = None,
aliases: 'list[str] | None' = None

self

self,
keys: 'Sequence[str]' = ()

self,
name: 'str',
run_path: 'str | None' = None,
replace: 'bool' = False,
root: 'str | None' = None

self,
glob_str: 'str | os.PathLike',
base_path: 'str | os.PathLike | None' = None,
policy: 'PolicyName' = 'live',
glob: 'bool' = True

self

self,
models: 'torch.nn.Module | Sequence[torch.nn.Module] | None' = None

self,
artifact_or_path: 'Artifact | str',
name: 'str | None' = None,
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
distributed_id: 'str | None' = None

self,
artifact_or_name: 'str | Artifact',
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
use_as: 'str | None' = None

import wandb

run = wandb.init(project="<example>")

# 이름과 별칭으로 아티팩트를 사용하세요
artifact_a = run.use_artifact(artifact_or_name="<name>:<alias>")

# 이름과 버전으로 아티팩트를 사용하세요
artifact_b = run.use_artifact(artifact_or_name="<name>:v<version>")

# entity/project/name:alias 형식으로 아티팩트를 사용하세요
artifact_c = run.use_artifact(
    artifact_or_name="<entity>/<project>/<name>:<alias>"
)

# entity/project/name:version 형식으로 아티팩트를 사용하세요
artifact_d = run.use_artifact(
    artifact_or_name="<entity>/<project>/<name>:v<version>"
)

# 컨텍스트 관리자를 사용하지 않으므로 run을 명시적으로 종료하세요.
run.finish()

self,
name: 'str'

self,
models: 'torch.nn.Module | Sequence[torch.nn.Module]',
criterion: 'torch.F | None' = None,
log: "Literal['gradients', 'parameters', 'all'] | None" = 'gradients',
log_freq: 'int' = 1000,
idx: 'int | None' = None,
log_graph: 'bool' = False

self,
text: 'str'