Experiments

• 1: Create an experiment
• 2: Configure experiments
• 3: Projects
• 4: View experiments results
• 5: What are runs?
• 5.1: Add labels to runs with tags
• 5.2: Filter and search runs
• 5.3: Fork a run
• 5.4: Group runs into experiments
• 5.5: Move runs
• 5.6: Resume a run
• 5.7: Rewind a run
• 5.8: Send an alert
• 6: Log objects and media
• 6.1: Create and track plots from experiments
• 6.2: Customize log axes
• 6.3: Log distributed training experiments
• 6.4: Log media and objects
• 6.5: Log models
• 6.6: Log summary metrics
• 6.7: Log tables
• 6.8: Track CSV files with experiments
• 7: Track Jupyter notebooks
• 8: Experiments limits and performance
• 9: Reproduce experiments
• 10: Import and export data
• 11: Environment variables

Try in Colab Try in W&B

몇 줄의 코드로 기계 학습 Experiments 를 추적하세요. 그런 다음 대화형 대시보드에서 결과를 검토하거나, Public API를 사용하여 프로그래밍 방식으로 엑세스할 수 있도록 데이터를 Python으로 내보낼 수 있습니다.

PyTorch, Keras, 또는 Scikit과 같은 널리 사용되는 프레임워크를 사용하는 경우 W&B Integrations 를 활용하세요. W&B 를 코드에 추가하는 방법에 대한 정보 및 전체 인테그레이션 목록은 Integration 가이드를 참조하세요.

위의 이미지는 여러 runs에서 메트릭을 보고 비교할 수 있는 대시보드 의 예시를 보여줍니다.

작동 방식

몇 줄의 코드로 기계 학습 experiment 를 추적합니다.

1. W&B run을 만듭니다.
2. 학습률 또는 모델 유형과 같은 하이퍼파라미터 사전을 구성 (run.config)에 저장합니다.
3. 정확도 및 손실과 같은 트레이닝 루프에서 시간 경과에 따른 메트릭 (run.log())을 기록합니다.
4. 모델 weights 또는 예측 테이블과 같은 run 의 출력을 저장합니다.

다음 코드는 일반적인 W&B experiment 추적 워크플로우를 보여줍니다.

# Start a run.
#
# When this block exits, it waits for logged data to finish uploading.
# If an exception is raised, the run is marked failed.
with wandb.init(entity="", project="my-project-name") as run:
  # Save mode inputs and hyperparameters.
  run.config.learning_rate = 0.01

  # Run your experiment code.
  for epoch in range(num_epochs):
    # Do some training...

    # Log metrics over time to visualize model performance.
    run.log({"loss": loss})

  # Upload model outputs as artifacts.
  run.log_artifact(model)

시작하기

유스 케이스에 따라 다음 리소스를 탐색하여 W&B Experiments 를 시작하세요.

• 데이터셋 artifact 를 생성, 추적 및 사용하는 데 사용할 수 있는 W&B Python SDK 코맨드에 대한 단계별 개요는 W&B 퀵스타트를 참조하세요.
• 다음 방법을 배우려면 이 챕터를 살펴보세요.
  • experiment 생성
  • Experiments 구성
  • Experiments 에서 데이터 기록
  • Experiments 결과 보기
• W&B API Reference Guide 내에서 W&B Python Library를 탐색합니다.

모범 사례 및 팁

Experiments 및 로깅에 대한 모범 사례 및 팁은 Best Practices: Experiments and Logging 를 참조하세요.

1 - Create an experiment

W&B Python SDK를 사용하여 기계 학습 Experiments를 추적합니다. 그런 다음 인터랙티브 대시보드에서 결과를 검토하거나 W&B Public API를 사용하여 프로그래밍 방식으로 Python으로 데이터를 내보낼 수 있습니다.

이 가이드에서는 W&B 빌딩 블록을 사용하여 W&B Experiment를 만드는 방법을 설명합니다.

W&B Experiment를 만드는 방법

W&B Experiment를 만드는 4단계:

1. W&B Run 초기화
2. 하이퍼파라미터 dictionary 캡처
3. 트레이닝 루프 내에서 메트릭 기록
4. W&B에 아티팩트 기록

W&B run 초기화

wandb.init()를 사용하여 W&B Run을 만듭니다.

다음 코드 조각은 이 run을 식별하는 데 도움이 되도록 설명이 “My first experiment” 인 “cat-classification”이라는 W&B project에서 run을 만듭니다. 태그 “baseline” 및 “paper1”은 이 run이 향후 논문 출판을 위한 베이스라인 experiment임을 알려줍니다.

import wandb

with wandb.init(
    project="cat-classification",
    notes="My first experiment",
    tags=["baseline", "paper1"],
) as run:
    ...

wandb.init()는 Run 오브젝트를 반환합니다.

하이퍼파라미터 dictionary 캡처

학습률 또는 모델 유형과 같은 하이퍼파라미터 dictionary를 저장합니다. config에서 캡처하는 모델 설정은 나중에 결과를 구성하고 쿼리하는 데 유용합니다.

with wandb.init(
    ...,
    config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
    ...

experiment를 구성하는 방법에 대한 자세한 내용은 Experiments 구성을 참조하십시오.

트레이닝 루프 내에서 메트릭 기록

run.log()를 호출하여 정확도 및 손실과 같은 각 트레이닝 단계에 대한 메트릭을 기록합니다.

model, dataloader = get_model(), get_data()

for epoch in range(run.config.epochs):
    for batch in dataloader:
        loss, accuracy = model.training_step()
        run.log({"accuracy": accuracy, "loss": loss})

W&B로 기록할 수 있는 다양한 데이터 유형에 대한 자세한 내용은 Experiments 중 데이터 기록을 참조하십시오.

W&B에 아티팩트 기록

선택적으로 W&B Artifact를 기록합니다. Artifact를 사용하면 데이터셋과 Models를 쉽게 버전 관리할 수 있습니다.

# 모든 파일 또는 디렉토리를 저장할 수 있습니다. 이 예에서는 모델에 ONNX 파일을 출력하는
# save() 메소드가 있다고 가정합니다.
model.save("path_to_model.onnx")
run.log_artifact("path_to_model.onnx", name="trained-model", type="model")

Artifacts 또는 Registry에서 Models 버전 관리에 대해 자세히 알아보십시오.

모두 함께 놓기

이전 코드 조각이 포함된 전체 스크립트는 아래에서 찾을 수 있습니다.

import wandb

with wandb.init(
    project="cat-classification",
    notes="",
    tags=["baseline", "paper1"],
    # run의 하이퍼파라미터를 기록합니다.
    config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
    # 모델 및 데이터를 설정합니다.
    model, dataloader = get_model(), get_data()

    # 모델 성능을 시각화하기 위해 메트릭을 기록하면서 트레이닝을 실행합니다.
    for epoch in range(run.config["epochs"]):
        for batch in dataloader:
            loss, accuracy = model.training_step()
            run.log({"accuracy": accuracy, "loss": loss})

    # 트레이닝된 모델을 아티팩트로 업로드합니다.
    model.save("path_to_model.onnx")
    run.log_artifact("path_to_model.onnx", name="trained-model", type="model")

다음 단계: experiment 시각화

W&B Dashboard를 기계 학습 모델의 결과를 구성하고 시각화하는 중앙 장소로 사용하십시오. 몇 번의 클릭만으로 평행 좌표 플롯, 파라미터 중요도 분석 및 기타와 같은 풍부한 인터랙티브 차트를 구성합니다.

Experiments 및 특정 runs를 보는 방법에 대한 자세한 내용은 Experiments 결과 시각화를 참조하십시오.

모범 사례

다음은 Experiments를 만들 때 고려해야 할 몇 가지 제안된 지침입니다.

1. Runs 완료: 코드가 완료되거나 예외가 발생하면 자동으로 run을 완료된 것으로 표시하려면 with 문에서 wandb.init()를 사용합니다.

   • Jupyter 노트북에서는 Run 오브젝트를 직접 관리하는 것이 더 편리할 수 있습니다. 이 경우 Run 오브젝트에서 finish()를 명시적으로 호출하여 완료된 것으로 표시할 수 있습니다.

     # 노트북 셀에서:
     run = wandb.init()
     
     # 다른 셀에서:
     run.finish()
     

2. Config: 하이퍼파라미터, 아키텍처, 데이터셋 및 모델을 재현하는 데 사용하려는 모든 항목을 추적합니다. 이러한 항목은 열에 표시됩니다. config 열을 사용하여 앱에서 runs를 동적으로 그룹화, 정렬 및 필터링합니다.
3. Project: project는 함께 비교할 수 있는 experiment 집합입니다. 각 project에는 전용 대시보드 페이지가 제공되며, 다양한 모델 버전을 비교하기 위해 다양한 run 그룹을 쉽게 켜거나 끌 수 있습니다.
4. Notes: 스크립트에서 직접 빠른 커밋 메시지를 설정합니다. W&B App에서 run의 개요 섹션에서 노트를 편집하고 엑세스합니다.
5. Tags: 베이스라인 runs 및 즐겨찾는 runs를 식별합니다. 태그를 사용하여 runs를 필터링할 수 있습니다. W&B App의 project 대시보드의 개요 섹션에서 나중에 태그를 편집할 수 있습니다.
6. Experiments를 비교하기 위해 여러 run 집합 만들기: Experiments를 비교할 때 메트릭을 쉽게 비교할 수 있도록 여러 run 집합을 만듭니다. 동일한 차트 또는 차트 그룹에서 run 집합을 켜거나 끌 수 있습니다.

다음 코드 조각은 위에 나열된 모범 사례를 사용하여 W&B Experiment를 정의하는 방법을 보여줍니다.

import wandb

config = {
    "learning_rate": 0.01,
    "momentum": 0.2,
    "architecture": "CNN",
    "dataset_id": "cats-0192",
}

with wandb.init(
    project="detect-cats",
    notes="tweak baseline",
    tags=["baseline", "paper1"],
    config=config,
) as run:
    ...

W&B Experiment를 정의할 때 사용할 수 있는 파라미터에 대한 자세한 내용은 API Reference Guide의 wandb.init API 문서를 참조하십시오.

2 - Configure experiments

트레이닝 설정을 저장하려면 run의 config 속성을 사용하세요.

• 하이퍼파라미터
• 데이터셋 이름 또는 모델 유형과 같은 입력 설정
• 모든 다른 독립 변수들

run.config 속성을 사용하면 실험을 쉽게 분석하고 향후 작업을 재현할 수 있습니다. W&B 앱에서 설정 값으로 그룹화하고, 서로 다른 W&B run의 설정을 비교하고, 각 트레이닝 설정이 결과에 미치는 영향을 평가할 수 있습니다. config 속성은 여러 사전과 유사한 오브젝트로 구성될 수 있는 사전과 유사한 오브젝트입니다.

실험 설정 구성하기

일반적으로 설정은 트레이닝 스크립트의 시작 부분에 정의됩니다. 그러나 기계 학습 워크플로우는 다를 수 있으므로 트레이닝 스크립트의 시작 부분에 설정을 정의할 필요는 없습니다.

config 변수 이름에는 마침표 (.) 대신 대시 (-) 또는 밑줄 (_)을 사용하세요.

스크립트가 루트 아래의 run.config 키에 엑세스하는 경우 속성 엑세스 구문 config.key.value 대신 사전 엑세스 구문 ["key"]["value"]를 사용하세요.

다음 섹션에서는 실험 설정을 정의하는 다양한 일반적인 시나리오에 대해 설명합니다.

초기화 시 설정 구성하기

W&B Run으로 데이터를 동기화하고 기록하는 백그라운드 프로세스를 생성하기 위해 wandb.init() API를 호출할 때 스크립트 시작 부분에 사전을 전달합니다.

다음 코드 조각은 설정 값으로 Python 사전을 정의하는 방법과 W&B Run을 초기화할 때 해당 사전을 인수로 전달하는 방법을 보여줍니다.

import wandb

# config 사전 오브젝트 정의
config = {
    "hidden_layer_sizes": [32, 64],
    "kernel_sizes": [3],
    "activation": "ReLU",
    "pool_sizes": [2],
    "dropout": 0.5,
    "num_classes": 10,
}

# W&B를 초기화할 때 config 사전 전달
with wandb.init(project="config_example", config=config) as run:
    ...

중첩된 사전을 config로 전달하면 W&B는 점을 사용하여 이름을 평면화합니다.

Python에서 다른 사전에 엑세스하는 방법과 유사하게 사전에서 값에 엑세스합니다.

# 키를 인덱스 값으로 사용하여 값에 엑세스
hidden_layer_sizes = run.config["hidden_layer_sizes"]
kernel_sizes = run.config["kernel_sizes"]
activation = run.config["activation"]

# Python 사전 get() 메소드
hidden_layer_sizes = run.config.get("hidden_layer_sizes")
kernel_sizes = run.config.get("kernel_sizes")
activation = run.config.get("activation")

argparse로 설정 구성하기

argparse 오브젝트로 설정을 구성할 수 있습니다. argument parser의 약자인 argparse는 커맨드라인 인수의 모든 유연성과 성능을 활용하는 스크립트를 쉽게 작성할 수 있도록 하는 Python 3.2 이상의 표준 라이브러리 모듈입니다.

이는 커맨드라인에서 실행되는 스크립트의 결과를 추적하는 데 유용합니다.

다음 Python 스크립트는 파서 오브젝트를 정의하여 실험 설정을 정의하고 구성하는 방법을 보여줍니다. 함수 train_one_epoch 및 evaluate_one_epoch는 이 데모의 목적으로 트레이닝 루프를 시뮬레이션하기 위해 제공됩니다.

# config_experiment.py
import argparse
import random

import numpy as np
import wandb


# 트레이닝 및 평가 데모 코드
def train_one_epoch(epoch, lr, bs):
    acc = 0.25 + ((epoch / 30) + (random.random() / 10))
    loss = 0.2 + (1 - ((epoch - 1) / 10 + random.random() / 5))
    return acc, loss


def evaluate_one_epoch(epoch):
    acc = 0.1 + ((epoch / 20) + (random.random() / 10))
    loss = 0.25 + (1 - ((epoch - 1) / 10 + random.random() / 6))
    return acc, loss


def main(args):
    # W&B Run 시작
    with wandb.init(project="config_example", config=args) as run:
        # config 사전에서 값에 엑세스하고 가독성을 위해 변수에 저장합니다.
        lr = run.config["learning_rate"]
        bs = run.config["batch_size"]
        epochs = run.config["epochs"]

        # W&B에 값을 시뮬레이션하여 트레이닝하고 기록합니다.
        for epoch in np.arange(1, epochs):
            train_acc, train_loss = train_one_epoch(epoch, lr, bs)
            val_acc, val_loss = evaluate_one_epoch(epoch)

            run.log(
                {
                    "epoch": epoch,
                    "train_acc": train_acc,
                    "train_loss": train_loss,
                    "val_acc": val_acc,
                    "val_loss": val_loss,
                }
            )


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )

    parser.add_argument("-b", "--batch_size", type=int, default=32, help="배치 크기")
    parser.add_argument(
        "-e", "--epochs", type=int, default=50, help="트레이닝 에포크 수"
    )
    parser.add_argument(
        "-lr", "--learning_rate", type=int, default=0.001, help="학습률"
    )

    args = parser.parse_args()
    main(args)

스크립트 전체에서 설정 구성하기

스크립트 전체에서 config 오브젝트에 더 많은 파라미터를 추가할 수 있습니다. 다음 코드 조각은 config 오브젝트에 새 키-값 쌍을 추가하는 방법을 보여줍니다.

import wandb

# config 사전 오브젝트 정의
config = {
    "hidden_layer_sizes": [32, 64],
    "kernel_sizes": [3],
    "activation": "ReLU",
    "pool_sizes": [2],
    "dropout": 0.5,
    "num_classes": 10,
}

# W&B를 초기화할 때 config 사전 전달
with wandb.init(project="config_example", config=config) as run:
    # W&B를 초기화한 후 config 업데이트
    run.config["dropout"] = 0.2
    run.config.epochs = 4
    run.config["batch_size"] = 32

여러 값을 한 번에 업데이트할 수 있습니다.

run.config.update({"lr": 0.1, "channels": 16})

Run이 완료된 후 설정 구성하기

W&B Public API를 사용하여 완료된 run의 구성을 업데이트합니다.

API에 엔티티, 프로젝트 이름 및 run의 ID를 제공해야 합니다. Run 오브젝트 또는 W&B 앱 UI에서 이러한 세부 정보를 찾을 수 있습니다.

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

# 현재 스크립트 또는 노트북에서 시작된 경우 Run 오브젝트에서 다음 값을 찾거나 W&B 앱 UI에서 복사할 수 있습니다.
username = run.entity
project = run.project
run_id = run.id

# api.run()은 wandb.init()과 다른 유형의 오브젝트를 반환합니다.
api = wandb.Api()
api_run = api.run(f"{username}/{project}/{run_id}")
api_run.config["bar"] = 32
api_run.update()

absl.FLAGS

absl flags를 전달할 수도 있습니다.

flags.DEFINE_string("model", None, "실행할 모델")  # name, default, help

run.config.update(flags.FLAGS)  # absl flags를 config에 추가

파일 기반 Configs

config-defaults.yaml이라는 파일을 run 스크립트와 동일한 디렉토리에 배치하면 run이 파일에 정의된 키-값 쌍을 자동으로 선택하여 run.config에 전달합니다.

다음 코드 조각은 샘플 config-defaults.yaml YAML 파일을 보여줍니다.

batch_size:
  desc: 각 미니배치의 크기
  value: 32

wandb.init의 config 인수에 업데이트된 값을 설정하여 config-defaults.yaml에서 자동으로 로드된 기본값을 재정의할 수 있습니다. 예:

import wandb

# 사용자 지정 값을 전달하여 config-defaults.yaml 재정의
with wandb.init(config={"epochs": 200, "batch_size": 64}) as run:
    ...

config-defaults.yaml 이외의 구성 파일을 로드하려면 --configs 커맨드라인 인수를 사용하고 파일 경로를 지정합니다.

python train.py --configs other-config.yaml

파일 기반 configs의 유스 케이스 예제

Run에 대한 일부 메타데이터가 있는 YAML 파일과 Python 스크립트에 하이퍼파라미터 사전이 있다고 가정합니다. 중첩된 config 오브젝트에 둘 다 저장할 수 있습니다.

hyperparameter_defaults = dict(
    dropout=0.5,
    batch_size=100,
    learning_rate=0.001,
)

config_dictionary = dict(
    yaml=my_yaml_file,
    params=hyperparameter_defaults,
)

with wandb.init(config=config_dictionary) as run:
    ...

TensorFlow v1 flags

TensorFlow flags를 wandb.config 오브젝트에 직접 전달할 수 있습니다.

with wandb.init() as run:
    run.config.epochs = 4

    flags = tf.app.flags
    flags.DEFINE_string("data_dir", "/tmp/data")
    flags.DEFINE_integer("batch_size", 128, "배치 크기.")
    run.config.update(flags.FLAGS)  # tensorflow flags를 config로 추가

3 - Projects

프로젝트는 결과를 시각화하고, 실험을 비교하고, 아티팩트를 보고 다운로드하고, 자동화를 생성하는 등 다양한 작업을 수행할 수 있는 중앙 위치입니다.

각 프로젝트에는 사이드바에서 엑세스할 수 있는 다음이 포함되어 있습니다.

• Overview: 프로젝트의 스냅샷
• Workspace: 개인 시각화 샌드박스
• Runs: 프로젝트의 모든 run을 나열하는 테이블
• Automations: 프로젝트에서 구성된 자동화
• Sweeps: 자동화된 탐색 및 최적화
• Reports: 노트, run 및 그래프의 저장된 스냅샷
• Artifacts: 모든 run과 해당 run과 연결된 아티팩트 포함

Overview 탭

• Project name: 프로젝트 이름입니다. W&B는 프로젝트 필드에 제공한 이름으로 run을 초기화할 때 프로젝트를 생성합니다. 오른쪽 상단 모서리에 있는 편집 버튼을 선택하여 언제든지 프로젝트 이름을 변경할 수 있습니다.
• Description: 프로젝트에 대한 설명입니다.
• Project visibility: 프로젝트의 공개 설정입니다. 누가 엑세스할 수 있는지 결정하는 공개 설정입니다. 자세한 내용은 프로젝트 공개 설정을 참조하세요.
• Last active: 이 프로젝트에 마지막으로 데이터가 기록된 타임스탬프
• Owner: 이 프로젝트를 소유한 엔티티
• Contributors: 이 프로젝트에 기여하는 Users 수
• Total runs: 이 프로젝트의 총 Runs 수
• Total compute: 프로젝트의 모든 run 시간을 합산하여 이 총계를 얻습니다.
• Undelete runs: 드롭다운 메뉴를 클릭하고 “Undelete all runs"를 클릭하여 프로젝트에서 삭제된 Runs을 복구합니다.
• Delete project: 오른쪽 상단 모서리에 있는 점 메뉴를 클릭하여 프로젝트를 삭제합니다.

라이브 예제 보기

Workspace 탭

프로젝트의 workspace는 실험을 비교할 수 있는 개인 샌드박스를 제공합니다. 프로젝트를 사용하여 다양한 아키텍처, 하이퍼파라미터, 데이터셋, 전처리 등으로 동일한 문제에 대해 작업하면서 비교할 수 있는 Models를 구성합니다.

Runs Sidebar: 프로젝트의 모든 Runs 목록입니다.

• Dot menu: 사이드바에서 행 위로 마우스를 가져가면 왼쪽에 메뉴가 나타납니다. 이 메뉴를 사용하여 run 이름을 바꾸거나, run을 삭제하거나, 활성 run을 중지합니다.
• Visibility icon: 눈을 클릭하여 그래프에서 Runs을 켜고 끕니다.
• Color: run 색상을 다른 사전 설정 색상 또는 사용자 지정 색상으로 변경합니다.
• Search: 이름으로 Runs을 검색합니다. 이렇게 하면 플롯에서 보이는 Runs도 필터링됩니다.
• Filter: 사이드바 필터를 사용하여 보이는 Runs 집합을 좁힙니다.
• Group: 아키텍처별로 Runs을 동적으로 그룹화할 구성 열을 선택합니다. 그룹화하면 플롯에 평균 값을 따라 선이 표시되고 그래프에서 점의 분산에 대한 음영 영역이 표시됩니다.
• Sort: 가장 낮은 손실 또는 가장 높은 정확도를 가진 Runs과 같이 Runs을 정렬할 값을 선택합니다. 정렬은 그래프에 표시되는 Runs에 영향을 미칩니다.
• Expand button: 사이드바를 전체 테이블로 확장합니다.
• Run count: 상단의 괄호 안의 숫자는 프로젝트의 총 Runs 수입니다. (N visualized) 숫자는 눈이 켜져 있고 각 플롯에서 시각화할 수 있는 Runs 수입니다. 아래 예에서 그래프는 183개의 Runs 중 처음 10개만 보여줍니다. 보이는 Runs의 최대 수를 늘리려면 그래프를 편집합니다.

Runs 탭에서 열을 고정, 숨기거나 순서를 변경하면 Runs 사이드바에 이러한 사용자 지정이 반영됩니다.

Panels layout: 이 스크래치 공간을 사용하여 결과를 탐색하고, 차트를 추가 및 제거하고, 다양한 메트릭을 기반으로 Models 버전을 비교합니다.

라이브 예제 보기

패널 섹션 추가

섹션 드롭다운 메뉴를 클릭하고 “섹션 추가"를 클릭하여 패널에 대한 새 섹션을 만듭니다. 섹션 이름을 바꾸고, 드래그하여 재구성하고, 섹션을 확장 및 축소할 수 있습니다.

각 섹션에는 오른쪽 상단 모서리에 다음과 같은 옵션이 있습니다.

• Switch to custom layout: 사용자 지정 레이아웃을 사용하면 패널 크기를 개별적으로 조정할 수 있습니다.
• Switch to standard layout: 표준 레이아웃을 사용하면 섹션의 모든 패널 크기를 한 번에 조정할 수 있으며 페이지 매김을 제공합니다.
• Add section: 드롭다운 메뉴에서 위 또는 아래에 섹션을 추가하거나 페이지 하단의 버튼을 클릭하여 새 섹션을 추가합니다.
• Rename section: 섹션 제목을 변경합니다.
• Export section to report: 이 패널 섹션을 새 Report에 저장합니다.
• Delete section: 전체 섹션과 모든 차트를 제거합니다. 페이지 하단의 워크스페이스 바에서 실행 취소 버튼으로 실행 취소할 수 있습니다.
• Add panel: 더하기 버튼을 클릭하여 섹션에 패널을 추가합니다.

섹션 간에 패널 이동

패널을 드래그 앤 드롭하여 섹션으로 재정렬하고 구성합니다. 패널 오른쪽 상단 모서리에 있는 “이동” 버튼을 클릭하여 패널을 이동할 섹션을 선택할 수도 있습니다.

패널 크기 조정

• Standard layout: 모든 패널은 동일한 크기를 유지하고 패널 페이지가 있습니다. 오른쪽 하단 모서리를 클릭하고 드래그하여 패널 크기를 조정할 수 있습니다. 섹션의 오른쪽 하단 모서리를 클릭하고 드래그하여 섹션 크기를 조정합니다.
• Custom layout: 모든 패널의 크기는 개별적으로 조정되며 페이지가 없습니다.

메트릭 검색

워크스페이스의 검색 상자를 사용하여 패널을 필터링합니다. 이 검색은 기본적으로 시각화된 메트릭의 이름인 패널 제목과 일치합니다.

Runs 탭

Runs 탭을 사용하여 Runs을 필터링, 그룹화 및 정렬합니다.

다음 탭은 Runs 탭에서 수행할 수 있는 몇 가지 일반적인 작업을 보여줍니다.

• Customize columns
• Sort
• Filter
• Group

Runs 탭은 프로젝트의 Runs에 대한 세부 정보를 보여줍니다. 기본적으로 많은 수의 열을 보여줍니다.

• 보이는 모든 열을 보려면 페이지를 가로로 스크롤합니다.
• 열 순서를 변경하려면 열을 왼쪽 또는 오른쪽으로 드래그합니다.
• 열을 고정하려면 열 이름 위로 마우스를 가져간 다음 나타나는 작업 메뉴 ...을 클릭한 다음 열 고정을 클릭합니다. 고정된 열은 이름 열 뒤에 페이지 왼쪽에 가깝게 나타납니다. 고정된 열을 고정 해제하려면 열 고정 해제를 선택합니다.
• 열을 숨기려면 열 이름 위로 마우스를 가져간 다음 나타나는 작업 메뉴 ...을 클릭한 다음 열 숨기기를 클릭합니다. 현재 숨겨진 모든 열을 보려면 열을 클릭합니다.
  • 숨겨진 열의 이름을 클릭하여 숨김 해제합니다.
  • 보이는 열의 이름을 클릭하여 숨깁니다.
  • 보이는 열 옆에 있는 핀 아이콘을 클릭하여 고정합니다.

Runs 탭을 사용자 지정하면 사용자 지정은 Workspace 탭의 Runs 선택기에도 반영됩니다.

지정된 열의 값을 기준으로 테이블의 모든 행을 정렬합니다.

1. 열 제목 위로 마우스를 가져갑니다. 케밥 메뉴(세 개의 세로 문서)가 나타납니다.
2. 케밥 메뉴(세 개의 세로 점)에서 선택합니다.
3. 행을 오름차순 또는 내림차순으로 정렬하려면 각각 오름차순 정렬 또는 내림차순 정렬을 선택합니다.

위의 이미지는 val_acc라는 테이블 열에 대한 정렬 옵션을 보는 방법을 보여줍니다.

대시보드 왼쪽 상단에 있는 필터 버튼을 사용하여 표현식으로 모든 행을 필터링합니다.

필터 추가를 선택하여 행에 하나 이상의 필터를 추가합니다. 세 개의 드롭다운 메뉴가 나타납니다. 왼쪽에서 오른쪽으로 필터 유형은 열 이름, 연산자 및 값을 기반으로 합니다.

	열 이름	이항 관계	값
허용된 값	문자열	=, ≠, ≤, ≥, IN, NOT IN,	정수, 부동 소수점, 문자열, 타임스탬프, null

표현식 편집기는 열 이름과 논리적 술어 구조에 대한 자동 완성을 사용하여 각 용어에 대한 옵션 목록을 보여줍니다. “and” 또는 “or”(때로는 괄호)를 사용하여 여러 논리적 술어를 하나의 표현식으로 연결할 수 있습니다.

위의 이미지는 `val_loss` 열을 기반으로 하는 필터를 보여줍니다. 필터는 유효성 검사 손실이 1 이하인 Runs을 보여줍니다.

열 머리글에서 그룹화 기준 버튼을 사용하여 특정 열의 값을 기준으로 모든 행을 그룹화합니다.

기본적으로 이렇게 하면 다른 숫자 열이 해당 그룹 전체의 해당 열에 대한 값 분포를 보여주는 히스토그램으로 바뀝니다. 그룹화는 데이터에서 상위 수준 패턴을 이해하는 데 유용합니다.

Reports 탭

결과의 모든 스냅샷을 한 곳에서 보고 팀과 발견한 내용을 공유하세요.

Sweeps 탭

프로젝트에서 새 sweep을 시작합니다.

Artifacts 탭

트레이닝 데이터셋 및 파인튜닝된 Models에서 메트릭 및 미디어 테이블에 이르기까지 프로젝트와 연결된 모든 Artifacts를 봅니다.

Overview 패널

Overview 패널에서는 아티팩트 이름과 버전, 변경 사항을 감지하고 중복을 방지하는 데 사용되는 해시 다이제스트, 생성 날짜, 에일리어스를 포함하여 아티팩트에 대한 다양한 고급 정보를 찾을 수 있습니다. 여기서 에일리어스를 추가하거나 제거하고 버전과 아티팩트 전체에 대한 메모를 작성할 수 있습니다.

Metadata 패널

Metadata 패널은 아티팩트가 구성될 때 제공되는 아티팩트의 메타데이터에 대한 엑세스를 제공합니다. 이 메타데이터에는 아티팩트를 재구성하는 데 필요한 구성 인수, 더 많은 정보를 찾을 수 있는 URL 또는 아티팩트를 기록한 run 중에 생성된 메트릭이 포함될 수 있습니다. 또한 아티팩트를 생성한 run에 대한 구성과 아티팩트를 로깅할 당시의 기록 메트릭을 볼 수 있습니다.

Usage 패널

Usage 패널은 예를 들어 로컬 머신에서 웹 앱 외부에서 사용할 수 있도록 아티팩트를 다운로드하기 위한 코드 조각을 제공합니다. 이 섹션은 또한 아티팩트를 출력하는 run과 아티팩트를 입력으로 사용하는 모든 Runs을 나타내고 링크합니다.

Files 패널

Files 패널은 아티팩트와 연결된 파일 및 폴더를 나열합니다. W&B는 run에 대한 특정 파일을 자동으로 업로드합니다. 예를 들어 requirements.txt는 run에서 사용된 각 라이브러리의 버전을 보여주고 wandb-metadata.json 및 wandb-summary.json에는 run에 대한 정보가 포함되어 있습니다. 다른 파일은 run의 구성에 따라 아티팩트 또는 미디어와 같이 업로드될 수 있습니다. 이 파일 트리를 탐색하고 W&B 웹 앱에서 직접 내용을 볼 수 있습니다.

아티팩트와 연결된 테이블은 특히 풍부하고 대화형입니다. Artifacts와 함께 테이블을 사용하는 방법에 대해 자세히 알아보려면 여기를 참조하세요.

Lineage 패널

Lineage 패널은 프로젝트와 연결된 모든 아티팩트와 서로 연결하는 Runs에 대한 뷰를 제공합니다. run 유형을 블록으로, 아티팩트를 원으로 표시하고 화살표를 사용하여 지정된 유형의 run이 지정된 유형의 아티팩트를 소비하거나 생성하는 시기를 나타냅니다. 왼쪽 열에서 선택한 특정 아티팩트의 유형이 강조 표시됩니다.

개별 아티팩트 버전과 연결하는 특정 Runs을 모두 보려면 Explode 토글을 클릭합니다.

Action History Audit 탭

작업 기록 감사 탭은 리소스의 전체 진화를 감사할 수 있도록 컬렉션에 대한 모든 에일리어스 작업과 멤버십 변경 사항을 보여줍니다.

Versions 탭

Versions 탭은 아티팩트의 모든 버전과 버전을 로깅할 당시의 Run History의 각 숫자 값에 대한 열을 보여줍니다. 이를 통해 성능을 비교하고 관심 있는 버전을 빠르게 식별할 수 있습니다.

프로젝트에 별표 표시

프로젝트에 별표를 추가하여 해당 프로젝트를 중요하다고 표시합니다. 사용자와 팀이 별표로 중요하다고 표시한 프로젝트는 조직의 홈페이지 상단에 나타납니다.

예를 들어, 다음 이미지는 중요하다고 표시된 두 개의 프로젝트인 zoo_experiment와 registry_demo를 보여줍니다. 두 프로젝트 모두 Starred projects 섹션 내에서 조직의 홈페이지 상단에 나타납니다.

프로젝트를 중요하다고 표시하는 방법에는 프로젝트의 Overview 탭 내에서 또는 팀의 프로필 페이지 내에서 두 가지가 있습니다.

• Project overview
• Team profile

1. W&B 앱의 https://wandb.ai/<team>/<project-name>에서 W&B 프로젝트로 이동합니다.
2. 프로젝트 사이드바에서 Overview 탭을 선택합니다.
3. 오른쪽 상단 모서리에 있는 편집 버튼 옆에 있는 별표 아이콘을 선택합니다.

1. https://wandb.ai/<team>/projects에서 팀의 프로필 페이지로 이동합니다.
2. Projects 탭을 선택합니다.
3. 별표를 표시할 프로젝트 옆으로 마우스를 가져갑니다. 나타나는 별표 아이콘을 클릭합니다.

예를 들어, 다음 이미지는 “Compare_Zoo_Models” 프로젝트 옆에 있는 별표 아이콘을 보여줍니다.

앱의 왼쪽 상단 모서리에 있는 조직 이름을 클릭하여 프로젝트가 조직의 랜딩 페이지에 나타나는지 확인합니다.

프로젝트 삭제

Overview 탭의 오른쪽에 있는 세 개의 점을 클릭하여 프로젝트를 삭제할 수 있습니다.

프로젝트가 비어 있으면 오른쪽 상단의 드롭다운 메뉴를 클릭하고 프로젝트 삭제를 선택하여 삭제할 수 있습니다.

프로젝트에 노트 추가

설명 개요 또는 Workspace 내의 마크다운 패널로 프로젝트에 노트를 추가합니다.

프로젝트에 설명 개요 추가

페이지에 추가하는 설명은 프로필의 Overview 탭에 나타납니다.

1. W&B 프로젝트로 이동합니다.
2. 프로젝트 사이드바에서 Overview 탭을 선택합니다.
3. 오른쪽 상단 모서리에서 편집을 선택합니다.
4. Description 필드에 노트를 추가합니다.
5. Save 버튼을 선택합니다.

Run Workspace에 노트 추가

1. W&B 프로젝트로 이동합니다.
2. 프로젝트 사이드바에서 Workspace 탭을 선택합니다.
3. 오른쪽 상단 모서리에서 패널 추가 버튼을 선택합니다.
4. 나타나는 모달에서 TEXT AND CODE 드롭다운을 선택합니다.
5. Markdown을 선택합니다.
6. Workspace에 나타나는 마크다운 패널에 노트를 추가합니다.

4 - View experiments results

W&B 워크스페이스는 차트를 사용자 정의하고 모델 결과를 탐색할 수 있는 개인 샌드박스입니다. W&B 워크스페이스는 테이블 과 패널 섹션 으로 구성됩니다.

• 테이블: 프로젝트에 기록된 모든 run이 프로젝트 테이블에 나열됩니다. Run을 켜고 끄고, 색상을 변경하고, 테이블을 확장하여 각 run에 대한 메모, 구성 및 요약 메트릭을 확인합니다.
• 패널 섹션: 하나 이상의 패널을 포함하는 섹션입니다. 새 패널을 만들고, 구성하고, 리포트로 내보내 워크스페이스의 스냅샷을 저장합니다.

워크스페이스 유형

주요 워크스페이스 범주에는 개인 워크스페이스 와 저장된 뷰 의 두 가지가 있습니다.

• 개인 워크스페이스: 모델 및 데이터 시각화에 대한 심층 분석을 위한 사용자 정의 가능한 워크스페이스입니다. 워크스페이스 소유자만 변경 사항을 편집하고 저장할 수 있습니다. 팀원은 개인 워크스페이스를 볼 수 있지만 다른 사람의 개인 워크스페이스는 변경할 수 없습니다.
• 저장된 뷰: 저장된 뷰는 워크스페이스의 협업 스냅샷입니다. 팀의 모든 구성원이 저장된 워크스페이스 뷰를 보고, 편집하고, 변경 사항을 저장할 수 있습니다. 저장된 워크스페이스 뷰를 사용하여 Experiments, Runs 등을 검토하고 논의합니다.

다음 이미지는 Cécile-parker의 팀원이 만든 여러 개인 워크스페이스를 보여줍니다. 이 프로젝트에는 저장된 뷰가 없습니다.

저장된 워크스페이스 뷰

맞춤형 워크스페이스 뷰로 팀 협업을 개선하십시오. 저장된 뷰를 만들어 차트 및 데이터의 기본 설정을 구성합니다.

새 저장된 워크스페이스 뷰 만들기

1. 개인 워크스페이스 또는 저장된 뷰로 이동합니다.
2. 워크스페이스를 편집합니다.
3. 워크스페이스 오른쪽 상단에 있는 미트볼 메뉴 (가로 점 3개) 를 클릭합니다. 새 뷰로 저장 을 클릭합니다.

새로운 저장된 뷰가 워크스페이스 탐색 메뉴에 나타납니다.

저장된 워크스페이스 뷰 업데이트

저장된 변경 사항은 저장된 뷰의 이전 상태를 덮어씁니다. 저장되지 않은 변경 사항은 유지되지 않습니다. W&B에서 저장된 워크스페이스 뷰를 업데이트하려면:

1. 저장된 뷰로 이동합니다.
2. 워크스페이스 내에서 차트 및 데이터에 원하는 변경 사항을 적용합니다.
3. 저장 버튼을 클릭하여 변경 사항을 확인합니다.

저장된 워크스페이스 뷰 삭제

더 이상 필요하지 않은 저장된 뷰를 제거합니다.

1. 제거할 저장된 뷰로 이동합니다.
2. 뷰 오른쪽 상단의 가로선 3개 (…) 를 선택합니다.
3. 뷰 삭제 를 선택합니다.
4. 삭제를 확인하여 워크스페이스 메뉴에서 뷰를 제거합니다.

워크스페이스 뷰 공유

워크스페이스 URL을 직접 공유하여 사용자 정의된 워크스페이스를 팀과 공유합니다. 워크스페이스 프로젝트에 엑세스할 수 있는 모든 사용자는 해당 워크스페이스의 저장된 뷰를 볼 수 있습니다.

프로그래밍 방식으로 워크스페이스 만들기

wandb-workspaces 는 W&B 워크스페이스 및 리포트를 프로그래밍 방식으로 작업하기 위한 Python 라이브러리입니다.

wandb-workspaces 로 프로그래밍 방식으로 워크스페이스를 정의합니다. wandb-workspaces 는 W&B 워크스페이스 및 리포트를 프로그래밍 방식으로 작업하기 위한 Python 라이브러리입니다.

다음과 같은 워크스페이스 속성을 정의할 수 있습니다.

• 패널 레이아웃, 색상 및 섹션 순서를 설정합니다.
• 기본 x축, 섹션 순서 및 축소 상태와 같은 워크스페이스 설정을 구성합니다.
• 섹션 내에 패널을 추가하고 사용자 정의하여 워크스페이스 뷰를 구성합니다.
• URL을 사용하여 기존 워크스페이스를 로드하고 수정합니다.
• 기존 워크스페이스에 대한 변경 사항을 저장하거나 새 뷰로 저장합니다.
• 간단한 표현식을 사용하여 Runs을 프로그래밍 방식으로 필터링, 그룹화 및 정렬합니다.
• 색상 및 가시성과 같은 설정으로 Run 모양을 사용자 정의합니다.
• 통합 및 재사용을 위해 한 워크스페이스에서 다른 워크스페이스로 뷰를 복사합니다.

워크스페이스 API 설치

wandb 외에도 wandb-workspaces 를 설치해야 합니다.

pip install wandb wandb-workspaces

프로그래밍 방식으로 워크스페이스 뷰를 정의하고 저장합니다.

import wandb_workspaces.reports.v2 as wr

workspace = ws.Workspace(entity="your-entity", project="your-project", views=[...])
workspace.save()

기존 뷰 편집

existing_workspace = ws.Workspace.from_url("workspace-url")
existing_workspace.views[0] = ws.View(name="my-new-view", sections=[...])
existing_workspace.save()

워크스페이스 saved view 를 다른 워크스페이스로 복사합니다.

old_workspace = ws.Workspace.from_url("old-workspace-url")
old_workspace_view = old_workspace.views[0]
new_workspace = ws.Workspace(entity="new-entity", project="new-project", views=[old_workspace_view])

new_workspace.save()

종합적인 워크스페이스 API 예제는 wandb-workspace examples 를 참조하십시오. 엔드 투 엔드 튜토리얼은 Programmatic Workspaces 튜토리얼을 참조하십시오.

5 - What are runs?

W&B에서 run은 로그된 단일 연산 단위입니다. W&B run을 전체 프로젝트의 원자적 요소로 생각할 수 있습니다. 다시 말해, 각 run은 모델 트레이닝 및 결과 로깅, 하이퍼파라미터 스윕 등과 같은 특정 연산의 기록입니다.

run을 시작하는 일반적인 패턴은 다음을 포함하지만 이에 국한되지는 않습니다.

• 모델 트레이닝
• 하이퍼파라미터를 변경하고 새로운 실험 수행
• 다른 모델로 새로운 기계학습 실험 수행
• W&B Artifacts로 데이터 또는 모델 로깅
• W&B Artifacts 다운로드

W&B는 생성한 run을 프로젝트에 저장합니다. W&B 앱 UI에서 run과 해당 속성을 run의 프로젝트 워크스페이스 내에서 볼 수 있습니다. wandb.Api.Run 오브젝트를 사용하여 run 속성에 프로그래밍 방식으로 엑세스할 수도 있습니다.

run.log로 로그하는 모든 내용은 해당 run에 기록됩니다. 다음 코드 조각을 살펴보십시오.

import wandb

run = wandb.init(entity="nico", project="awesome-project")
run.log({"accuracy": 0.9, "loss": 0.1})

첫 번째 줄은 W&B Python SDK를 임포트합니다. 두 번째 줄은 엔터티 nico 아래의 프로젝트 awesome-project에서 run을 초기화합니다. 세 번째 줄은 모델의 정확도와 손실을 해당 run에 기록합니다.

터미널 내에서 W&B는 다음을 반환합니다.

wandb: Syncing run earnest-sunset-1
wandb: ⭐️ View project at https://wandb.ai/nico/awesome-project
wandb: 🚀 View run at https://wandb.ai/nico/awesome-project/runs/1jx1ud12
wandb:                                                                                
wandb: 
wandb: Run history:
wandb: accuracy  
wandb:     loss  
wandb: 
wandb: Run summary:
wandb: accuracy 0.9
wandb:     loss 0.5
wandb: 
wandb: 🚀 View run earnest-sunset-1 at: https://wandb.ai/nico/awesome-project/runs/1jx1ud12
wandb: ⭐️ View project at: https://wandb.ai/nico/awesome-project
wandb: Synced 6 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)
wandb: Find logs at: ./wandb/run-20241105_111006-1jx1ud12/logs

터미널에서 W&B가 반환하는 URL은 W&B 앱 UI에서 run의 워크스페이스로 리디렉션합니다. 워크스페이스에서 생성된 패널은 단일 지점에 해당합니다.

단일 시점에 메트릭을 로깅하는 것은 그다지 유용하지 않을 수 있습니다. 판별 모델 트레이닝의 경우 더 현실적인 예는 메트릭을 정기적인 간격으로 로깅하는 것입니다. 예를 들어, 다음 코드 조각을 살펴보십시오.

epochs = 10
lr = 0.01

run = wandb.init(
    entity="nico",
    project="awesome-project",
    config={
        "learning_rate": lr,
        "epochs": epochs,
    },
)

offset = random.random() / 5

# simulating a training run
for epoch in range(epochs):
    acc = 1 - 2**-epoch - random.random() / (epoch + 1) - offset
    loss = 2**-epoch + random.random() / (epoch + 1) + offset
    print(f"epoch={epoch}, accuracy={acc}, loss={loss}")
    run.log({"accuracy": acc, "loss": loss})

다음 출력을 반환합니다.

wandb: Syncing run jolly-haze-4
wandb: ⭐️ View project at https://wandb.ai/nico/awesome-project
wandb: 🚀 View run at https://wandb.ai/nico/awesome-project/runs/pdo5110r
lr: 0.01
epoch=0, accuracy=-0.10070974957523078, loss=1.985328507123956
epoch=1, accuracy=0.2884687745057535, loss=0.7374362314407752
epoch=2, accuracy=0.7347387967382066, loss=0.4402409835486663
epoch=3, accuracy=0.7667969248039795, loss=0.26176963846423457
epoch=4, accuracy=0.7446848791003173, loss=0.24808611724405083
epoch=5, accuracy=0.8035095836268268, loss=0.16169791827329466
epoch=6, accuracy=0.861349032371624, loss=0.03432578493587426
epoch=7, accuracy=0.8794926436276016, loss=0.10331872172219471
epoch=8, accuracy=0.9424839917077272, loss=0.07767793473500445
epoch=9, accuracy=0.9584880427028566, loss=0.10531971149250456
wandb: 🚀 View run jolly-haze-4 at: https://wandb.ai/nico/awesome-project/runs/pdo5110r
wandb: Find logs at: wandb/run-20241105_111816-pdo5110r/logs

트레이닝 스크립트는 run.log를 10번 호출합니다. 스크립트가 run.log를 호출할 때마다 W&B는 해당 에포크의 정확도와 손실을 기록합니다. W&B가 이전 출력에서 출력하는 URL을 선택하면 W&B 앱 UI에서 run의 워크스페이스로 이동합니다.

스크립트가 wandb.init 메서드를 한 번만 호출하기 때문에 W&B는 시뮬레이션된 트레이닝 루프를 jolly-haze-4라는 단일 run 내에서 캡처합니다.

또 다른 예로, 스윕 중에 W&B는 사용자가 지정한 하이퍼파라미터 검색 공간을 탐색합니다. W&B는 스윕이 생성하는 각 새로운 하이퍼파라미터 조합을 고유한 run으로 구현합니다.

Run 초기화

wandb.init()로 W&B run을 초기화합니다. 다음 코드 조각은 W&B Python SDK를 임포트하고 run을 초기화하는 방법을 보여줍니다.

각도 괄호(<>)로 묶인 값을 사용자 고유의 값으로 바꾸십시오.

import wandb

run = wandb.init(entity="<entity>", project="<project>")

run을 초기화할 때 W&B는 프로젝트 필드에 지정한 프로젝트(wandb.init(project="<project>"))에 run을 기록합니다. W&B는 프로젝트가 아직 존재하지 않으면 새 프로젝트를 만듭니다. 프로젝트가 이미 존재하는 경우 W&B는 해당 프로젝트에 run을 저장합니다.

W&B의 각 run에는 run ID라고 하는 고유 식별자가 있습니다. 고유 ID를 지정하거나 W&B가 임의로 ID를 생성하도록 할 수 있습니다.

각 run에는 사람이 읽을 수 있는 run 이름이라고 하는 고유하지 않은 식별자도 있습니다. run 이름을 지정하거나 W&B가 임의로 이름을 생성하도록 할 수 있습니다.

예를 들어, 다음 코드 조각을 살펴보십시오.

import wandb

run = wandb.init(entity="wandbee", project="awesome-project")

코드 조각은 다음 출력을 생성합니다.

🚀 View run exalted-darkness-6 at: 
https://wandb.ai/nico/awesome-project/runs/pgbn9y21
Find logs at: wandb/run-20241106_090747-pgbn9y21/logs

이전 코드는 id 파라미터에 대한 인수를 지정하지 않았으므로 W&B는 고유한 run ID를 만듭니다. 여기서 nico는 run을 기록한 엔터티이고, awesome-project는 run이 기록된 프로젝트의 이름이고, exalted-darkness-6은 run의 이름이고, pgbn9y21은 run ID입니다.

import wandb

run = wandb.init(entity="<entity>", project="<project>")
# Training code, logging, and so forth
run.finish()

각 run에는 run의 현재 상태를 설명하는 상태가 있습니다. 가능한 run 상태의 전체 목록은 Run 상태를 참조하십시오.

Run 상태

다음 표는 run이 가질 수 있는 가능한 상태를 설명합니다.

고유한 run 식별자

Run ID는 run에 대한 고유 식별자입니다. 기본적으로 W&B는 새 run을 초기화할 때 임의의 고유한 run ID를 생성합니다. run을 초기화할 때 고유한 run ID를 지정할 수도 있습니다.

자동 생성된 run ID

run을 초기화할 때 run ID를 지정하지 않으면 W&B는 임의의 run ID를 생성합니다. W&B 앱 UI에서 run의 고유 ID를 찾을 수 있습니다.

1. https://wandb.ai/home에서 W&B 앱 UI로 이동합니다.
2. run을 초기화할 때 지정한 W&B 프로젝트로 이동합니다.
3. 프로젝트의 워크스페이스 내에서 Runs 탭을 선택합니다.
4. Overview 탭을 선택합니다.

W&B는 Run path 필드에 고유한 run ID를 표시합니다. run 경로는 팀 이름, 프로젝트 이름 및 run ID로 구성됩니다. 고유 ID는 run 경로의 마지막 부분입니다.

예를 들어, 다음 이미지에서 고유한 run ID는 9mxi1arc입니다.

사용자 지정 run ID

id 파라미터를 wandb.init 메서드에 전달하여 사용자 고유의 run ID를 지정할 수 있습니다.

import wandb

run = wandb.init(entity="<project>", project="<project>", id="<run-id>")

run의 고유 ID를 사용하여 W&B 앱 UI에서 run의 Overview 페이지로 직접 이동할 수 있습니다. 다음 셀은 특정 run에 대한 URL 경로를 보여줍니다.

https://wandb.ai/<entity>/<project>/<run-id>

각도 괄호(<>)로 묶인 값은 엔터티, 프로젝트 및 run ID의 실제 값에 대한 자리 표시자입니다.

Run 이름 지정

run 이름은 사람이 읽을 수 있는 고유하지 않은 식별자입니다.

기본적으로 W&B는 새 run을 초기화할 때 임의의 run 이름을 생성합니다. run 이름은 프로젝트의 워크스페이스 내와 run의 Overview 페이지 상단에 나타납니다.

name 파라미터를 wandb.init 메서드에 전달하여 run 이름을 지정할 수 있습니다.

import wandb

run = wandb.init(entity="<project>", project="<project>", name="<run-name>")

Run에 노트 추가

특정 run에 추가하는 노트는 Overview 탭의 run 페이지와 프로젝트 페이지의 run 테이블에 나타납니다.

1. W&B 프로젝트로 이동합니다.
2. 프로젝트 사이드바에서 Workspace 탭을 선택합니다.
3. 노트를 추가할 run을 run 선택기에서 선택합니다.
4. Overview 탭을 선택합니다.
5. Description 필드 옆에 있는 연필 아이콘을 선택하고 노트를 추가합니다.

Run 중지

W&B 앱 또는 프로그래밍 방식으로 run을 중지합니다.

• 프로그래밍 방식
• W&B 앱

1. run을 초기화한 터미널 또는 코드 편집기로 이동합니다.
2. Ctrl+D를 눌러 run을 중지합니다.

예를 들어, 이전 지침을 따르면 터미널이 다음과 유사하게 보일 수 있습니다.

KeyboardInterrupt
wandb: 🚀 View run legendary-meadow-2 at: https://wandb.ai/nico/history-blaster-4/runs/o8sdbztv
wandb: Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 1 other file(s)
wandb: Find logs at: ./wandb/run-20241106_095857-o8sdbztv/logs

W&B 앱 UI로 이동하여 run이 더 이상 활성 상태가 아닌지 확인합니다.

1. run이 기록되고 있는 프로젝트로 이동합니다.
2. run 이름을 선택합니다.

터미널 또는 코드 편집기의 출력에서 중지한 run 이름을 찾을 수 있습니다. 예를 들어, 이전 예에서 run 이름은 legendary-meadow-2입니다.

3. 프로젝트 사이드바에서 **Overview** 탭을 선택합니다.

State 필드 옆에 있는 run의 상태가 running에서 Killed로 변경됩니다.

1. run이 기록되고 있는 프로젝트로 이동합니다.
2. run 선택기 내에서 중지할 run을 선택합니다.
3. 프로젝트 사이드바에서 Overview 탭을 선택합니다.
4. State 필드 옆에 있는 맨 위 버튼을 선택합니다.

State 필드 옆에 있는 run의 상태가 running에서 Killed로 변경됩니다.

가능한 run 상태의 전체 목록은 상태 필드를 참조하십시오.

기록된 Run 보기

Run 상태, run에 기록된 Artifacts, run 중에 기록된 로그 파일 등과 같은 특정 run에 대한 정보를 봅니다.

특정 run을 보려면 다음을 수행하십시오.

1. https://wandb.ai/home에서 W&B 앱 UI로 이동합니다.

2. run을 초기화할 때 지정한 W&B 프로젝트로 이동합니다.

3. 프로젝트 사이드바 내에서 Workspace 탭을 선택합니다.

4. run 선택기 내에서 보려는 run을 클릭하거나 일치하는 run을 필터링하기 위해 run 이름의 일부를 입력합니다.

   기본적으로 긴 run 이름은 가독성을 위해 중간에서 잘립니다. 대신 run 이름을 시작 또는 끝에서 자르려면 run 목록 상단에 있는 작업 ... 메뉴를 클릭한 다음 Run name cropping을 설정하여 끝, 중간 또는 시작을 자릅니다.

특정 run의 URL 경로는 다음 형식을 갖습니다.

https://wandb.ai/<team-name>/<project-name>/runs/<run-id>

각도 괄호(<>)로 묶인 값은 팀 이름, 프로젝트 이름 및 run ID의 실제 값에 대한 자리 표시자입니다.

Overview 탭

Overview 탭을 사용하여 프로젝트에서 다음과 같은 특정 run 정보를 알아봅니다.

• Author: run을 만드는 W&B 엔터티입니다.
• Command: run을 초기화하는 코맨드입니다.
• Description: 사용자가 제공한 run에 대한 설명입니다. run을 만들 때 설명을 지정하지 않으면 이 필드는 비어 있습니다. W&B 앱 UI를 사용하거나 Python SDK를 사용하여 프로그래밍 방식으로 run에 설명을 추가할 수 있습니다.
• Duration: run이 일시 중지 또는 대기 시간을 제외하고 활발하게 연산하거나 데이터를 로깅하는 데 걸리는 시간입니다.
• Git repository: run과 연결된 Git 리포지토리입니다. 이 필드를 보려면 Git을 활성화해야 합니다.
• Host name: W&B가 run을 연산하는 위치입니다. 머신에서 로컬로 run을 초기화하는 경우 W&B는 머신 이름을 표시합니다.
• Name: run 이름입니다.
• OS: run을 초기화하는 운영 체제입니다.
• Python executable: run을 시작하는 코맨드입니다.
• Python version: run을 만드는 Python 버전을 지정합니다.
• Run path: entity/project/run-ID 형식으로 고유한 run 식별자를 식별합니다.
• Runtime: run 시작부터 종료까지의 총 시간을 측정합니다. run에 대한 실제 시간입니다. Runtime에는 run이 일시 중지되거나 리소스를 기다리는 시간이 포함되지만 Duration에는 포함되지 않습니다.
• Start time: run을 초기화한 타임스탬프입니다.
• State: run 상태입니다.
• System hardware: W&B가 run을 연산하는 데 사용하는 하드웨어입니다.
• Tags: 문자열 목록입니다. 태그는 관련 run을 함께 구성하거나 베이스라인 또는 프로덕션과 같은 임시 레이블을 적용하는 데 유용합니다.
• W&B CLI version: run 코맨드를 호스팅한 머신에 설치된 W&B CLI 버전입니다.

W&B는 Overview 섹션 아래에 다음 정보를 저장합니다.

• Artifact Outputs: run에서 생성된 Artifacts 출력입니다.
• Config: wandb.config로 저장된 구성 파라미터 목록입니다.
• Summary: wandb.log()로 저장된 요약 파라미터 목록입니다. 기본적으로 W&B는 이 값을 마지막으로 기록된 값으로 설정합니다.

여기에서 프로젝트 Overview의 예를 봅니다.

Workspace 탭

Workspace 탭을 사용하여 자동 생성된 플롯 및 사용자 지정 플롯, 시스템 메트릭 등과 같은 시각화를 보고, 검색하고, 그룹화하고, 정렬합니다.

여기에서 프로젝트 워크스페이스의 예를 봅니다.

Runs 탭

Runs 탭을 사용하여 run을 필터링, 그룹화 및 정렬합니다.

다음 탭은 Runs 탭에서 수행할 수 있는 몇 가지 일반적인 작업을 보여줍니다.

• 열 사용자 지정
• 정렬
• 필터
• 그룹

Runs 탭에는 프로젝트의 run에 대한 세부 정보가 표시됩니다. 기본적으로 많은 열이 표시됩니다.

• 표시되는 모든 열을 보려면 페이지를 가로로 스크롤합니다.
• 열 순서를 변경하려면 열을 왼쪽이나 오른쪽으로 드래그합니다.
• 열을 고정하려면 열 이름 위로 마우스를 가져간 다음 나타나는 작업 메뉴 ...를 클릭하고 Pin column을 클릭합니다. 고정된 열은 Name 열 뒤에 페이지 왼쪽에 가깝게 나타납니다. 고정된 열을 고정 해제하려면 Unpin column을 선택합니다.
• 열을 숨기려면 열 이름 위로 마우스를 가져간 다음 나타나는 작업 메뉴 ...를 클릭하고 Hide column을 클릭합니다. 현재 숨겨진 모든 열을 보려면 Columns를 클릭합니다.
  • 숨겨진 열 이름을 클릭하여 숨김을 해제합니다.
  • 보이는 열 이름을 클릭하여 숨깁니다.
  • 보이는 열 옆에 있는 핀 아이콘을 클릭하여 고정합니다.

Runs 탭을 사용자 지정하면 사용자 지정이 Workspace 탭의 Runs 선택기에 반영됩니다.

지정된 열의 값을 기준으로 테이블의 모든 행을 정렬합니다.

1. 마우스를 열 제목 위로 가져갑니다. 케밥 메뉴(세 개의 세로 문서)가 나타납니다.
2. 케밥 메뉴(세 개의 세로 점)를 선택합니다.
3. Sort Asc 또는 Sort Desc를 선택하여 행을 각각 오름차순 또는 내림차순으로 정렬합니다.

위의 이미지는 val_acc라는 테이블 열에 대한 정렬 옵션을 보는 방법을 보여줍니다.

대시보드 위의 Filter 버튼으로 표현식을 사용하여 모든 행을 필터링합니다.

Add filter를 선택하여 행에 하나 이상의 필터를 추가합니다. 세 개의 드롭다운 메뉴가 나타납니다. 왼쪽에서 오른쪽으로 필터 유형은 열 이름, 연산자 및 값을 기준으로 합니다.

	열 이름	이항 관계	값
허용된 값	String	=, ≠, ≤, ≥, IN, NOT IN,	Integer, float, string, 타임스탬프, null

표현식 편집기는 열 이름과 논리적 술어 구조에 대한 자동 완성 기능을 사용하여 각 용어에 대한 옵션 목록을 보여줍니다. “and” 또는 “or”(때로는 괄호)를 사용하여 여러 논리적 술어를 하나의 표현식으로 연결할 수 있습니다.

위의 이미지는 `val_loss` 열을 기준으로 하는 필터를 보여줍니다. 필터는 유효성 검사 손실이 1 이하인 run을 보여줍니다.

대시보드 위의 Group by 버튼을 사용하여 특정 열의 값을 기준으로 모든 행을 그룹화합니다.

기본적으로 이렇게 하면 다른 숫자 열이 해당 그룹 전체의 해당 열에 대한 값 분포를 보여주는 히스토그램으로 바뀝니다. 그룹화는 데이터에서 상위 수준 패턴을 이해하는 데 유용합니다.

System 탭

System 탭은 CPU 사용률, 시스템 메모리, 디스크 I/O, 네트워크 트래픽, GPU 사용률 등과 같은 특정 run에 대해 추적된 시스템 메트릭을 보여줍니다.

W&B가 추적하는 시스템 메트릭의 전체 목록은 시스템 메트릭을 참조하십시오.

여기에서 시스템 탭의 예를 봅니다.

Logs 탭

Log 탭은 표준 출력(stdout) 및 표준 오류(stderr)와 같은 코맨드라인에 출력된 내용을 보여줍니다.

로그 파일을 다운로드하려면 오른쪽 상단 모서리에 있는 Download 버튼을 선택합니다.

여기에서 로그 탭의 예를 봅니다.

Files 탭

Files 탭을 사용하여 모델 체크포인트, 검증 세트 예제 등과 같은 특정 run과 연결된 파일을 봅니다.

여기에서 파일 탭의 예를 봅니다.

Artifacts 탭

Artifacts 탭에는 지정된 run에 대한 입력 및 출력 artifacts가 나열됩니다.

여기에서 artifacts 탭의 예를 봅니다.

Run 삭제

W&B 앱으로 프로젝트에서 하나 이상의 run을 삭제합니다.

1. 삭제할 run이 포함된 프로젝트로 이동합니다.
2. 프로젝트 사이드바에서 Runs 탭을 선택합니다.
3. 삭제할 run 옆에 있는 확인란을 선택합니다.
4. 테이블 위에 있는 Delete 버튼(휴지통 아이콘)을 선택합니다.
5. 나타나는 모달에서 Delete를 선택합니다.

Run 구성

이 섹션에서는 그룹 및 job 유형을 사용하여 run을 구성하는 방법에 대한 지침을 제공합니다. run을 그룹(예: 실험 이름)에 할당하고 job 유형(예: 전처리, 트레이닝, 평가, 디버깅)을 지정하면 워크플로우를 간소화하고 모델 비교를 개선할 수 있습니다.

Run에 그룹 또는 Job 유형 할당

W&B의 각 run은 그룹과 Job 유형으로 분류할 수 있습니다.

• Group: 실험에 대한 광범위한 범주로, run을 구성하고 필터링하는 데 사용됩니다.
• Job 유형: 전처리, 트레이닝 또는 평가와 같은 run의 기능입니다.

다음 예제 워크스페이스는 Fashion-MNIST 데이터셋에서 점점 더 많은 양의 데이터를 사용하여 베이스라인 모델을 트레이닝합니다. 워크스페이스는 색상을 사용하여 사용된 데이터 양을 나타냅니다.

• 노란색에서 진한 녹색은 베이스라인 모델에 대해 점점 더 많은 양의 데이터를 나타냅니다.
• 밝은 파란색에서 보라색에서 마젠타색은 추가 파라미터가 있는 더 복잡한 “이중” 모델에 대한 데이터 양을 나타냅니다.

W&B의 필터링 옵션과 검색 창을 사용하여 다음과 같은 특정 조건을 기준으로 run을 비교합니다.

• 동일한 데이터셋에서 트레이닝합니다.
• 동일한 테스트 세트에서 평가합니다.

필터를 적용하면 Table 보기가 자동으로 업데이트됩니다. 이렇게 하면 모델 간의 성능 차이를 식별할 수 있습니다(예: 특정 클래스가 다른 모델에 비해 훨씬 더 어려운지 확인).

5.1 - Add labels to runs with tags

로그된 메트릭 또는 아티팩트 데이터에서 명확하지 않을 수 있는 특정 기능으로 Runs에 레이블을 지정하려면 태그를 추가하세요.

예를 들어, Run의 모델이 in_production임을 나타내거나, 해당 Run이 preemptible인지, 이 Run이 baseline을 나타내는지 등을 나타내는 태그를 Run에 추가할 수 있습니다.

하나 이상의 Runs에 태그 추가

프로그래밍 방식으로 또는 대화형으로 Runs에 태그를 추가합니다.

사용 사례에 따라 필요에 가장 적합한 아래 탭을 선택하세요.

• W&B Python SDK
• Public API
• Project page
• Run page

import wandb

run = wandb.init(
  entity="entity",
  project="<project-name>",
  tags=["tag1", "tag2"]
)

import wandb

run = wandb.init(
  entity="entity", 
  project="capsules", 
  tags=["debug"]
  )

# 모델을 훈련하는 파이썬 로직

if current_loss < threshold:
    run.tags = run.tags + ("release_candidate",)

run = wandb.Api().run("{entity}/{project}/{run-id}")
run.tags.append("tag1")  # 여기에서 Run 데이터를 기반으로 태그를 선택할 수 있습니다.
run.update()

하나 이상의 Runs에서 태그 제거

태그는 W&B App UI를 사용하여 Runs에서 제거할 수도 있습니다.

• Project page
• Run page

5.2 - Filter and search runs

W&B에 기록된 run으로부터 얻은 통찰력을 프로젝트 페이지에서 활용하세요. Workspace 페이지와 Runs 페이지 모두에서 run을 필터링하고 검색할 수 있습니다.

Run 필터링

필터 버튼을 사용하여 상태, 태그 또는 기타 속성을 기준으로 run을 필터링합니다.

태그로 Run 필터링

필터 버튼을 사용하여 태그를 기준으로 run을 필터링합니다.

정규식으로 Run 필터링

정규식으로 원하는 결과를 얻을 수 없는 경우, 태그를 사용하여 Runs Table에서 run을 필터링할 수 있습니다. 태그는 run 생성 시 또는 완료 후에 추가할 수 있습니다. 태그가 run에 추가되면 아래 GIF와 같이 태그 필터를 추가할 수 있습니다.

Run 검색

regex를 사용하여 지정한 정규식으로 run을 찾습니다. 검색 상자에 쿼리를 입력하면 Workspace의 그래프에서 보이는 run과 테이블의 행이 필터링됩니다.

Run 그룹화

숨겨진 열을 포함하여 하나 이상의 열을 기준으로 run을 그룹화하려면 다음을 수행합니다.

1. 검색 상자 아래에 있는 줄이 그어진 종이 모양의 Group 버튼을 클릭합니다.
2. 결과를 그룹화할 열을 하나 이상 선택합니다.
3. 그룹화된 run 세트는 기본적으로 축소됩니다. 확장하려면 그룹 이름 옆에 있는 화살표를 클릭합니다.

최소값 및 최대값으로 Run 정렬

기록된 메트릭의 최소값 또는 최대값으로 run 테이블을 정렬합니다. 이는 가장 좋거나 가장 나쁜 기록 값을 보려는 경우에 특히 유용합니다.

다음 단계에서는 기록된 최소값 또는 최대값을 기준으로 특정 메트릭으로 run 테이블을 정렬하는 방법을 설명합니다.

1. 정렬하려는 메트릭이 있는 열 위에 마우스 커서를 올립니다.
2. 케밥 메뉴(세 개의 세로선)를 선택합니다.
3. 드롭다운에서 Show min 또는 Show max를 선택합니다.
4. 동일한 드롭다운에서 Sort by asc 또는 Sort by desc를 선택하여 각각 오름차순 또는 내림차순으로 정렬합니다.

Run에 대한 종료 시간 검색

클라이언트 프로세스에서 마지막 heartbeat를 기록하는 End Time이라는 열을 제공합니다. 이 필드는 기본적으로 숨겨져 있습니다.

Run 테이블을 CSV로 내보내기

다운로드 버튼을 사용하여 모든 run, 하이퍼파라미터 및 요약 메트릭 테이블을 CSV로 내보냅니다.

5.3 - Fork a run

기존 W&B run에서 “포크"하려면 wandb.init()으로 run을 초기화할 때 fork_from을 사용하십시오. run에서 포크하면 W&B는 소스 run의 run ID 및 step을 사용하여 새 run을 생성합니다.

run을 포크하면 원래 run에 영향을 주지 않고 실험의 특정 시점에서 다른 파라미터 또는 Models를 탐색할 수 있습니다.

포크된 run 시작

run을 포크하려면 wandb.init()에서 fork_from 인수를 사용하고 포크할 소스 run ID와 소스 run의 step을 지정하십시오.

import wandb

# 나중에 포크할 run을 초기화합니다
original_run = wandb.init(project="your_project_name", entity="your_entity_name")
# ... 트레이닝 또는 로깅 수행 ...
original_run.finish()

# 특정 step에서 run을 포크합니다
forked_run = wandb.init(
    project="your_project_name",
    entity="your_entity_name",
    fork_from=f"{original_run.id}?_step=200",
)

변경 불가능한 run ID 사용

특정 run에 대한 일관되고 변경되지 않는 참조를 보장하려면 변경 불가능한 run ID를 사용하십시오. 사용자 인터페이스에서 변경 불가능한 run ID를 얻으려면 다음 단계를 따르십시오.

1. Overview 탭에 엑세스: 소스 run 페이지의 Overview 탭으로 이동합니다.

2. 변경 불가능한 Run ID 복사: Overview 탭의 오른쪽 상단에 있는 ... 메뉴(세 개의 점)를 클릭합니다. 드롭다운 메뉴에서 Copy Immutable Run ID 옵션을 선택합니다.

이러한 단계를 따르면 run에 대한 안정적이고 변경되지 않는 참조를 갖게 되어 run을 포크하는 데 사용할 수 있습니다.

포크된 run에서 계속하기

포크된 run을 초기화한 후 새 run에 계속 로그할 수 있습니다. 연속성을 위해 동일한 메트릭을 로그하고 새 메트릭을 도입할 수 있습니다.

예를 들어 다음 코드 예제에서는 먼저 run을 포크한 다음 트레이닝 step 200부터 포크된 run에 메트릭을 로그하는 방법을 보여줍니다.

import wandb
import math

# 첫 번째 run을 초기화하고 일부 메트릭을 로그합니다
run1 = wandb.init("your_project_name", entity="your_entity_name")
for i in range(300):
    run1.log({"metric": i})
run1.finish()

# 특정 step에서 첫 번째 run에서 포크하고 step 200부터 메트릭을 로그합니다
run2 = wandb.init(
    "your_project_name", entity="your_entity_name", fork_from=f"{run1.id}?_step=200"
)

# 새 run에서 계속 로깅합니다
# 처음 몇 steps 동안은 run1에서 메트릭을 그대로 로깅합니다
# Step 250 이후에는 스파이크 패턴 로깅을 시작합니다
for i in range(200, 300):
    if i < 250:
        run2.log({"metric": i})  # 스파이크 없이 run1에서 계속 로깅합니다
    else:
        # Step 250부터 스파이크 행동을 도입합니다
        subtle_spike = i + (2 * math.sin(i / 3.0))  # 미묘한 스파이크 패턴을 적용합니다
        run2.log({"metric": subtle_spike})
    # 모든 steps에서 새 메트릭을 추가로 로깅합니다
    run2.log({"additional_metric": i * 1.1})
run2.finish()

5.4 - Group runs into experiments

개별 작업을 wandb.init() 에 고유한 group 이름을 전달하여 Experiments 로 그룹화합니다.

유스 케이스

1. 분산 트레이닝: Experiments 가 별도의 트레이닝 및 평가 스크립트로 분할되어 더 큰 전체의 일부로 보아야 하는 경우 그룹화를 사용합니다.
2. 다중 프로세스: 여러 개의 작은 프로세스를 하나의 experiment 로 그룹화합니다.
3. K-겹 교차 검증: 더 큰 experiment 를 보기 위해 다른 임의 시드를 가진 Runs 를 함께 그룹화합니다. 다음은 스윕 및 그룹화를 사용한 k-겹 교차 검증의 예제입니다.

그룹화를 설정하는 세 가지 방법이 있습니다.

1. 스크립트에서 그룹 설정

선택적 group 및 job_type 을 wandb.init() 에 전달합니다. 이렇게 하면 각 experiment 에 대한 전용 그룹 페이지가 제공되며, 여기에는 개별 Runs 가 포함됩니다. 예를 들면 다음과 같습니다. wandb.init(group="experiment_1", job_type="eval")

2. 그룹 환경 변수 설정

WANDB_RUN_GROUP 를 사용하여 Runs 에 대한 그룹을 환경 변수로 지정합니다. 자세한 내용은 환경 변수에 대한 문서를 확인하세요. Group 은 프로젝트 내에서 고유해야 하며 그룹의 모든 Runs 에서 공유해야 합니다. wandb.util.generate_id() 를 사용하여 모든 프로세스에서 사용할 고유한 8자 문자열을 생성할 수 있습니다. 예를 들어 os.environ["WANDB_RUN_GROUP"] = "experiment-" + wandb.util.generate_id() 와 같습니다.

3. UI에서 그룹화 전환

구성 열별로 동적으로 그룹화할 수 있습니다. 예를 들어 wandb.config 를 사용하여 배치 크기 또는 학습률을 로그하면 웹 앱에서 해당 하이퍼파라미터별로 동적으로 그룹화할 수 있습니다.

그룹화를 사용한 분산 트레이닝

wandb.init() 에서 그룹화를 설정하면 UI에서 기본적으로 Runs 가 그룹화됩니다. 테이블 상단의 Group 버튼을 클릭하여 이를 켜거나 끌 수 있습니다. 그룹화를 설정한 샘플 코드에서 생성된 예제 프로젝트가 있습니다. 사이드바에서 각 “Group” 행을 클릭하여 해당 experiment 에 대한 전용 그룹 페이지로 이동할 수 있습니다.

위의 프로젝트 페이지에서 왼쪽 사이드바의 Group 을 클릭하여 이 페이지와 같은 전용 페이지로 이동할 수 있습니다.

UI에서 동적으로 그룹화

예를 들어 하이퍼파라미터별로 열별로 Runs 를 그룹화할 수 있습니다. 다음은 그 모양의 예입니다.

• 사이드바: Runs 는 에포크 수별로 그룹화됩니다.
• 그래프: 각 선은 그룹의 평균을 나타내고 음영은 분산을 나타냅니다. 이 동작은 그래프 설정에서 변경할 수 있습니다.

그룹화 끄기

언제든지 그룹화 버튼을 클릭하고 그룹 필드를 지우면 테이블과 그래프가 그룹 해제된 상태로 돌아갑니다.

그룹화 그래프 설정

그래프 오른쪽 상단 모서리에 있는 편집 버튼을 클릭하고 Advanced 탭을 선택하여 선과 음영을 변경합니다. 각 그룹에서 선의 평균, 최소값 또는 최대값을 선택할 수 있습니다. 음영의 경우 음영을 끄고 최소값과 최대값, 표준 편차 및 표준 오차를 표시할 수 있습니다.

5.5 - Move runs

이 페이지에서는 run 을 한 프로젝트에서 다른 프로젝트로, 팀 내부 또는 외부로, 또는 한 팀에서 다른 팀으로 이동하는 방법을 보여줍니다. 현재 위치와 새 위치에서 run 에 대한 엑세스 권한이 있어야 합니다.

Runs 탭을 사용자 정의하려면 Project page를 참조하세요.

프로젝트 간에 run 이동

run 을 한 프로젝트에서 다른 프로젝트로 이동하려면 다음을 수행합니다.

1. 이동하려는 run 이 포함된 프로젝트로 이동합니다.
2. 프로젝트 사이드바에서 Runs 탭을 선택합니다.
3. 이동하려는 run 옆에 있는 확인란을 선택합니다.
4. 테이블 위의 Move 버튼을 선택합니다.
5. 드롭다운에서 대상 프로젝트를 선택합니다.

팀으로 run 이동

자신이 멤버인 팀으로 run 을 이동합니다.

1. 이동하려는 run 이 포함된 프로젝트로 이동합니다.
2. 프로젝트 사이드바에서 Runs 탭을 선택합니다.
3. 이동하려는 run 옆에 있는 확인란을 선택합니다.
4. 테이블 위의 Move 버튼을 선택합니다.
5. 드롭다운에서 대상 팀 및 프로젝트를 선택합니다.

5.6 - Resume a run

run이 중지되거나 충돌할 경우 run이 어떻게 작동해야 하는지 지정합니다. run을 재개하거나 자동으로 재개하도록 설정하려면 id 파라미터에 대해 해당 run과 연결된 고유한 run ID를 지정해야 합니다.

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="<resume>")

다음 인수 중 하나를 resume 파라미터에 전달하여 W&B가 어떻게 응답해야 하는지 결정합니다. 각 경우에 대해 W&B는 먼저 run ID가 이미 존재하는지 확인합니다.

resume="auto"를 지정하여 W&B가 자동으로 사용자를 대신하여 run을 다시 시작하도록 할 수도 있습니다. 그러나 동일한 디렉토리에서 run을 다시 시작해야 합니다. 자세한 내용은 자동으로 run을 재개하도록 설정 섹션을 참조하세요.

아래의 모든 예제에서는 <>로 묶인 값을 사용자 고유의 값으로 바꿉니다.

동일한 Run ID를 사용해야 하는 Run 재개

run이 중지되거나, 충돌하거나, 실패하는 경우 동일한 run ID를 사용하여 재개할 수 있습니다. 이렇게 하려면 run을 초기화하고 다음을 지정합니다.

• resume 파라미터를 "must"(resume="must")로 설정합니다.
• 중지되거나 충돌한 run의 run ID를 제공합니다.

다음 코드조각은 W&B Python SDK를 사용하여 이를 수행하는 방법을 보여줍니다.

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="must")

기존 Run을 덮어쓰지 않고 Run 재개

기존 run을 덮어쓰지 않고 중지되거나 충돌한 run을 재개합니다. 이는 프로세스가 성공적으로 종료되지 않는 경우에 특히 유용합니다. 다음에 W&B를 시작하면 W&B는 마지막 단계부터 로깅을 시작합니다.

W&B로 run을 초기화할 때 resume 파라미터를 "allow"(resume="allow")로 설정합니다. 중지되거나 충돌한 run의 run ID를 제공합니다. 다음 코드조각은 W&B Python SDK를 사용하여 이를 수행하는 방법을 보여줍니다.

import wandb

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="allow")

Run이 자동으로 재개되도록 설정

다음 코드조각은 Python SDK 또는 환경 변수를 사용하여 run이 자동으로 재개되도록 설정하는 방법을 보여줍니다.

• W&B Python SDK
• Shell script

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="<resume>")

RUN_ID="$1"

WANDB_RESUME=allow WANDB_RUN_ID="$RUN_ID" python eval.py

sh run_experiment.sh akj172 

예를 들어 Users/AwesomeEmployee/Desktop/ImageClassify/training/이라는 디렉토리에서 train.py라는 python 스크립트를 실행한다고 가정합니다. train.py 내에서 스크립트는 자동 재개를 활성화하는 run을 만듭니다. 다음으로 트레이닝 스크립트가 중지되었다고 가정합니다. 이 run을 재개하려면 Users/AwesomeEmployee/Desktop/ImageClassify/training/ 내에서 train.py 스크립트를 다시 시작해야 합니다.

Preemptible Sweeps Run 재개

중단된 sweep run을 자동으로 다시 큐에 넣습니다. 이는 선점형 큐의 SLURM 작업, EC2 스팟 인스턴스 또는 Google Cloud 선점형 VM과 같이 선점이 적용되는 컴퓨팅 환경에서 sweep agent를 실행하는 경우에 특히 유용합니다.

mark_preempting 함수를 사용하여 W&B가 중단된 sweep run을 자동으로 다시 큐에 넣도록 설정합니다. 예를 들어, 다음 코드조각을 참조하세요.

run = wandb.init()  # Run 초기화
run.mark_preempting()

다음 표는 sweep run의 종료 상태에 따라 W&B가 run을 처리하는 방법을 간략하게 설명합니다.

5.7 - Rewind a run

run 되감기

원본 데이터를 잃지 않고 run 기록을 수정하거나 변경하려면 run을 되감으십시오. 또한 run을 되감을 때 해당 시점부터 새로운 데이터를 로그할 수 있습니다. W&B는 새롭게 기록된 기록을 기반으로 되감은 run에 대한 요약 메트릭을 다시 계산합니다. 이는 다음 동작을 의미합니다.

• 기록 잘림: W&B는 기록을 되감기 시점까지 자르므로 새로운 데이터 로깅이 가능합니다.
• 요약 메트릭: 새롭게 기록된 기록을 기반으로 다시 계산됩니다.
• 설정 보존: W&B는 원래 설정을 보존하고 새로운 설정을 병합할 수 있습니다.

run을 되감을 때 W&B는 원래 데이터를 보존하고 일관된 run ID를 유지하면서 run 상태를 지정된 단계로 재설정합니다. 이는 다음을 의미합니다.

• run 보관: W&B는 원래 run을 보관합니다. Run Overview 탭에서 run에 엑세스할 수 있습니다.
• 아티팩트 연결: 아티팩트를 해당 아티팩트를 생성하는 run과 연결합니다.
• 변경 불가능한 run ID: 정확한 상태에서 일관된 포크를 위해 도입되었습니다.
• 변경 불가능한 run ID 복사: 향상된 run 관리를 위해 변경 불가능한 run ID를 복사하는 버튼입니다.

run 되감기

resume_from과 함께 wandb.init()을 사용하여 run 기록을 특정 단계로 “되감습니다”. 되감을 run의 이름과 되감을 단계를 지정합니다.

import wandb
import math

# 첫 번째 run을 초기화하고 일부 메트릭을 기록합니다.
# your_project_name 및 your_entity_name으로 대체하십시오!
run1 = wandb.init(project="your_project_name", entity="your_entity_name")
for i in range(300):
    run1.log({"metric": i})
run1.finish()

# 특정 단계에서 첫 번째 run부터 되감고 200단계부터 메트릭을 기록합니다.
run2 = wandb.init(project="your_project_name", entity="your_entity_name", resume_from=f"{run1.id}?_step=200")

# 새로운 run에서 계속 기록합니다.
# 처음 몇 단계에서는 run1에서 메트릭을 그대로 기록합니다.
# 250단계 이후에는 스파이크 패턴을 기록하기 시작합니다.
for i in range(200, 300):
    if i < 250:
        run2.log({"metric": i, "step": i})  # 스파이크 없이 run1부터 계속 기록합니다.
    else:
        # 250단계부터 스파이크 동작을 도입합니다.
        subtle_spike = i + (2 * math.sin(i / 3.0))  # 미묘한 스파이크 패턴을 적용합니다.
        run2.log({"metric": subtle_spike, "step": i})
    # 또한 모든 단계에서 새로운 메트릭을 기록합니다.
    run2.log({"additional_metric": i * 1.1, "step": i})
run2.finish()

보관된 run 보기

run을 되감은 후 W&B App UI를 사용하여 보관된 run을 탐색할 수 있습니다. 보관된 run을 보려면 다음 단계를 따르십시오.

1. Overview 탭에 엑세스: run 페이지의 Overview 탭으로 이동합니다. 이 탭은 run의 세부 정보 및 기록에 대한 포괄적인 보기를 제공합니다.
2. Forked From 필드 찾기: Overview 탭 내에서 Forked From 필드를 찾습니다. 이 필드는 재개 기록을 캡처합니다. Forked From 필드에는 소스 run에 대한 링크가 포함되어 있어 원래 run으로 다시 추적하고 전체 되감기 기록을 이해할 수 있습니다.

Forked From 필드를 사용하면 보관된 재개 트리를 쉽게 탐색하고 각 되감기의 순서와 출처에 대한 통찰력을 얻을 수 있습니다.

되감은 run에서 포크

되감은 run에서 포크하려면 wandb.init()에서 fork_from 인수를 사용하고 포크할 소스 run ID와 소스 run의 단계를 지정합니다.

import wandb

# 특정 단계에서 run을 포크합니다.
forked_run = wandb.init(
    project="your_project_name",
    entity="your_entity_name",
    fork_from=f"{rewind_run.id}?_step=500",
)

# 새로운 run에서 계속 기록합니다.
for i in range(500, 1000):
    forked_run.log({"metric": i*3})
forked_run.finish()

5.8 - Send an alert

run 이 충돌하거나 사용자 정의 트리거를 사용하는 경우 Slack 또는 이메일로 알림을 생성합니다. 예를 들어, 트레이닝 루프의 그레이디언트가 폭발하기 시작하거나 (NaN을 reports) ML 파이프라인의 단계가 완료되면 알림을 생성할 수 있습니다. 알림은 개인 및 팀 프로젝트를 포함하여 run을 초기화하는 모든 프로젝트에 적용됩니다.

그런 다음 Slack (또는 이메일)에서 W&B Alerts 메시지를 확인합니다:

알림 생성 방법

알림을 설정하는 주요 단계는 두 가지입니다:

1. W&B 사용자 설정에서 Alerts 켜기
2. 코드에 run.alert() 추가
3. 알림이 올바르게 설정되었는지 확인

1. W&B 사용자 설정에서 알림 켜기

사용자 설정에서:

• Alerts 섹션으로 스크롤
• run.alert()에서 알림을 받으려면 스크립트 가능한 run 알림을 켭니다.
• Slack 연결을 사용하여 알림을 게시할 Slack 채널을 선택합니다. 알림을 비공개로 유지하므로 Slackbot 채널을 권장합니다.
• 이메일은 W&B에 가입할 때 사용한 이메일 주소로 전송됩니다. 이러한 모든 알림이 폴더로 이동하여 받은 편지함을 채우지 않도록 이메일에서 필터를 설정하는 것이 좋습니다.

W&B Alerts를 처음 설정하거나 알림 수신 방법을 수정하려는 경우에만 이 작업을 수행하면 됩니다.

2. 코드에 run.alert() 추가

알림을 트리거하려는 위치에서 코드 (노트북 또는 Python 스크립트)에 run.alert()를 추가합니다.

import wandb

run = wandb.init()
run.alert(title="High Loss", text="Loss is increasing rapidly")

3. Slack 또는 이메일 확인

Slack 또는 이메일에서 알림 메시지를 확인합니다. 아무것도 받지 못한 경우 사용자 설정에서 스크립트 가능한 알림에 대해 이메일 또는 Slack이 켜져 있는지 확인하십시오.

예시

이 간단한 알림은 정확도가 임계값 아래로 떨어지면 경고를 보냅니다. 이 예에서는 최소 5분 간격으로 알림을 보냅니다.

import wandb
from wandb import AlertLevel

run = wandb.init()

if acc < threshold:
    run.alert(
        title="Low accuracy",
        text=f"Accuracy {acc} is below the acceptable threshold {threshold}",
        level=AlertLevel.WARN,
        wait_duration=300,
    )

사용자 태그 또는 멘션 방법

알림 제목 또는 텍스트에서 자신 또는 동료를 태그하려면 at 기호 @ 다음에 Slack 사용자 ID를 사용하십시오. Slack 프로필 페이지에서 Slack 사용자 ID를 찾을 수 있습니다.

run.alert(title="Loss is NaN", text=f"Hey <@U1234ABCD> loss has gone to NaN")

팀 알림

팀 관리자는 팀 설정 페이지 wandb.ai/teams/your-team에서 팀에 대한 알림을 설정할 수 있습니다.

팀 알림은 팀의 모든 사용자에게 적용됩니다. W&B는 알림을 비공개로 유지하므로 Slackbot 채널을 사용하는 것이 좋습니다.

알림을 보낼 Slack 채널 변경

알림을 보낼 채널을 변경하려면 Slack 연결 끊기를 클릭한 다음 다시 연결합니다. 다시 연결한 후 다른 Slack 채널을 선택합니다.

6 - Log objects and media

W&B Python SDK를 사용하여 메트릭, 미디어 또는 사용자 정의 오브젝트의 사전을 단계별로 기록합니다. W&B는 각 단계에서 키-값 쌍을 수집하고 wandb.log()로 데이터를 기록할 때마다 하나의 통합된 사전에 저장합니다. 스크립트에서 기록된 데이터는 wandb라는 디렉토리에 로컬로 저장된 다음 W&B 클라우드 또는 개인 서버로 동기화됩니다.

wandb.log를 호출할 때마다 기본적으로 새로운 step이 됩니다. W&B는 차트 및 패널을 만들 때 단계를 기본 x축으로 사용합니다. 선택적으로 사용자 정의 x축을 만들고 사용하거나 사용자 정의 요약 메트릭을 캡처할 수 있습니다. 자세한 내용은 로그 축 사용자 정의를 참조하세요.

자동으로 기록되는 데이터

W&B는 W&B Experiments 동안 다음 정보를 자동으로 기록합니다.

• 시스템 메트릭: CPU 및 GPU 사용률, 네트워크 등. 이러한 메트릭은 run 페이지의 시스템 탭에 표시됩니다. GPU의 경우 이러한 메트릭은 nvidia-smi를 통해 가져옵니다.
• 커맨드 라인: stdout 및 stderr이 선택되어 run 페이지의 로그 탭에 표시됩니다.

계정의 설정 페이지에서 코드 저장을 켜서 다음을 기록합니다.

• Git 커밋: 최신 git 커밋을 선택하여 run 페이지의 Overview 탭에서 확인하고 커밋되지 않은 변경 사항이 있는 경우 diff.patch 파일을 확인합니다.
• Dependencies: requirements.txt 파일이 업로드되어 run 페이지의 파일 탭에 표시되고, run을 위해 wandb 디렉터리에 저장하는 모든 파일과 함께 표시됩니다.

특정 W&B API 호출로 기록되는 데이터는 무엇입니까?

W&B를 사용하면 기록할 대상을 정확하게 결정할 수 있습니다. 다음은 일반적으로 기록되는 오브젝트의 일부입니다.

• Datasets: 이미지를 W&B로 스트리밍하려면 이미지 또는 기타 데이터셋 샘플을 구체적으로 기록해야 합니다.
• Plots: 차트를 추적하려면 wandb.plot을 wandb.log와 함께 사용합니다. 자세한 내용은 Plots 기록을 참조하세요.
• Tables: W&B로 시각화하고 쿼리할 데이터를 기록하려면 wandb.Table을 사용합니다. 자세한 내용은 Tables 기록을 참조하세요.
• PyTorch 그레이디언트: UI에서 가중치의 그레이디언트를 히스토그램으로 보려면 wandb.watch(model)을 추가합니다.
• 설정 정보: 하이퍼파라미터, 데이터셋 링크 또는 사용 중인 아키텍처 이름을 config 파라미터로 기록합니다. 예: wandb.init(config=your_config_dictionary). 자세한 내용은 PyTorch 인테그레이션 페이지를 참조하세요.
• 메트릭: 모델의 메트릭을 보려면 wandb.log를 사용합니다. 트레이닝 루프 내에서 정확도 및 손실과 같은 메트릭을 기록하면 UI에서 실시간 업데이트 그래프를 얻을 수 있습니다.

일반적인 워크플로우

1. 최고 정확도 비교: run 간에 메트릭의 최고 값을 비교하려면 해당 메트릭의 요약 값을 설정합니다. 기본적으로 요약은 각 키에 대해 기록한 마지막 값으로 설정됩니다. 이는 UI의 테이블에서 유용합니다. 여기서 요약 메트릭을 기준으로 run을 정렬하고 필터링하여 최종 정확도가 아닌 최고 정확도를 기준으로 테이블 또는 막대 차트에서 run을 비교할 수 있습니다. 예: wandb.run.summary["best_accuracy"] = best_accuracy
2. 하나의 차트에 여러 메트릭 보기: wandb.log({"acc'": 0.9, "loss": 0.1})과 같이 wandb.log에 대한 동일한 호출에서 여러 메트릭을 기록하면 UI에서 플롯하는 데 사용할 수 있습니다.
3. x축 사용자 정의: 동일한 로그 호출에 사용자 정의 x축을 추가하여 W&B 대시보드에서 다른 축에 대해 메트릭을 시각화합니다. 예: wandb.log({'acc': 0.9, 'epoch': 3, 'batch': 117}). 지정된 메트릭에 대한 기본 x축을 설정하려면 Run.define_metric()을 사용합니다.
4. 풍부한 미디어 및 차트 기록: wandb.log는 이미지 및 비디오와 같은 미디어에서 테이블 및 차트에 이르기까지 다양한 데이터 유형의 로깅을 지원합니다.

모범 사례 및 팁

Experiments 및 로깅에 대한 모범 사례 및 팁은 모범 사례: Experiments 및 로깅을 참조하세요.

6.1 - Create and track plots from experiments

wandb.plot의 메소드를 사용하면 트레이닝 중 시간에 따라 변하는 차트를 포함하여 wandb.log로 차트를 추적할 수 있습니다. 사용자 정의 차트 프레임워크에 대해 자세히 알아보려면 이 가이드를 확인하십시오.

기본 차트

이러한 간단한 차트를 사용하면 메트릭 및 결과의 기본 시각화를 쉽게 구성할 수 있습니다.

• Line
• Scatter
• Bar
• Histogram
• Multi-line

wandb.plot.line()

임의의 축에서 연결되고 정렬된 점 목록인 사용자 정의 라인 플롯을 기록합니다.

data = [[x, y] for (x, y) in zip(x_values, y_values)]
table = wandb.Table(data=data, columns=["x", "y"])
wandb.log(
    {
        "my_custom_plot_id": wandb.plot.line(
            table, "x", "y", title="Custom Y vs X Line Plot"
        )
    }
)

이를 사용하여 임의의 두 차원에 대한 곡선을 기록할 수 있습니다. 두 값 목록을 서로 플로팅하는 경우 목록의 값 수는 정확히 일치해야 합니다. 예를 들어 각 점에는 x와 y가 있어야 합니다.

앱에서 보기

코드 실행

wandb.plot.scatter()

임의의 축 x 및 y 쌍에 대한 점 (x, y) 목록인 사용자 정의 스캐터 플롯을 기록합니다.

data = [[x, y] for (x, y) in zip(class_x_scores, class_y_scores)]
table = wandb.Table(data=data, columns=["class_x", "class_y"])
wandb.log({"my_custom_id": wandb.plot.scatter(table, "class_x", "class_y")})

이를 사용하여 임의의 두 차원에 대한 스캐터 점을 기록할 수 있습니다. 두 값 목록을 서로 플로팅하는 경우 목록의 값 수는 정확히 일치해야 합니다. 예를 들어 각 점에는 x와 y가 있어야 합니다.

앱에서 보기

코드 실행

wandb.plot.bar()

몇 줄의 코드로 레이블이 지정된 값 목록을 막대로 표시하는 사용자 정의 막대 차트를 기본적으로 기록합니다.

data = [[label, val] for (label, val) in zip(labels, values)]
table = wandb.Table(data=data, columns=["label", "value"])
wandb.log(
    {
        "my_bar_chart_id": wandb.plot.bar(
            table, "label", "value", title="Custom Bar Chart"
        )
    }
)

이를 사용하여 임의의 막대 차트를 기록할 수 있습니다. 목록의 레이블과 값 수는 정확히 일치해야 합니다. 각 데이터 포인트에는 레이블과 값이 모두 있어야 합니다.

앱에서 보기

코드 실행

wandb.plot.histogram()

몇 줄의 코드로 값 목록을 발생 횟수/빈도별로 bin으로 정렬하는 사용자 정의 히스토그램을 기본적으로 기록합니다. 예측 신뢰도 점수 목록 (scores)이 있고 분포를 시각화하고 싶다고 가정해 보겠습니다.

data = [[s] for s in scores]
table = wandb.Table(data=data, columns=["scores"])
wandb.log({"my_histogram": wandb.plot.histogram(table, "scores", title="Histogram")})

이를 사용하여 임의의 히스토그램을 기록할 수 있습니다. data는 행과 열의 2D 배열을 지원하기 위한 목록의 목록입니다.

앱에서 보기

코드 실행

wandb.plot.line_series()

하나의 공유된 x-y 축 집합에 여러 라인 또는 여러 x-y 좌표 쌍 목록을 플로팅합니다.

wandb.log(
    {
        "my_custom_id": wandb.plot.line_series(
            xs=[0, 1, 2, 3, 4],
            ys=[[10, 20, 30, 40, 50], [0.5, 11, 72, 3, 41]],
            keys=["metric Y", "metric Z"],
            title="Two Random Metrics",
            xname="x units",
        )
    }
)

x 및 y 점의 수는 정확히 일치해야 합니다. y 값의 여러 목록과 일치시키기 위해 x 값 목록 하나를 제공하거나 y 값의 각 목록에 대해 별도의 x 값 목록을 제공할 수 있습니다.

앱에서 보기

모델 평가 차트

이러한 사전 설정 차트에는 스크립트에서 직접 차트를 빠르게 쉽게 기록하고 UI에서 찾고 있는 정확한 정보를 볼 수 있도록 하는 기본 제공 wandb.plot 메소드가 있습니다.

• Precision-recall curves
• ROC curves
• Confusion matrix

wandb.plot.pr_curve()

한 줄로 Precision-Recall curve를 만듭니다.

wandb.log({"pr": wandb.plot.pr_curve(ground_truth, predictions)})

코드가 다음에 엑세스할 수 있을 때마다 이를 기록할 수 있습니다.

• 예제 집합에 대한 모델의 예측 점수 (predictions)
• 해당 예제에 대한 해당 그라운드 트루스 레이블 (ground_truth)
• (선택 사항) 레이블/클래스 이름 목록 (labels=["cat", "dog", "bird"...] 레이블 인덱스 0이 cat, 1 = dog, 2 = bird 등을 의미하는 경우)
• (선택 사항) 플롯에서 시각화할 레이블의 서브셋 (여전히 목록 형식)

앱에서 보기

코드 실행

wandb.plot.roc_curve()

한 줄로 ROC curve를 만듭니다.

wandb.log({"roc": wandb.plot.roc_curve(ground_truth, predictions)})

코드가 다음에 엑세스할 수 있을 때마다 이를 기록할 수 있습니다.

• 예제 집합에 대한 모델의 예측 점수 (predictions)
• 해당 예제에 대한 해당 그라운드 트루스 레이블 (ground_truth)
• (선택 사항) 레이블/클래스 이름 목록 (labels=["cat", "dog", "bird"...] 레이블 인덱스 0이 cat, 1 = dog, 2 = bird 등을 의미하는 경우)
• (선택 사항) 플롯에서 시각화할 이러한 레이블의 서브셋 (여전히 목록 형식)

앱에서 보기

코드 실행

wandb.plot.confusion_matrix()

한 줄로 다중 클래스 confusion matrix를 만듭니다.

cm = wandb.plot.confusion_matrix(
    y_true=ground_truth, preds=predictions, class_names=class_names
)

wandb.log({"conf_mat": cm})

코드가 다음에 엑세스할 수 있을 때마다 이를 기록할 수 있습니다.

• 예제 집합에 대한 모델의 예측 레이블 (preds) 또는 정규화된 확률 점수 (probs). 확률은 (예제 수, 클래스 수) 모양이어야 합니다. 확률 또는 예측값 중 하나를 제공할 수 있지만 둘 다 제공할 수는 없습니다.
• 해당 예제에 대한 해당 그라운드 트루스 레이블 (y_true)
• class_names 문자열로 된 레이블/클래스 이름의 전체 목록. 예: class_names=["cat", "dog", "bird"] 인덱스 0이 cat, 1이 dog, 2가 bird인 경우

앱에서 보기

코드 실행

인터랙티브 사용자 정의 차트

전체 사용자 정의를 위해 기본 제공 사용자 정의 차트 사전 설정을 조정하거나 새 사전 설정을 만든 다음 차트를 저장합니다. 차트 ID를 사용하여 스크립트에서 직접 해당 사용자 정의 사전 설정에 데이터를 기록합니다.

# 플로팅할 열이 있는 테이블을 만듭니다.
table = wandb.Table(data=data, columns=["step", "height"])

# 테이블의 열에서 차트의 필드로 매핑합니다.
fields = {"x": "step", "value": "height"}

# 테이블을 사용하여 새 사용자 정의 차트 사전 설정을 채웁니다.
# 자신의 저장된 차트 사전 설정을 사용하려면 vega_spec_name을 변경하십시오.
# 제목을 편집하려면 string_fields를 변경하십시오.
my_custom_chart = wandb.plot_table(
    vega_spec_name="carey/new_chart",
    data_table=table,
    fields=fields,
    string_fields={"title": "Height Histogram"},
)

코드 실행

Matplotlib 및 Plotly 플롯

wandb.plot으로 W&B 사용자 정의 차트를 사용하는 대신 matplotlib 및 Plotly로 생성된 차트를 기록할 수 있습니다.

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4])
plt.ylabel("some interesting numbers")
wandb.log({"chart": plt})

matplotlib 플롯 또는 그림 오브젝트를 wandb.log()에 전달하기만 하면 됩니다. 기본적으로 플롯을 Plotly 플롯으로 변환합니다. 플롯을 이미지로 기록하려면 플롯을 wandb.Image에 전달할 수 있습니다. Plotly 차트도 직접 허용합니다.

W&B Tables에 사용자 정의 HTML 로그

W&B는 Plotly 및 Bokeh의 인터랙티브 차트를 HTML로 기록하고 이를 Tables에 추가하는 것을 지원합니다.

Plotly 그림을 HTML로 Tables에 로그

HTML로 변환하여 인터랙티브 Plotly 차트를 wandb Tables에 기록할 수 있습니다.

import wandb
import plotly.express as px

# 새 run 초기화
run = wandb.init(project="log-plotly-fig-tables", name="plotly_html")

# 테이블 만들기
table = wandb.Table(columns=["plotly_figure"])

# Plotly 그림에 대한 경로 만들기
path_to_plotly_html = "./plotly_figure.html"

# Plotly 그림 예제
fig = px.scatter(x=[0, 1, 2, 3, 4], y=[0, 1, 4, 9, 16])

# Plotly 그림을 HTML에 쓰기
# auto_play를 False로 설정하면 테이블에서 애니메이션 Plotly 차트가 자동으로 재생되지 않습니다.
fig.write_html(path_to_plotly_html, auto_play=False)

# Plotly 그림을 HTML 파일로 테이블에 추가
table.add_data(wandb.Html(path_to_plotly_html))

# 테이블 로그
run.log({"test_table": table})
wandb.finish()

Bokeh 그림을 HTML로 Tables에 로그

HTML로 변환하여 인터랙티브 Bokeh 차트를 wandb Tables에 기록할 수 있습니다.

from scipy.signal import spectrogram
import holoviews as hv
import panel as pn
from scipy.io import wavfile
import numpy as np
from bokeh.resources import INLINE

hv.extension("bokeh", logo=False)
import wandb


def save_audio_with_bokeh_plot_to_html(audio_path, html_file_name):
    sr, wav_data = wavfile.read(audio_path)
    duration = len(wav_data) / sr
    f, t, sxx = spectrogram(wav_data, sr)
    spec_gram = hv.Image((t, f, np.log10(sxx)), ["Time (s)", "Frequency (hz)"]).opts(
        width=500, height=150, labelled=[]
    )
    audio = pn.pane.Audio(wav_data, sample_rate=sr, name="Audio", throttle=500)
    slider = pn.widgets.FloatSlider(end=duration, visible=False)
    line = hv.VLine(0).opts(color="white")
    slider.jslink(audio, value="time", bidirectional=True)
    slider.jslink(line, value="glyph.location")
    combined = pn.Row(audio, spec_gram * line, slider).save(html_file_name)


html_file_name = "audio_with_plot.html"
audio_path = "hello.wav"
save_audio_with_bokeh_plot_to_html(audio_path, html_file_name)

wandb_html = wandb.Html(html_file_name)
run = wandb.init(project="audio_test")
my_table = wandb.Table(columns=["audio_with_plot"], data=[[wandb_html], [wandb_html]])
run.log({"audio_table": my_table})
run.finish()

6.2 - Customize log axes

define_metric을 사용하여 사용자 정의 x축을 설정하세요. 사용자 정의 x축은 트레이닝 중 과거의 다른 타임 스텝에 비동기적으로 로그해야 하는 상황에서 유용합니다. 예를 들어, 에피소드별 보상과 스텝별 보상을 추적할 수 있는 RL에서 유용할 수 있습니다.

Google Colab에서 define_metric을 직접 사용해 보세요 →

축 사용자 정의

기본적으로 모든 메트릭은 W&B 내부 step인 동일한 x축에 대해 기록됩니다. 때로는 이전 스텝에 로그하거나 다른 x축을 사용하고 싶을 수 있습니다.

다음은 기본 스텝 대신 사용자 정의 x축 메트릭을 설정하는 예입니다.

import wandb

wandb.init()
# 사용자 정의 x축 메트릭 정의
wandb.define_metric("custom_step")
# 어떤 메트릭을 기준으로 플롯할지 정의
wandb.define_metric("validation_loss", step_metric="custom_step")

for i in range(10):
    log_dict = {
        "train_loss": 1 / (i + 1),
        "custom_step": i**2,
        "validation_loss": 1 / (i + 1),
    }
    wandb.log(log_dict)

x축은 glob을 사용하여 설정할 수도 있습니다. 현재 문자열 접두사가 있는 glob만 사용할 수 있습니다. 다음 예제는 접두사 "train/"가 있는 기록된 모든 메트릭을 x축 "train/step"에 플롯합니다.

import wandb

wandb.init()
# 사용자 정의 x축 메트릭 정의
wandb.define_metric("train/step")
# 다른 모든 train/ 메트릭이 이 스텝을 사용하도록 설정
wandb.define_metric("train/*", step_metric="train/step")

for i in range(10):
    log_dict = {
        "train/step": 2**i,  # 내부 W&B 스텝으로 지수적 증가
        "train/loss": 1 / (i + 1),  # x축은 train/step
        "train/accuracy": 1 - (1 / (1 + i)),  # x축은 train/step
        "val/loss": 1 / (1 + i),  # x축은 내부 wandb step
    }
    wandb.log(log_dict)

6.3 - Log distributed training experiments

분산 트레이닝에서 모델은 여러 개의 GPU를 병렬로 사용하여 트레이닝됩니다. W&B는 분산 트레이닝 Experiments를 추적하는 두 가지 패턴을 지원합니다.

1. 단일 프로세스: 단일 프로세스에서 W&B (wandb.init)를 초기화하고 Experiments (wandb.log)를 기록합니다. 이는 PyTorch Distributed Data Parallel (DDP) 클래스를 사용하여 분산 트레이닝 Experiments를 로깅하는 일반적인 솔루션입니다. 경우에 따라 사용자는 멀티프로세싱 대기열(또는 다른 통신 기본 요소)을 사용하여 다른 프로세스의 데이터를 기본 로깅 프로세스로 전달합니다.
2. 다중 프로세스: 모든 프로세스에서 W&B (wandb.init)를 초기화하고 Experiments (wandb.log)를 기록합니다. 각 프로세스는 사실상 별도의 experiment입니다. W&B를 초기화할 때 group 파라미터(wandb.init(group='group-name'))를 사용하여 공유 experiment를 정의하고 기록된 값들을 W&B App UI에서 함께 그룹화합니다.

다음 예제는 단일 머신에서 2개의 GPU를 사용하는 PyTorch DDP를 통해 W&B로 메트릭을 추적하는 방법을 보여줍니다. PyTorch DDP(torch.nn의 DistributedDataParallel)는 분산 트레이닝을 위한 널리 사용되는 라이브러리입니다. 기본 원리는 모든 분산 트레이닝 설정에 적용되지만 구현 세부 사항은 다를 수 있습니다.

방법 1: 단일 프로세스

이 방법에서는 순위 0 프로세스만 추적합니다. 이 방법을 구현하려면 W&B(wandb.init)를 초기화하고, W&B Run을 시작하고, 순위 0 프로세스 내에서 메트릭(wandb.log)을 기록합니다. 이 방법은 간단하고 강력하지만 다른 프로세스의 모델 메트릭(예: 배치에서의 손실 값 또는 입력)을 기록하지 않습니다. 사용량 및 메모리와 같은 시스템 메트릭은 해당 정보가 모든 프로세스에서 사용 가능하므로 모든 GPU에 대해 계속 기록됩니다.

샘플 Python 스크립트(log-ddp.py) 내에서 순위가 0인지 확인합니다. 이를 구현하기 위해 먼저 torch.distributed.launch를 사용하여 여러 프로세스를 시작합니다. 다음으로 --local_rank 커맨드라인 인수로 순위를 확인합니다. 순위가 0으로 설정된 경우 train() 함수에서 조건부로 wandb 로깅을 설정합니다. Python 스크립트 내에서 다음 검사를 사용합니다.

if __name__ == "__main__":
    # Get args
    args = parse_args()

    if args.local_rank == 0:  # only on main process
        # Initialize wandb run
        run = wandb.init(
            entity=args.entity,
            project=args.project,
        )
        # Train model with DDP
        train(args, run)
    else:
        train(args)

W&B App UI를 탐색하여 단일 프로세스에서 추적된 메트릭의 예제 대시보드를 확인하세요. 대시보드는 두 GPU에 대해 추적된 온도 및 사용률과 같은 시스템 메트릭을 표시합니다.

그러나 에포크 및 배치 크기 함수로서의 손실 값은 단일 GPU에서만 기록되었습니다.

방법 2: 다중 프로세스

이 방법에서는 작업의 각 프로세스를 추적하여 각 프로세스에서 wandb.init() 및 wandb.log()를 호출합니다. 트레이닝이 끝나면 wandb.finish()를 호출하여 Run이 완료되었음을 표시하여 모든 프로세스가 올바르게 종료되도록 하는 것이 좋습니다.

이 방법을 사용하면 더 많은 정보를 로깅에 엑세스할 수 있습니다. 그러나 여러 개의 W&B Runs가 W&B App UI에 보고되는 점에 유의하세요. 여러 Experiments에서 W&B Runs를 추적하기 어려울 수 있습니다. 이를 완화하려면 W&B를 초기화할 때 group 파라미터에 값을 제공하여 지정된 experiment에 속하는 W&B Run을 추적하세요. Experiments에서 트레이닝 및 평가 W&B Runs를 추적하는 방법에 대한 자세한 내용은 Run 그룹화를 참조하세요.

다음 Python 코드 조각은 W&B를 초기화할 때 group 파라미터를 설정하는 방법을 보여줍니다.

if __name__ == "__main__":
    # Get args
    args = parse_args()
    # Initialize run
    run = wandb.init(
        entity=args.entity,
        project=args.project,
        group="DDP",  # all runs for the experiment in one group
    )
    # Train model with DDP
    train(args, run)

W&B App UI를 탐색하여 여러 프로세스에서 추적된 메트릭의 예제 대시보드를 확인하세요. 왼쪽 사이드바에 함께 그룹화된 두 개의 W&B Runs가 있습니다. 그룹을 클릭하여 experiment에 대한 전용 그룹 페이지를 확인하세요. 전용 그룹 페이지에는 각 프로세스의 메트릭이 개별적으로 표시됩니다.

앞의 이미지는 W&B App UI 대시보드를 보여줍니다. 사이드바에는 두 개의 Experiments가 있습니다. 하나는 ’null’로 레이블이 지정되고 다른 하나는 ‘DPP’(노란색 상자로 묶임)로 표시됩니다. 그룹을 확장하면(그룹 드롭다운 선택) 해당 experiment와 연결된 W&B Runs가 표시됩니다.

W&B Service를 사용하여 일반적인 분산 트레이닝 문제 방지

W&B 및 분산 트레이닝을 사용할 때 발생할 수 있는 두 가지 일반적인 문제가 있습니다.

1. 트레이닝 시작 시 중단 - wandb 멀티프로세싱이 분산 트레이닝의 멀티프로세싱을 방해하는 경우 wandb 프로세스가 중단될 수 있습니다.
2. 트레이닝 종료 시 중단 - wandb 프로세스가 종료해야 할 시점을 알지 못하는 경우 트레이닝 작업이 중단될 수 있습니다. Python 스크립트의 끝에서 wandb.finish() API를 호출하여 W&B에 Run이 완료되었음을 알립니다. wandb.finish() API는 데이터 업로드를 완료하고 W&B가 종료되도록 합니다.

wandb service를 사용하여 분산 작업의 안정성을 개선하는 것이 좋습니다. 앞서 언급한 두 가지 트레이닝 문제는 일반적으로 wandb service를 사용할 수 없는 W&B SDK 버전에서 발견됩니다.

W&B Service 활성화

W&B SDK 버전에 따라 W&B Service가 기본적으로 활성화되어 있을 수 있습니다.

W&B SDK 0.13.0 이상

W&B Service는 W&B SDK 0.13.0 버전 이상에서 기본적으로 활성화되어 있습니다.

W&B SDK 0.12.5 이상

Python 스크립트를 수정하여 W&B SDK 버전 0.12.5 이상에서 W&B Service를 활성화하세요. wandb.require 메소드를 사용하고 기본 함수 내에서 문자열 "service"를 전달하세요.

if __name__ == "__main__":
    main()


def main():
    wandb.require("service")
    # rest-of-your-script-goes-here

최적의 경험을 위해 최신 버전으로 업그레이드하는 것이 좋습니다.

W&B SDK 0.12.4 이하

W&B SDK 버전 0.12.4 이하를 사용하는 경우 WANDB_START_METHOD 환경 변수를 "thread"로 설정하여 대신 멀티스레딩을 사용하세요.

멀티프로세싱에 대한 예제 유스 케이스

다음 코드 조각은 고급 분산 유스 케이스에 대한 일반적인 방법을 보여줍니다.

프로세스 생성

생성된 프로세스에서 W&B Run을 시작하는 경우 기본 함수에서 wandb.setup() 메소드를 사용하세요.

import multiprocessing as mp


def do_work(n):
    run = wandb.init(config=dict(n=n))
    run.log(dict(this=n * n))


def main():
    wandb.setup()
    pool = mp.Pool(processes=4)
    pool.map(do_work, range(4))


if __name__ == "__main__":
    main()

W&B Run 공유

W&B Run 오브젝트를 인수로 전달하여 프로세스 간에 W&B Runs를 공유합니다.

def do_work(run):
    run.log(dict(this=1))


def main():
    run = wandb.init()
    p = mp.Process(target=do_work, kwargs=dict(run=run))
    p.start()
    p.join()


if __name__ == "__main__":
    main()

6.4 - Log media and objects

이미지, 비디오, 오디오 등을 지원합니다. 풍부한 미디어를 기록하여 결과물을 살펴보고 run, model, dataset을 시각적으로 비교해 보세요. 예시와 사용 가이드는 아래를 참고하세요.

사전 준비 사항

W&B SDK로 미디어 오브젝트를 기록하려면 추가 종속성을 설치해야 할 수 있습니다. 다음 코맨드를 실행하여 이러한 종속성을 설치할 수 있습니다.

pip install wandb[media]

이미지

이미지를 기록하여 입력, 출력, 필터 가중치, 활성화 등을 추적합니다.

이미지는 NumPy 배열, PIL 이미지 또는 파일 시스템에서 직접 기록할 수 있습니다.

단계별로 이미지를 기록할 때마다 UI에 표시되도록 저장됩니다. 이미지 패널을 확장하고 스텝 슬라이더를 사용하여 다른 스텝의 이미지를 확인합니다. 이렇게 하면 트레이닝 중에 모델의 출력이 어떻게 변하는지 쉽게 비교할 수 있습니다.

• 배열을 이미지로 로깅
• PIL 이미지 로깅
• 파일에서 이미지 로깅

images = wandb.Image(image_array, caption="Top: Output, Bottom: Input")

wandb.log({"examples": images})

images = [PIL.Image.fromarray(image) for image in image_array]

wandb.log({"examples": [wandb.Image(image) for image in images]})

im = PIL.fromarray(...)
rgb_im = im.convert("RGB")
rgb_im.save("myimage.jpg")

wandb.log({"example": wandb.Image("myimage.jpg")})

이미지 오버레이

• 시멘틱 세그멘테이션 마스크
• 바운딩 박스

W&B UI를 통해 시멘틱 세그멘테이션 마스크를 기록하고 (불투명도 변경, 시간 경과에 따른 변경 사항 보기 등) 상호 작용합니다.

오버레이를 기록하려면 다음 키와 값이 있는 사전을 wandb.Image의 masks 키워드 인수에 제공해야 합니다.

• 이미지 마스크를 나타내는 두 개의 키 중 하나:
  • "mask_data": 각 픽셀에 대한 정수 클래스 레이블을 포함하는 2D NumPy 배열
  • "path": (문자열) 저장된 이미지 마스크 파일의 경로
• "class_labels": (선택 사항) 이미지 마스크의 정수 클래스 레이블을 읽을 수 있는 클래스 이름에 매핑하는 사전

여러 마스크를 기록하려면 아래 코드조각과 같이 여러 키가 있는 마스크 사전을 기록합니다.

라이브 예시 보기

샘플 코드

mask_data = np.array([[1, 2, 2, ..., 2, 2, 1], ...])

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

mask_img = wandb.Image(
    image,
    masks={
        "predictions": {"mask_data": mask_data, "class_labels": class_labels},
        "ground_truth": {
            # ...
        },
        # ...
    },
)

이미지와 함께 바운딩 박스를 기록하고 필터와 토글을 사용하여 UI에서 다양한 박스 세트를 동적으로 시각화합니다.

라이브 예시 보기

바운딩 박스를 기록하려면 다음 키와 값이 있는 사전을 wandb.Image의 boxes 키워드 인수에 제공해야 합니다.

• box_data: 각 박스에 대해 하나씩, 사전의 리스트입니다. 박스 사전 형식은 아래에 설명되어 있습니다.
  • position: 아래에 설명된 두 가지 형식 중 하나로 박스의 위치와 크기를 나타내는 사전입니다. 박스가 모두 동일한 형식을 사용할 필요는 없습니다.
    • 옵션 1: {"minX", "maxX", "minY", "maxY"}. 각 박스 차원의 상한 및 하한을 정의하는 좌표 세트를 제공합니다.
    • 옵션 2: {"middle", "width", "height"}. middle 좌표를 [x,y]로 지정하고 width와 height를 스칼라로 지정하는 좌표 세트를 제공합니다.
  • class_id: 박스의 클래스 ID를 나타내는 정수입니다. 아래의 class_labels 키를 참조하세요.
  • scores: 점수에 대한 문자열 레이블과 숫자 값의 사전입니다. UI에서 박스를 필터링하는 데 사용할 수 있습니다.
  • domain: 박스 좌표의 단위/형식을 지정합니다. 박스 좌표가 이미지 크기 범위 내의 정수와 같이 픽셀 공간으로 표현되는 경우 “pixel"로 설정합니다. 기본적으로 도메인은 이미지의 분수/백분율로 간주되며 0과 1 사이의 부동 소수점 숫자로 표현됩니다.
  • box_caption: (선택 사항) 이 박스의 레이블 텍스트로 표시할 문자열입니다.
• class_labels: (선택 사항) class_id를 문자열에 매핑하는 사전입니다. 기본적으로 class_0, class_1 등 클래스 레이블을 생성합니다.

이 예시를 확인해 보세요.

class_id_to_label = {
    1: "car",
    2: "road",
    3: "building",
    # ...
}

img = wandb.Image(
    image,
    boxes={
        "predictions": {
            "box_data": [
                {
                    # one box expressed in the default relative/fractional domain
                    "position": {"minX": 0.1, "maxX": 0.2, "minY": 0.3, "maxY": 0.4},
                    "class_id": 2,
                    "box_caption": class_id_to_label[2],
                    "scores": {"acc": 0.1, "loss": 1.2},
                    # another box expressed in the pixel domain
                    # (for illustration purposes only, all boxes are likely
                    # to be in the same domain/format)
                    "position": {"middle": [150, 20], "width": 68, "height": 112},
                    "domain": "pixel",
                    "class_id": 3,
                    "box_caption": "a building",
                    "scores": {"acc": 0.5, "loss": 0.7},
                    # ...
                    # Log as many boxes an as needed
                }
            ],
            "class_labels": class_id_to_label,
        },
        # Log each meaningful group of boxes with a unique key name
        "ground_truth": {
            # ...
        },
    },
)

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

테이블의 이미지 오버레이

• 시멘틱 세그멘테이션 마스크
• 바운딩 박스

테이블에 시멘틱 세그멘테이션 마스크를 기록하려면 테이블의 각 행에 대해 wandb.Image 오브젝트를 제공해야 합니다.

아래 코드조각에 예시가 제공되어 있습니다.

table = wandb.Table(columns=["ID", "Image"])

for id, img, label in zip(ids, images, labels):
    mask_img = wandb.Image(
        img,
        masks={
            "prediction": {"mask_data": label, "class_labels": class_labels}
            # ...
        },
    )

    table.add_data(id, img)

wandb.log({"Table": table})

테이블에 바운딩 박스가 있는 이미지를 기록하려면 테이블의 각 행에 대해 wandb.Image 오브젝트를 제공해야 합니다.

아래 코드조각에 예시가 제공되어 있습니다.

table = wandb.Table(columns=["ID", "Image"])

for id, img, boxes in zip(ids, images, boxes_set):
    box_img = wandb.Image(
        img,
        boxes={
            "prediction": {
                "box_data": [
                    {
                        "position": {
                            "minX": box["minX"],
                            "minY": box["minY"],
                            "maxX": box["maxX"],
                            "maxY": box["maxY"],
                        },
                        "class_id": box["class_id"],
                        "box_caption": box["caption"],
                        "domain": "pixel",
                    }
                    for box in boxes
                ],
                "class_labels": class_labels,
            }
        },
    )

히스토그램

• 기본 히스토그램 로깅
• 유연한 히스토그램 로깅
• 요약의 히스토그램

리스트, 배열 또는 텐서와 같은 숫자 시퀀스가 첫 번째 인수로 제공되면 np.histogram을 호출하여 히스토그램이 자동으로 구성됩니다. 모든 배열/텐서는 평면화됩니다. 선택적 num_bins 키워드 인수를 사용하여 기본값인 64개 구간을 재정의할 수 있습니다. 지원되는 최대 구간 수는 512개입니다.

UI에서 히스토그램은 x축에 트레이닝 스텝, y축에 메트릭 값, 색상으로 표현되는 개수로 플롯되어 트레이닝 전반에 걸쳐 기록된 히스토그램을 쉽게 비교할 수 있습니다. 일회성 히스토그램 로깅에 대한 자세한 내용은 이 패널의 “요약의 히스토그램” 탭을 참조하세요.

wandb.log({"gradients": wandb.Histogram(grads)})

더 많은 제어를 원하면 np.histogram을 호출하고 반환된 튜플을 np_histogram 키워드 인수에 전달합니다.

np_hist_grads = np.histogram(grads, density=True, range=(0.0, 1.0))
wandb.log({"gradients": wandb.Histogram(np_hist_grads)})

wandb.run.summary.update(  # if only in summary, only visible on Overview 탭
    {"final_logits": wandb.Histogram(logits)}
)

'obj', 'gltf', 'glb', 'babylon', 'stl', 'pts.json' 형식으로 파일을 기록하면 run이 완료될 때 UI에서 렌더링됩니다.

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

라이브 예시 보기

히스토그램이 요약에 있으면 Run 페이지의 Overview 탭에 나타납니다. 히스토리가 있으면 차트 탭에서 시간 경과에 따른 구간의 히트맵이 플롯됩니다.

3D 시각화

point_cloud = np.array([[0, 0, 0, COLOR]])

wandb.log({"point_cloud": wandb.Object3D(point_cloud)})

point_list = [
    [
        2566.571924017235, # x
        746.7817289698219, # y
        -15.269245470863748,# z
        76.5, # red
        127.5, # green
        89.46617199365393 # blue
    ],
    [ 2566.592983606823, 746.6791987335685, -15.275803826279521, 76.5, 127.5, 89.45471117247024 ],
    [ 2566.616361739416, 746.4903185513501, -15.28628929674075, 76.5, 127.5, 89.41336375503832 ],
    [ 2561.706014951675, 744.5349468458361, -14.877496818222781, 76.5, 127.5, 82.21868245418283 ],
    [ 2561.5281847916694, 744.2546118233013, -14.867862032341005, 76.5, 127.5, 81.87824684536432 ],
    [ 2561.3693562897465, 744.1804761656741, -14.854129178142523, 76.5, 127.5, 81.64137897587152 ],
    [ 2561.6093071504515, 744.0287526628543, -14.882135189841177, 76.5, 127.5, 81.89871499537098 ],
    # ... and so on
]

run.log({"my_first_point_cloud": wandb.Object3D.from_point_cloud(
     points = point_list,
     boxes = [{
         "corners": [
                [ 2601.2765123137915, 767.5669506323393, -17.816764802288663 ],
                [ 2599.7259021588347, 769.0082337923552, -17.816764802288663 ],
                [ 2599.7259021588347, 769.0082337923552, -19.66876480228866 ],
                [ 2601.2765123137915, 767.5669506323393, -19.66876480228866 ],
                [ 2604.8684867834395, 771.4313904894723, -17.816764802288663 ],
                [ 2603.3178766284827, 772.8726736494882, -17.816764802288663 ],
                [ 2603.3178766284827, 772.8726736494882, -19.66876480228866 ],
                [ 2604.8684867834395, 771.4313904894723, -19.66876480228866 ]
        ],
         "color": [0, 0, 255], # 바운딩 박스의 RGB 색상
         "label": "car", # 바운딩 박스에 표시되는 문자열
         "score": 0.6 # 바운딩 박스에 표시되는 숫자
     }],
     vectors = [
        {"start": [0, 0, 0], "end": [0.1, 0.2, 0.5], "color": [255, 0, 0]}, # 색상은 선택 사항입니다.
     ],
     point_cloud_type = "lidar/beta",
)})

run.log({"my_cloud_from_file": wandb.Object3D.from_file(
     "./my_point_cloud.pts.json"
)})

{
    "boxes": [
        {
            "color": [
                0,
                255,
                0
            ],
            "score": 0.35,
            "label": "My label",
            "corners": [
                [
                    2589.695869075582,
                    760.7400443552185,
                    -18.044831294622487
                ],
                [
                    2590.719039645323,
                    762.3871153874499,
                    -18.044831294622487
                ],
                [
                    2590.719039645323,
                    762.3871153874499,
                    -19.54083129462249
                ],
                [
                    2589.695869075582,
                    760.7400443552185,
                    -19.54083129462249
                ],
                [
                    2594.9666662674313,
                    757.4657929961453,
                    -18.044831294622487
                ],
                [
                    2595.9898368371723,
                    759.1128640283766,
                    -18.044831294622487
                ],
                [
                    2595.9898368371723,
                    759.1128640283766,
                    -19.54083129462249
                ],
                [
                    2594.9666662674313,
                    757.4657929961453,
                    -19.54083129462249
                ]
            ]
        }
    ],
    "points": [
        [
            2566.571924017235,
            746.7817289698219,
            -15.269245470863748,
            76.5,
            127.5,
            89.46617199365393
        ],
        [
            2566.592983606823,
            746.6791987335685,
            -15.275803826279521,
            76.5,
            127.5,
            89.45471117247024
        ],
        [
            2566.616361739416,
            746.4903185513501,
            -15.28628929674075,
            76.5,
            127.5,
            89.41336375503832
        ]
    ],
    "type": "lidar/beta"
}

run.log({"my_cloud_from_numpy_xyz": wandb.Object3D.from_numpy(
     np.array(
        [
            [0.4, 1, 1.3], # x, y, z
            [1, 1, 1],
            [1.2, 1, 1.2]
        ]
    )
)})

run.log({"my_cloud_from_numpy_cat": wandb.Object3D.from_numpy(
     np.array(
        [
            [0.4, 1, 1.3, 1], # x, y, z, 카테고리
            [1, 1, 1, 1],
            [1.2, 1, 1.2, 12],
            [1.2, 1, 1.3, 12],
            [1.2, 1, 1.4, 12],
            [1.2, 1, 1.5, 12],
            [1.2, 1, 1.6, 11],
            [1.2, 1, 1.7, 11],
        ]
    )
)})

run.log({"my_cloud_from_numpy_rgb": wandb.Object3D.from_numpy(
     np.array(
        [
            [0.4, 1, 1.3, 255, 0, 0], # x, y, z, r, g, b
            [1, 1, 1, 0, 255, 0],
            [1.2, 1, 1.3, 0, 255, 255],
            [1.2, 1, 1.4, 0, 255, 255],
            [1.2, 1, 1.5, 0, 0, 255],
            [1.2, 1, 1.1, 0, 0, 255],
            [1.2, 1, 0.9, 0, 0, 255],
        ]
    )
)})

wandb.log({"protein": wandb.Molecule("6lu7.pdb")})

resveratrol = rdkit.Chem.MolFromSmiles("Oc1ccc(cc1)C=Cc1cc(O)cc(c1)O")

wandb.log(
    {
        "resveratrol": wandb.Molecule.from_rdkit(resveratrol),
        "green fluorescent protein": wandb.Molecule.from_rdkit("2b3p.mol"),
        "acetaminophen": wandb.Molecule.from_smiles("CC(=O)Nc1ccc(O)cc1"),
    }
)

wandb.log({"example": wandb.Image(...)})
# 또는 여러 이미지
wandb.log({"example": [wandb.Image(...) for img in images]})

wandb.log({"example": wandb.Video("myvideo.mp4")})

molecule = rdkit.Chem.MolFromSmiles("CC(=O)O")
rdkit.Chem.AllChem.Compute2DCoords(molecule)
rdkit.Chem.AllChem.GenerateDepictionMatching2DStructure(molecule, molecule)
pil_image = rdkit.Chem.Draw.MolToImage(molecule, size=(300, 300))

wandb.log({"acetic_acid": wandb.Image(pil_image)})

wandb.log({"whale songs": wandb.Audio(np_array, caption="OooOoo", sample_rate=32)})

wandb.log({"video": wandb.Video(numpy_array_or_path_to_video, fps=4, format="gif")})

columns = ["Text", "Predicted Sentiment", "True Sentiment"]
# Method 1
data = [["I love my phone", "1", "1"], ["My phone sucks", "0", "-1"]]
table = wandb.Table(data=data, columns=columns)
wandb.log({"examples": table})

# Method 2
table = wandb.Table(columns=columns)
table.add_data("I love my phone", "1", "1")
table.add_data("My phone sucks", "0", "-1")
wandb.log({"examples": table})

table = wandb.Table(dataframe=my_dataframe)

wandb.log({"custom_file": wandb.Html(open("some.html"))})
wandb.log({"custom_string": wandb.Html('<a href="https://mysite">Link</a>')})

wandb.log({"custom_file": wandb.Html(open("some.html"), inject=False)})

6.5 - Log models

모델 로깅

다음 가이드는 모델을 W&B run에 로깅하고 상호 작용하는 방법을 설명합니다.

모델을 run에 로깅

log_model을 사용하여 지정한 디렉토리 내에 콘텐츠가 포함된 모델 아티팩트를 로깅합니다. log_model 메서드는 결과 모델 아티팩트를 W&B run의 출력으로 표시합니다.

모델을 W&B run의 입력 또는 출력으로 표시하면 모델의 종속성과 모델의 연결을 추적할 수 있습니다. W&B App UI 내에서 모델의 계보를 확인하세요. 자세한 내용은 Artifacts 챕터의 아티팩트 그래프 탐색 및 트래버스 페이지를 참조하세요.

모델 파일이 저장된 경로를 path 파라미터에 제공하세요. 경로는 로컬 파일, 디렉토리 또는 s3://bucket/path와 같은 외부 버킷에 대한 참조 URI일 수 있습니다.

<>로 묶인 값은 사용자 고유의 값으로 바꾸세요.

import wandb

# W&B run 초기화
run = wandb.init(project="<your-project>", entity="<your-entity>")

# 모델 로깅
run.log_model(path="<path-to-model>", name="<name>")

선택적으로 name 파라미터에 모델 아티팩트 이름을 제공합니다. name이 지정되지 않은 경우 W&B는 run ID가 앞에 붙은 입력 경로의 기본 이름을 이름으로 사용합니다.

가능한 파라미터에 대한 자세한 내용은 API 참조 가이드의 log_model을 참조하세요.

import os
import wandb
from tensorflow import keras
from tensorflow.keras import layers

config = {"optimizer": "adam", "loss": "categorical_crossentropy"}

# W&B run 초기화
run = wandb.init(entity="charlie", project="mnist-experiments", config=config)

# 하이퍼파라미터
loss = run.config["loss"]
optimizer = run.config["optimizer"]
metrics = ["accuracy"]
num_classes = 10
input_shape = (28, 28, 1)

# 트레이닝 알고리즘
model = keras.Sequential(
    [
        layers.Input(shape=input_shape),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation="softmax"),
    ]
)

# 트레이닝을 위한 모델 구성
model.compile(loss=loss, optimizer=optimizer, metrics=metrics)

# 모델 저장
model_filename = "model.h5"
local_filepath = "./"
full_path = os.path.join(local_filepath, model_filename)
model.save(filepath=full_path)

# 모델을 W&B run에 로깅
run.log_model(path=full_path, name="MNIST")
run.finish()

View run different-surf-5 at: https://wandb.ai/charlie/mnist-experiments/runs/wlby6fuw
Synced 5 W&B file(s), 0 media file(s), 1 artifact file(s) and 0 other file(s)
Find logs at: ./wandb/run-20231206_103511-wlby6fuw/logs

로깅된 모델 다운로드 및 사용

use_model 함수를 사용하여 이전에 W&B run에 로깅된 모델 파일에 엑세스하고 다운로드합니다.

검색하려는 모델 파일이 저장된 모델 아티팩트의 이름을 제공합니다. 제공하는 이름은 기존의 로깅된 모델 아티팩트의 이름과 일치해야 합니다.

log_model로 파일을 원래 로깅할 때 name을 정의하지 않은 경우 할당된 기본 이름은 run ID가 앞에 붙은 입력 경로의 기본 이름입니다.

<>로 묶인 다른 값은 사용자 고유의 값으로 바꾸세요.

import wandb

# run 초기화
run = wandb.init(project="<your-project>", entity="<your-entity>")

# 모델에 엑세스 및 다운로드합니다. 다운로드된 아티팩트의 경로를 반환합니다.
downloaded_model_path = run.use_model(name="<your-model-name>")

use_model 함수는 다운로드된 모델 파일의 경로를 반환합니다. 나중에 이 모델을 연결하려면 이 경로를 추적하세요. 앞의 코드 조각에서 반환된 경로는 downloaded_model_path라는 변수에 저장됩니다.

import wandb

entity = "luka"
project = "NLP_Experiments"
alias = "latest"  # 모델 버전에 대한 시맨틱 닉네임 또는 식별자
model_artifact_name = "fine-tuned-model"

# run 초기화
run = wandb.init(project=project, entity=entity)
# 모델에 엑세스 및 다운로드합니다. 다운로드된 아티팩트의 경로를 반환합니다.
downloaded_model_path = run.use_model(name = f"{model_artifact_name}:{alias}") 

가능한 파라미터 및 반환 유형에 대한 자세한 내용은 API 참조 가이드의 use_model을 참조하세요.

모델을 로깅하고 W&B Model Registry에 연결

link_model 메서드를 사용하여 모델 파일을 W&B run에 로깅하고 W&B Model Registry에 연결합니다. 등록된 모델이 없으면 W&B는 registered_model_name 파라미터에 제공하는 이름으로 새 모델을 만듭니다.

모델을 연결하는 것은 팀의 다른 구성원이 보고 사용할 수 있는 모델의 중앙 집중식 팀 리포지토리에 모델을 ‘북마크’하거나 ‘게시’하는 것과 유사합니다.

모델을 연결하면 해당 모델이 Registry에서 복제되거나 프로젝트에서 레지스트리로 이동되지 않습니다. 연결된 모델은 프로젝트의 원래 모델에 대한 포인터입니다.

Registry를 사용하여 작업별로 최상의 모델을 구성하고, 모델 수명 주기를 관리하고, ML 수명 주기 전반에 걸쳐 간편한 추적 및 감사를 용이하게 하고, 웹 훅 또는 작업을 통해 다운스트림 작업을 자동화합니다.

Registered Model은 Model Registry의 연결된 모델 버전의 컬렉션 또는 폴더입니다. 등록된 모델은 일반적으로 단일 모델링 유스 케이스 또는 작업에 대한 후보 모델을 나타냅니다.

앞의 코드 조각은 link_model API로 모델을 연결하는 방법을 보여줍니다. <>로 묶인 다른 값은 사용자 고유의 값으로 바꾸세요.

import wandb

run = wandb.init(entity="<your-entity>", project="<your-project>")
run.link_model(path="<path-to-model>", registered_model_name="<registered-model-name>")
run.finish()

선택적 파라미터에 대한 자세한 내용은 API 참조 가이드의 link_model을 참조하세요.

registered-model-name이 Model Registry 내에 이미 존재하는 등록된 모델의 이름과 일치하면 모델이 해당 등록된 모델에 연결됩니다. 이러한 등록된 모델이 없으면 새 모델이 생성되고 모델이 첫 번째로 연결됩니다.

예를 들어, Model Registry에 “Fine-Tuned-Review-Autocompletion"이라는 기존 등록된 모델이 있다고 가정합니다(예제는 여기 참조). 그리고 몇 개의 모델 버전이 이미 v0, v1, v2로 연결되어 있다고 가정합니다. registered-model-name="Fine-Tuned-Review-Autocompletion"으로 link_model을 호출하면 새 모델이 이 기존 등록된 모델에 v3으로 연결됩니다. 이 이름으로 등록된 모델이 없으면 새 모델이 생성되고 새 모델이 v0으로 연결됩니다.

import wandb

path = "/local/dir/model.pt"
registered_model_name = "Fine-Tuned-Review-Autocompletion"

run = wandb.init(project="llm-evaluation", entity="noa")
run.link_model(path=path, registered_model_name=registered_model_name)
run.finish()

6.6 - Log summary metrics

트레이닝 과정에서 시간이 지남에 따라 변하는 값 외에도, 모델 또는 전처리 단계를 요약하는 단일 값을 추적하는 것이 중요한 경우가 많습니다. W&B Run의 summary 사전에 이 정보를 기록하세요. Run의 summary 사전은 numpy 배열, PyTorch 텐서 또는 TensorFlow 텐서를 처리할 수 있습니다. 값이 이러한 유형 중 하나인 경우 전체 텐서를 바이너리 파일에 유지하고 요약 오브젝트에 최소값, 평균, 분산, 백분위수 등과 같은 높은 수준의 메트릭을 저장합니다.

wandb.log로 기록된 마지막 값은 W&B Run에서 자동으로 summary 사전으로 설정됩니다. summary 메트릭 사전이 수정되면 이전 값은 손실됩니다.

다음 코드 조각은 사용자 정의 summary 메트릭을 W&B에 제공하는 방법을 보여줍니다.

wandb.init(config=args)

best_accuracy = 0
for epoch in range(1, args.epochs + 1):
    test_loss, test_accuracy = test()
    if test_accuracy > best_accuracy:
        wandb.summary["best_accuracy"] = test_accuracy
        best_accuracy = test_accuracy

트레이닝이 완료된 후 기존 W&B Run의 summary 속성을 업데이트할 수 있습니다. W&B Public API를 사용하여 summary 속성을 업데이트합니다.

api = wandb.Api()
run = api.run("username/project/run_id")
run.summary["tensor"] = np.random.random(1000)
run.summary.update()

summary 메트릭 사용자 정의

사용자 정의 summary 메트릭은 wandb.summary에서 트레이닝의 최적 단계에서 모델 성능을 캡처하는 데 유용합니다. 예를 들어 최종 값 대신 최대 정확도 또는 최소 손실 값을 캡처할 수 있습니다.

기본적으로 summary는 히스토리의 최종 값을 사용합니다. summary 메트릭을 사용자 정의하려면 define_metric에서 summary 인수를 전달합니다. 다음 값을 사용할 수 있습니다.

• "min"
• "max"
• "mean"
• "best"
• "last"
• "none"

선택적 objective 인수를 "minimize" 또는 "maximize"로 설정한 경우에만 "best"를 사용할 수 있습니다.

다음 예제는 손실 및 정확도의 최소값과 최대값을 summary에 추가합니다.

import wandb
import random

random.seed(1)
wandb.init()

# 손실에 대한 최소값 및 최대값 summary
wandb.define_metric("loss", summary="min")
wandb.define_metric("loss", summary="max")

# 정확도에 대한 최소값 및 최대값 summary
wandb.define_metric("acc", summary="min")
wandb.define_metric("acc", summary="max")

for i in range(10):
    log_dict = {
        "loss": random.uniform(0, 1 / (i + 1)),
        "acc": random.uniform(1 / (i + 1), 1),
    }
    wandb.log(log_dict)

summary 메트릭 보기

run의 Overview 페이지 또는 프로젝트의 runs 테이블에서 summary 값을 봅니다.

• Run Overview
• Run Table
• W&B Public API

1. W&B 앱으로 이동합니다.
2. Workspace 탭을 선택합니다.
3. runs 목록에서 summary 값이 기록된 run의 이름을 클릭합니다.
4. Overview 탭을 선택합니다.
5. Summary 섹션에서 summary 값을 봅니다.

1. W&B 앱으로 이동합니다.
2. Runs 탭을 선택합니다.
3. runs 테이블 내에서 summary 값의 이름을 기준으로 열 내에서 summary 값을 볼 수 있습니다.

W&B Public API를 사용하여 run의 summary 값을 가져올 수 있습니다.

다음 코드 예제는 W&B Public API 및 pandas를 사용하여 특정 run에 기록된 summary 값을 검색하는 한 가지 방법을 보여줍니다.

import wandb
import pandas

entity = "<your-entity>"
project = "<your-project>"
run_name = "<your-run-name>" # summary 값이 있는 run의 이름

all_runs = []

for run in api.runs(f"{entity}/{project_name}"):
  print("Fetching details for run: ", run.id, run.name)
  run_data = {
            "id": run.id,
            "name": run.name,
            "url": run.url,
            "state": run.state,
            "tags": run.tags,
            "config": run.config,
            "created_at": run.created_at,
            "system_metrics": run.system_metrics,
            "summary": run.summary,
            "project": run.project,
            "entity": run.entity,
            "user": run.user,
            "path": run.path,
            "notes": run.notes,
            "read_only": run.read_only,
            "history_keys": run.history_keys,
            "metadata": run.metadata,
        }
  all_runs.append(run_data)
  
# DataFrame으로 변환
df = pd.DataFrame(all_runs)

# 열 이름(run)을 기준으로 행을 가져오고 사전으로 변환
df[df['name']==run_name].summary.reset_index(drop=True).to_dict()

6.7 - Log tables

1. 테이블 만들기
2. 데이터 추가
3. 데이터 검색
4. 테이블 저장

테이블 만들기

테이블을 정의하려면 데이터의 각 행에 대해 보려는 열을 지정합니다. 각 행은 트레이닝 데이터셋의 단일 항목, 트레이닝 중의 특정 단계 또는 에포크, 테스트 항목에 대한 모델의 예측값, 모델에서 생성된 오브젝트 등이 될 수 있습니다. 각 열에는 숫자, 텍스트, 부울, 이미지, 비디오, 오디오 등 고정된 유형이 있습니다. 유형을 미리 지정할 필요는 없습니다. 각 열에 이름을 지정하고 해당 유형의 데이터만 해당 열 인덱스로 전달해야 합니다. 더 자세한 예는 이 리포트를 참조하십시오.

다음 두 가지 방법 중 하나로 wandb.Table 생성자를 사용합니다.

1. 행 목록: 이름이 지정된 열과 데이터 행을 기록합니다. 예를 들어 다음 코드 조각은 두 개의 행과 세 개의 열이 있는 테이블을 생성합니다.

wandb.Table(columns=["a", "b", "c"], data=[["1a", "1b", "1c"], ["2a", "2b", "2c"]])

2. Pandas DataFrame: wandb.Table(dataframe=my_df)를 사용하여 DataFrame을 기록합니다. 열 이름은 DataFrame에서 추출됩니다.

기존 배열 또는 데이터 프레임에서

# 모델이 다음 필드를 사용할 수 있는 네 개의 이미지에 대한 예측을 반환했다고 가정합니다.
# - 이미지 ID
# - wandb.Image()로 래핑된 이미지 픽셀
# - 모델의 예측 레이블
# - 그라운드 트루스 레이블
my_data = [
    [0, wandb.Image("img_0.jpg"), 0, 0],
    [1, wandb.Image("img_1.jpg"), 8, 0],
    [2, wandb.Image("img_2.jpg"), 7, 1],
    [3, wandb.Image("img_3.jpg"), 1, 1],
]

# 해당 열이 있는 wandb.Table() 생성
columns = ["id", "image", "prediction", "truth"]
test_table = wandb.Table(data=my_data, columns=columns)

데이터 추가

테이블은 변경 가능합니다. 스크립트가 실행될 때 테이블에 최대 200,000개의 행까지 더 많은 데이터를 추가할 수 있습니다. 테이블에 데이터를 추가하는 방법에는 두 가지가 있습니다.

1. 행 추가: table.add_data("3a", "3b", "3c"). 새 행은 목록으로 표시되지 않습니다. 행이 목록 형식인 경우 별표 표기법 *을 사용하여 목록을 위치 인수로 확장합니다. table.add_data(*my_row_list). 행에는 테이블의 열 수와 동일한 수의 항목이 포함되어야 합니다.
2. 열 추가: table.add_column(name="col_name", data=col_data). col_data의 길이는 테이블의 현재 행 수와 같아야 합니다. 여기서 col_data는 목록 데이터 또는 NumPy NDArray일 수 있습니다.

점진적으로 데이터 추가

이 코드 샘플은 W&B 테이블을 점진적으로 생성하고 채우는 방법을 보여줍니다. 가능한 모든 레이블에 대한 신뢰도 점수를 포함하여 미리 정의된 열로 테이블을 정의하고 추론 중에 행별로 데이터를 추가합니다. run을 재개할 때 테이블에 점진적으로 데이터를 추가할 수도 있습니다.

# 각 레이블에 대한 신뢰도 점수를 포함하여 테이블의 열을 정의합니다.
columns = ["id", "image", "guess", "truth"]
for digit in range(10):  # 각 숫자(0-9)에 대한 신뢰도 점수 열을 추가합니다.
    columns.append(f"score_{digit}")

# 정의된 열로 테이블을 초기화합니다.
test_table = wandb.Table(columns=columns)

# 테스트 데이터셋을 반복하고 데이터를 행별로 테이블에 추가합니다.
# 각 행에는 이미지 ID, 이미지, 예측 레이블, 트루 레이블 및 신뢰도 점수가 포함됩니다.
for img_id, img in enumerate(mnist_test_data):
    true_label = mnist_test_data_labels[img_id]  # 그라운드 트루스 레이블
    guess_label = my_model.predict(img)  # 예측 레이블
    test_table.add_data(
        img_id, wandb.Image(img), guess_label, true_label
    )  # 테이블에 행 데이터를 추가합니다.

재개된 run에 데이터 추가

아티팩트에서 기존 테이블을 로드하고, 데이터의 마지막 행을 검색하고, 업데이트된 메트릭을 추가하여 재개된 run에서 W&B 테이블을 점진적으로 업데이트할 수 있습니다. 그런 다음 호환성을 위해 테이블을 다시 초기화하고 업데이트된 버전을 W&B에 다시 기록합니다.

# 아티팩트에서 기존 테이블을 로드합니다.
best_checkpt_table = wandb.use_artifact(table_tag).get(table_name)

# 재개를 위해 테이블에서 데이터의 마지막 행을 가져옵니다.
best_iter, best_metric_max, best_metric_min = best_checkpt_table.data[-1]

# 필요에 따라 최상의 메트릭을 업데이트합니다.

# 업데이트된 데이터를 테이블에 추가합니다.
best_checkpt_table.add_data(best_iter, best_metric_max, best_metric_min)

# 호환성을 보장하기 위해 업데이트된 데이터로 테이블을 다시 초기화합니다.
best_checkpt_table = wandb.Table(
    columns=["col1", "col2", "col3"], data=best_checkpt_table.data
)

# 업데이트된 테이블을 Weights & Biases에 기록합니다.
wandb.log({table_name: best_checkpt_table})

데이터 검색

데이터가 테이블에 있으면 열 또는 행별로 엑세스합니다.

1. 행 반복기: 사용자는 for ndx, row in table.iterrows(): ...와 같은 테이블의 행 반복기를 사용하여 데이터의 행을 효율적으로 반복할 수 있습니다.
2. 열 가져오기: 사용자는 table.get_column("col_name")을 사용하여 데이터 열을 검색할 수 있습니다. 편의를 위해 사용자는 convert_to="numpy"를 전달하여 열을 기본 요소의 NumPy NDArray로 변환할 수 있습니다. 이는 열에 기본 데이터에 직접 엑세스할 수 있도록 wandb.Image와 같은 미디어 유형이 포함된 경우에 유용합니다.

테이블 저장

예를 들어 모델 예측 테이블과 같이 스크립트에서 데이터 테이블을 생성한 후 결과를 라이브로 시각화하기 위해 W&B에 저장합니다.

테이블을 run에 기록

wandb.log()를 사용하여 다음과 같이 테이블을 run에 저장합니다.

run = wandb.init()
my_table = wandb.Table(columns=["a", "b"], data=[["1a", "1b"], ["2a", "2b"]])
run.log({"table_key": my_table})

테이블이 동일한 키에 기록될 때마다 테이블의 새 버전이 생성되어 백엔드에 저장됩니다. 즉, 모델 예측이 시간이 지남에 따라 어떻게 향상되는지 확인하기 위해 여러 트레이닝 단계에서 동일한 테이블을 기록하거나 동일한 키에 기록되는 한 다른 run에서 테이블을 비교할 수 있습니다. 최대 200,000개의 행을 기록할 수 있습니다.

프로그래밍 방식으로 테이블 엑세스

백엔드에서 테이블은 Artifacts로 유지됩니다. 특정 버전에 엑세스하려면 아티팩트 API를 사용하여 엑세스할 수 있습니다.

with wandb.init() as run:
    my_table = run.use_artifact("run-<run-id>-<table-name>:<tag>").get("<table-name>")

Artifacts에 대한 자세한 내용은 개발자 가이드의 Artifacts 챕터를 참조하십시오.

테이블 시각화

이러한 방식으로 기록된 테이블은 Run 페이지와 Project 페이지 모두의 Workspace에 표시됩니다. 자세한 내용은 테이블 시각화 및 분석을 참조하십시오.

아티팩트 테이블

artifact.add()를 사용하여 워크스페이스 대신 run의 Artifacts 섹션에 테이블을 기록합니다. 이는 한 번 기록한 다음 향후 run에 참조할 데이터셋이 있는 경우에 유용할 수 있습니다.

run = wandb.init(project="my_project")
# 각 의미 있는 단계에 대한 wandb Artifact 생성
test_predictions = wandb.Artifact("mnist_test_preds", type="predictions")

# [위와 같이 예측 데이터 빌드]
test_table = wandb.Table(data=data, columns=columns)
test_predictions.add(test_table, "my_test_key")
run.log_artifact(test_predictions)

이미지 데이터와 함께 artifact.add()의 자세한 예는 이 Colab을 참조하고, Artifacts 및 Tables를 사용하여 테이블 형식 데이터의 버전 제어 및 중복 제거하는 방법의 예는 이 리포트를 참조하십시오.

아티팩트 테이블 결합

wandb.JoinedTable(table_1, table_2, join_key)를 사용하여 로컬에서 구성한 테이블 또는 다른 아티팩트에서 검색한 테이블을 결합할 수 있습니다.

아티팩트 컨텍스트에서 이전에 기록한 두 개의 테이블을 결합하려면 아티팩트에서 가져와 결과를 새 테이블로 결합합니다.

예를 들어 'original_songs'라는 원본 노래의 테이블 하나와 동일한 노래의 합성 버전의 또 다른 테이블인 'synth_songs'를 읽는 방법을 보여줍니다. 다음 코드 예제는 "song_id"에서 두 테이블을 결합하고 결과 테이블을 새 W&B 테이블로 업로드합니다.