이 섹션의 다중 페이지 출력 화면임. 여기를 클릭하여 프린트.
W&B 인테그레이션을 사용하면 기존 프로젝트 내에서 실험 추적 및 데이터 버전 관리를 빠르고 쉽게 설정할 수 있습니다. PyTorch와 같은 ML 프레임워크, Hugging Face와 같은 ML 라이브러리 또는 Amazon SageMaker와 같은 클라우드 서비스에 대한 인테그레이션을 확인하세요.
이 가이드는 강력한 Experiment Tracking, GPU 및 시스템 모니터링, 모델 체크포인팅 등을 사용자 라이브러리에서 활용할 수 있도록 W&B를 Python 라이브러리에 통합하는 모범 사례를 제공합니다.
다음은 작업 중인 코드베이스가 단일 Python 트레이닝 스크립트 또는 Jupyter 노트북보다 복잡할 때 유용한 팁과 모범 사례입니다. 다루는 주제는 다음과 같습니다.
시작하기 전에 라이브러리의 종속성에 W&B가 필요한지 여부를 결정하세요.
W&B Python 라이브러리(wandb)를 종속성 파일에 추가합니다(예: requirements.txt 파일):
torch==1.8.0
...
wandb==0.13.*
W&B SDK(wandb)를 선택 사항으로 만드는 방법에는 두 가지가 있습니다.
A. 사용자가 수동으로 설치하지 않고 wandb 기능을 사용하려고 할 때 오류를 발생시키고 적절한 오류 메시지를 표시합니다.
try:
import wandb
except ImportError:
raise ImportError(
"You are trying to use wandb which is not currently installed."
"Please install it using pip install wandb"
)
B. Python 패키지를 빌드하는 경우 pyproject.toml 파일에 wandb를 선택적 종속성으로 추가합니다.
[project]
name = "my_awesome_lib"
version = "0.1.0"
dependencies = [
"torch",
"sklearn"
]
[project.optional-dependencies]
dev = [
"wandb"
]
API 키는 클라이언트 또는 머신을 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인로컬에서 wandb 라이브러리를 설치하고 로그인하려면:
API 키로 WANDB_API_KEY 환경 변수를 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
사용자가 위에 언급된 단계를 따르지 않고 처음으로 wandb를 사용하는 경우 스크립트에서 wandb.init을 호출할 때 자동으로 로그인하라는 메시지가 표시됩니다.
W&B Run은 W&B에서 로깅하는 계산 단위입니다. 일반적으로 트레이닝 실험당 단일 W&B Run을 연결합니다.
코드 내에서 W&B를 초기화하고 Run을 시작합니다.
run = wandb.init()
선택적으로, 코드에서 wandb_project와 같은 파라미터와 함께 프로젝트 이름을 제공하거나 사용자 이름 또는 팀 이름(예: 엔터티 파라미터에 대한 wandb_entity)과 함께 프로젝트 이름을 제공하도록 할 수 있습니다.
run = wandb.init(project=wandb_project, entity=wandb_entity)
Run을 완료하려면 run.finish()를 호출해야 합니다. 이것이 통합 디자인에 적합한 경우 Run을 컨텍스트 관리자로 사용합니다.
# 이 블록이 종료되면 run.finish()를 자동으로 호출합니다.
# 예외로 인해 종료되면 run.finish(exit_code=1)을 사용하여 Run을 실패로 표시합니다.
with wandb.init() as run:
...
wandb.init을 언제 호출해야 할까요?라이브러리는 가능한 한 빨리 W&B Run을 만들어야 합니다. 오류 메시지를 포함하여 콘솔의 모든 출력이 W&B Run의 일부로 로깅되기 때문입니다. 이렇게 하면 디버깅이 더 쉬워집니다.
wandb를 선택적 종속성으로 사용하기사용자가 라이브러리를 사용할 때 wandb를 선택 사항으로 만들려면 다음 중 하나를 수행할 수 있습니다.
wandb 플래그를 정의합니다.trainer = my_trainer(..., use_wandb=True)
python train.py ... --use-wandb
wandb.init에서 wandb를 disabled로 설정합니다.wandb.init(mode="disabled")
export WANDB_MODE=disabled
또는
wandb disabled
wandb를 오프라인으로 설정합니다. 이렇게 하면 여전히 wandb가 실행되지만 인터넷을 통해 W&B에 다시 통신하려고 시도하지 않습니다.export WANDB_MODE=offline
또는
os.environ['WANDB_MODE'] = 'offline'
wandb offline
wandb Run 설정으로 W&B Run을 만들 때 모델, 데이터셋 등에 대한 메타데이터를 제공할 수 있습니다. 이 정보를 사용하여 다양한 Experiments를 비교하고 주요 차이점을 빠르게 이해할 수 있습니다.
로깅할 수 있는 일반적인 구성 파라미터는 다음과 같습니다.
다음 코드 조각은 구성을 로깅하는 방법을 보여줍니다.
config = {"batch_size": 32, ...}
wandb.init(..., config=config)
run.config.update를 사용하여 구성을 업데이트합니다. 구성 사전이 정의된 후에 파라미터를 가져올 때 구성 사전을 업데이트하는 것이 유용합니다. 예를 들어 모델이 인스턴스화된 후에 모델의 파라미터를 추가할 수 있습니다.
run.config.update({"model_parameters": 3500})
구성 파일을 정의하는 방법에 대한 자세한 내용은 실험 구성을 참조하세요.
키 값이 메트릭 이름인 사전을 만듭니다. 이 사전 오브젝트를 run.log에 전달합니다.
for epoch in range(NUM_EPOCHS):
for input, ground_truth in data:
prediction = model(input)
loss = loss_fn(prediction, ground_truth)
metrics = { "loss": loss }
run.log(metrics)
메트릭이 많은 경우 메트릭 이름에 train/... 및 val/...와 같은 접두사를 사용하여 UI에서 자동으로 그룹화할 수 있습니다. 이렇게 하면 트레이닝 및 검증 메트릭 또는 분리하려는 다른 메트릭 유형에 대해 W&B Workspace에 별도의 섹션이 생성됩니다.
metrics = {
"train/loss": 0.4,
"train/learning_rate": 0.4,
"val/loss": 0.5,
"val/accuracy": 0.7
}
run.log(metrics)
동일한 트레이닝 단계에 대해 run.log를 여러 번 호출하는 경우 wandb SDK는 run.log를 호출할 때마다 내부 단계 카운터를 증가시킵니다. 이 카운터는 트레이닝 루프의 트레이닝 단계와 정렬되지 않을 수 있습니다.
이러한 상황을 피하려면 wandb.init을 호출한 직후에 run.define_metric을 사용하여 x축 단계를 명시적으로 한 번 정의하세요.
with wandb.init(...) as run:
run.define_metric("*", step_metric="global_step")
글로브 패턴 *는 모든 메트릭이 차트에서 global_step을 x축으로 사용함을 의미합니다. 특정 메트릭만 global_step에 대해 로깅하려면 대신 지정할 수 있습니다.
run.define_metric("train/loss", step_metric="global_step")
이제 run.log를 호출할 때마다 메트릭, step 메트릭 및 global_step을 로깅합니다.
for step, (input, ground_truth) in enumerate(data):
...
run.log({"global_step": step, "train/loss": 0.1})
run.log({"global_step": step, "eval/loss": 0.2})
예를 들어 검증 루프 중에 “global_step"을 사용할 수 없는 경우 독립 단계 변수에 액세스할 수 없는 경우 “global_step"에 대해 이전에 로깅된 값이 wandb에서 자동으로 사용됩니다. 이 경우 메트릭에 필요한 경우 정의되도록 메트릭에 대한 초기 값을 로깅해야 합니다.
메트릭 외에도 플롯, 히스토그램, 테이블, 텍스트, 이미지, 비디오, 오디오, 3D 등과 같은 미디어를 로깅할 수 있습니다.
데이터 로깅 시 고려해야 할 사항은 다음과 같습니다.
미디어, 오브젝트, 플롯 등을 로깅하는 방법에 대해 자세히 알아보세요.
분산 환경을 지원하는 프레임워크의 경우 다음 워크플로우 중 하나를 적용할 수 있습니다.
wandb를 사용합니다. 다른 프로세스에서 오는 필요한 데이터는 먼저 메인 프로세스로 라우팅되어야 합니다. (이 워크플로우가 권장됩니다).wandb를 호출하고 모두 동일한 고유 group 이름을 지정하여 자동으로 그룹화합니다.자세한 내용은 분산 트레이닝 실험 로깅을 참조하세요.
프레임워크에서 모델 또는 데이터셋을 사용하거나 생성하는 경우 전체 추적성을 위해 로깅하고 wandb가 W&B Artifacts를 통해 전체 파이프라인을 자동으로 모니터링하도록 할 수 있습니다.
Artifacts를 사용할 때 사용자가 다음을 정의하도록 하는 것이 유용하지만 필수는 아닙니다.
user/project/artifact입니다.모델 체크포인트를 W&B에 로깅할 수 있습니다. 고유한 wandb Run ID를 활용하여 출력 모델 체크포인트 이름을 지정하여 Runs 간에 차별화하는 것이 유용합니다. 유용한 메타데이터를 추가할 수도 있습니다. 또한 아래와 같이 각 모델에 에일리어스를 추가할 수도 있습니다.
metadata = {"eval/accuracy": 0.8, "train/steps": 800}
artifact = wandb.Artifact(
name=f"model-{run.id}",
metadata=metadata,
type="model"
)
artifact.add_dir("output_model") # 모델 가중치가 저장되는 로컬 디렉토리
aliases = ["best", "epoch_10"]
run.log_artifact(artifact, aliases=aliases)
사용자 지정 에일리어스를 만드는 방법에 대한 자세한 내용은 사용자 지정 에일리어스 만들기를 참조하세요.
출력 Artifacts를 임의의 빈도(예: 모든 에포크, 500단계마다 등)로 로깅할 수 있으며 자동으로 버전이 지정됩니다.
사전 학습된 모델 또는 데이터셋과 같이 트레이닝에 입력으로 사용되는 아티팩트를 로깅할 수 있습니다. 다음 코드 조각은 Artifact를 로깅하고 위의 그래프에 표시된 대로 진행 중인 Run에 입력으로 추가하는 방법을 보여줍니다.
artifact_input_data = wandb.Artifact(name="flowers", type="dataset")
artifact_input_data.add_file("flowers.npy")
run.use_artifact(artifact_input_data)
Artifact(데이터셋, 모델 등)를 다시 사용하면 wandb가 로컬에 복사본을 다운로드합니다(그리고 캐시합니다).
artifact = run.use_artifact("user/project/artifact:latest")
local_path = artifact.download("./tmp")
Artifacts는 W&B의 Artifacts 섹션에서 찾을 수 있으며 자동으로 생성된 에일리어스(latest, v2, v3) 또는 로깅할 때 수동으로 생성된 에일리어스(best_accuracy 등)로 참조할 수 있습니다.
분산 환경 또는 간단한 추론과 같이(wandb.init을 통해) wandb Run을 만들지 않고 Artifact를 다운로드하려면 대신 wandb API로 아티팩트를 참조할 수 있습니다.
artifact = wandb.Api().artifact("user/project/artifact:latest")
local_path = artifact.download()
자세한 내용은 Artifacts 다운로드 및 사용을 참조하세요.
라이브러리에서 W&B 하이퍼파라미터 튜닝을 활용하려면 W&B Sweeps를 라이브러리에 추가할 수도 있습니다.
다음 인테그레이션에서 고급 W&B 인테그레이션이 어떻게 보이는지 확인할 수도 있습니다. 대부분의 인테그레이션은 이만큼 복잡하지 않습니다.
W&B를 사용하여 Microsoft Azure에서 GPT-3.5 또는 GPT-4 모델을 미세 조정하면 메트릭을 자동으로 캡처하고 W&B의 실험 추적 및 평가 툴을 통해 체계적인 평가를 용이하게 하여 모델 성능을 추적, 분석 및 개선할 수 있습니다.
미세 조정하는 동안 W&B는 다음을 캡처합니다.
미세 조정한 후 W&B Weave를 사용하여 다음을 수행합니다.
Catalyst는 재현성, 빠른 실험, 코드베이스 재사용에 중점을 둔 딥러닝 R&D를 위한 PyTorch 프레임워크이므로 새로운 것을 만들 수 있습니다.
Catalyst에는 파라미터, 메트릭, 이미지 및 기타 Artifacts 로깅을 위한 W&B 인테그레이션이 포함되어 있습니다.
Python 및 Hydra를 사용한 예제가 포함된 인테그레이션 관련 문서를 확인하세요.
Catalyst 및 W&B 인테그레이션이 작동하는 것을 보려면 예제 colab을 실행하세요.
Weights & Biases를 사용하면 Cohere 모델의 미세 조정 메트릭 및 설정을 기록하여 모델의 성능을 분석하고 이해하며 동료와 결과를 공유할 수 있습니다.
이 Cohere 가이드에는 미세 조정 run을 시작하는 방법에 대한 전체 예제가 있으며, Cohere API 문서는 여기에서 찾을 수 있습니다.
Cohere 미세 조정 로깅을 W&B workspace에 추가하려면 다음을 수행하십시오.
W&B API 키, W&B entity 및 project 이름으로 WandbConfig를 생성합니다. W&B API 키는 https://wandb.ai/authorize 에서 찾을 수 있습니다.
모델 이름, 데이터셋 및 하이퍼파라미터와 함께 이 설정을 FinetunedModel 오브젝트에 전달하여 미세 조정 run을 시작합니다.
from cohere.finetuning import WandbConfig, FinetunedModel
# W&B 세부 정보로 config를 생성합니다.
wandb_ft_config = WandbConfig(
api_key="<wandb_api_key>",
entity="my-entity", # 제공된 API 키와 연결된 유효한 entity여야 합니다.
project="cohere-ft",
)
... # 데이터셋 및 하이퍼파라미터를 설정합니다.
# cohere에서 미세 조정 run을 시작합니다.
cmd_r_finetune = co.finetuning.create_finetuned_model(
request=FinetunedModel(
name="command-r-ft",
settings=Settings(
base_model=...
dataset_id=...
hyperparameters=...
wandb=wandb_ft_config # 여기에 W&B config를 전달합니다.
),
),
)
모델의 미세 조정 트레이닝 및 유효성 검사 메트릭과 하이퍼파라미터를 생성한 W&B project에서 확인합니다.
W&B runs는 자동으로 구성되며 job 유형, base model, 학습 속도 및 기타 하이퍼파라미터와 같은 모든 configuration 파라미터를 기준으로 필터링/정렬할 수 있습니다.
또한 runs의 이름을 바꾸거나, 노트를 추가하거나, 태그를 생성하여 그룹화할 수 있습니다.
W&B는 Databricks 환경에서 W&B Jupyter 노트북 경험을 사용자 정의하여 Databricks와 통합됩니다.
클러스터에 wandb 설치
클러스터 설정으로 이동하여 클러스터를 선택하고 Libraries를 클릭합니다. Install New를 클릭하고 PyPI를 선택한 다음 wandb 패키지를 추가합니다.
인증 설정
W&B 계정을 인증하려면 노트북이 쿼리할 수 있는 Databricks secret을 추가하면 됩니다.
# databricks cli 설치
pip install databricks-cli
# databricks UI에서 토큰 생성
databricks configure --token
# 다음 두 코맨드 중 하나를 사용하여 스코프를 생성합니다 (databricks에서 보안 기능 활성화 여부에 따라 다름).
# 보안 추가 기능 사용
databricks secrets create-scope --scope wandb
# 보안 추가 기능 미사용
databricks secrets create-scope --scope wandb --initial-manage-principal users
# 다음 위치에서 api_key를 추가합니다: https://app.wandb.ai/authorize
databricks secrets put --scope wandb --key api_key
import os
import wandb
api_key = dbutils.secrets.get("wandb", "api_key")
wandb.login(key=api_key)
wandb.init()
wandb.log({"foo": 1})
wandb.sweep() 또는 wandb.agent()를 사용하려는 노트북에 필요한 설정(임시):
import os
# 다음은 향후에는 필요하지 않습니다.
os.environ["WANDB_ENTITY"] = "my-entity"
os.environ["WANDB_PROJECT"] = "my-project-that-exists"
DeepChecks는 최소한의 노력으로 데이터의 무결성 검증, 분포 검사, 데이터 분할 검증, 모델 평가, 여러 모델 간 비교 등 기계 학습 모델과 데이터를 검증하는 데 도움을 줍니다.
DeepChecks 및 wandb 통합에 대해 자세히 알아보기 ->
DeepChecks를 Weights & Biases 와 함께 사용하려면 먼저 Weights & Biases 계정을 여기에서 가입해야 합니다. DeepChecks의 Weights & Biases 인테그레이션을 사용하면 다음과 같이 빠르게 시작할 수 있습니다.
import wandb
wandb.login()
# deepchecks에서 검사 가져오기
from deepchecks.checks import ModelErrorAnalysis
# 검사 실행
result = ModelErrorAnalysis()
# 해당 결과를 wandb로 푸시
result.to_wandb()
전체 DeepChecks 테스트 스위트를 Weights & Biases 에 로그할 수도 있습니다.
import wandb
wandb.login()
# deepchecks에서 full_suite 테스트 가져오기
from deepchecks.suites import full_suite
# DeepChecks 테스트 스위트 생성 및 실행
suite_result = full_suite().run(...)
# thes 결과를 wandb로 푸시
# 여기에서 필요한 wandb.init 구성 및 인수를 전달할 수 있습니다.
suite_result.to_wandb(project="my-suite-project", config={"suite-name": "full-suite"})
``이 Report는 DeepChecks와 Weights & Biases를 사용하는 강력한 기능을 보여줍니다.
이 Weights & Biases 인테그레이션에 대한 질문이나 문제가 있으십니까? DeepChecks github repository에 이슈를 열어주시면 확인 후 답변드리겠습니다 :)
DeepChem 라이브러리는 약물 발견, 재료 과학, 화학 및 생물학에서 딥러닝 사용을 대중화하는 오픈 소스 툴을 제공합니다. 이 W&B 인테그레이션은 DeepChem을 사용하여 모델을 트레이닝하는 동안 간단하고 사용하기 쉬운 experiment 추적 및 모델 체크포인팅을 추가합니다.
logger = WandbLogger(…)
model = TorchModel(…, wandb_logger=logger)
model.fit(…)
W&B와 DeepChem 사용: 분자 그래프 컨볼루션 네트워크 아티클에서 W&B DeepChem 인테그레이션을 사용하여 생성된 차트 예제를 살펴보세요.
작동하는 코드로 바로 들어가려면 이 Google Colab을 확인하세요.
KerasModel 또는 TorchModel 유형의 DeepChem 모델에 대해 W&B를 설정합니다.
API 키는 W&B에 대한 컴퓨터를 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리를 설치하고 로그인하기wandb 라이브러리를 로컬에 설치하고 로그인하려면 다음을 수행합니다.
WANDB_API_KEY 환경 변수를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
트레이닝 손실 및 평가 메트릭은 W&B에 자동으로 기록될 수 있습니다. DeepChem ValidationCallback을 사용하여 선택적 평가를 활성화할 수 있습니다. WandbLogger는 ValidationCallback 콜백을 감지하고 생성된 메트릭을 기록합니다.
from deepchem.models import TorchModel, ValidationCallback
vc = ValidationCallback(…) # optional
model = TorchModel(…, wandb_logger=logger)
model.fit(…, callbacks=[vc])
logger.finish()
from deepchem.models import KerasModel, ValidationCallback
vc = ValidationCallback(…) # optional
model = KerasModel(…, wandb_logger=logger)
model.fit(…, callbacks=[vc])
logger.finish()
W&B는 코드 가 실행된 Docker 이미지에 대한 포인터를 저장하여 이전의 실험 을 정확한 환경 으로 복원할 수 있도록 합니다. wandb 라이브러리 는 이 상태 를 유지하기 위해 WANDB_DOCKER 환경 변수 를 찾습니다. 이 상태 를 자동으로 설정하는 몇 가지 도우미를 제공합니다.
wandb docker 는 docker 컨테이너 를 시작하고, wandb 환경 변수 를 전달하고, 코드 를 마운트하고, wandb가 설치되었는지 확인하는 코맨드 입니다. 기본적으로 이 코맨드 는 TensorFlow, PyTorch, Keras 및 Jupyter가 설치된 docker 이미지 를 사용합니다. 동일한 코맨드 를 사용하여 자신의 docker 이미지 를 시작할 수 있습니다: wandb docker my/image:latest. 이 코맨드 는 현재 디렉토리 를 컨테이너 의 “/app” 디렉토리 에 마운트합니다. “–dir” 플래그 를 사용하여 이를 변경할 수 있습니다.
wandb docker-run 코맨드 는 프로덕션 워크로드 를 위해 제공됩니다. nvidia-docker 를 대체할 수 있도록 만들어졌습니다. 이는 docker run 코맨드 에 대한 간단한 래퍼 로, 자격 증명 과 WANDB_DOCKER 환경 변수 를 호출에 추가합니다. “–runtime” 플래그 를 전달하지 않고 시스템에서 nvidia-docker 를 사용할 수 있는 경우 런타임 이 nvidia로 설정됩니다.
Kubernetes에서 트레이닝 워크로드 를 실행하고 k8s API가 Pod에 노출된 경우 (기본적으로 해당됨) wandb는 docker 이미지 의 다이제스트에 대해 API를 쿼리하고 WANDB_DOCKER 환경 변수 를 자동으로 설정합니다.
WANDB_DOCKER 환경 변수 로 Run이 계측된 경우, wandb restore username/project:run_id 를 호출하면 코드 를 복원하는 새 분기를 체크아웃한 다음, 트레이닝 에 사용된 정확한 docker 이미지 를 원래 코맨드 로 미리 채워 시작합니다.
Farama Gymnasium을 사용하는 경우 gymnasium.wrappers.Monitor에서 생성된 환경의 비디오가 자동으로 기록됩니다. wandb.init에 대한 monitor_gym 키워드 인수를 True로 설정하기만 하면 됩니다.
Gymnasium 인테그레이션은 매우 간단합니다. gymnasium에서 기록된 비디오 파일의 이름을 확인하고, 그에 따라 이름을 지정하거나 일치하는 항목을 찾지 못하면 "videos"로 대체합니다. 더 많은 제어를 원한다면 언제든지 수동으로 비디오를 기록할 수 있습니다.
CleanRL 라이브러리와 함께 Gymnasium을 사용하는 방법에 대한 자세한 내용은 이 report를 확인하세요.
fastai를 사용하여 모델을 트레이닝하는 경우, W&B는 WandbCallback을 사용하여 쉽게 통합할 수 있습니다. 예제가 포함된 대화형 문서에서 자세한 내용을 살펴보세요 →
API 키는 사용자의 머신을 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인로컬에서 wandb 라이브러리를 설치하고 로그인하려면 다음을 수행합니다.
WANDB_API_KEY 환경 변수를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
WandbCallback을 learner 또는 fit 메서드에 추가import wandb
from fastai.callback.wandb import *
# wandb run 로깅 시작
wandb.init(project="my_project")
# 하나의 트레이닝 단계에서만 로깅하려면
learn.fit(..., cbs=WandbCallback())
# 모든 트레이닝 단계에서 지속적으로 로깅하려면
learn = learner(..., cbs=WandbCallback())
WandbCallback은 다음 인수를 허용합니다.
| Args | Description |
|---|---|
| log | 모델의 다음 항목을 기록할지 여부: gradients , parameters, all 또는 None (기본값). 손실 및 메트릭은 항상 기록됩니다. |
| log_preds | 예측 샘플을 기록할지 여부 (기본값은 True). |
| log_preds_every_epoch | 에포크마다 예측을 기록할지 또는 마지막에 기록할지 여부 (기본값은 False) |
| log_model | 모델을 기록할지 여부 (기본값은 False). 이 옵션은 SaveModelCallback도 필요합니다. |
| model_name | 저장할 file 이름으로, SaveModelCallback을 재정의합니다. |
| log_dataset |
참고: 하위 폴더 “models"는 항상 무시됩니다. |
| dataset_name | 기록된 데이터셋의 이름 (기본값은 folder name). |
| valid_dl | 예측 샘플에 사용되는 항목을 포함하는 DataLoaders (기본값은 learn.dls.valid의 임의 항목). |
| n_preds | 기록된 예측 수 (기본값은 36). |
| seed | 임의 샘플을 정의하는 데 사용됩니다. |
커스텀 워크플로우의 경우 데이터셋과 모델을 수동으로 기록할 수 있습니다.
log_dataset(path, name=None, metadata={})log_model(path, name=None, metadata={})참고: 모든 하위 폴더 “models"는 무시됩니다.
fastai는 컨텍스트 관리자 distrib_ctx를 사용하여 분산 트레이닝을 지원합니다. W&B는 이를 자동으로 지원하며 Multi-GPU Experiments를 즉시 추적할 수 있습니다.
이 최소 예제를 검토하세요.
import wandb
from fastai.vision.all import *
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback
wandb.require(experiment="service")
path = rank0_first(lambda: untar_data(URLs.PETS) / "images")
def train():
dls = ImageDataLoaders.from_name_func(
path,
get_image_files(path),
valid_pct=0.2,
label_func=lambda x: x[0].isupper(),
item_tfms=Resize(224),
)
wandb.init("fastai_ddp", entity="capecape")
cb = WandbCallback()
learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
with learn.distrib_ctx(sync_bn=False):
learn.fit(1)
if __name__ == "__main__":
train()
그런 다음 터미널에서 다음을 실행합니다.
$ torchrun --nproc_per_node 2 train.py
이 경우 머신에 2개의 GPU가 있습니다.
이제 노트북 내에서 직접 분산 트레이닝을 실행할 수 있습니다.
import wandb
from fastai.vision.all import *
from accelerate import notebook_launcher
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback
wandb.require(experiment="service")
path = untar_data(URLs.PETS) / "images"
def train():
dls = ImageDataLoaders.from_name_func(
path,
get_image_files(path),
valid_pct=0.2,
label_func=lambda x: x[0].isupper(),
item_tfms=Resize(224),
)
wandb.init("fastai_ddp", entity="capecape")
cb = WandbCallback()
learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
with learn.distrib_ctx(in_notebook=True, sync_bn=False):
learn.fit(1)
notebook_launcher(train, num_processes=2)
위의 예에서 wandb는 프로세스당 하나의 run을 시작합니다. 트레이닝이 끝나면 두 개의 run이 생성됩니다. 이는 혼란스러울 수 있으며 메인 프로세스에서만 로그할 수 있습니다. 이렇게 하려면 어떤 프로세스에 있는지 수동으로 감지하고 다른 모든 프로세스에서 run 생성을 피해야 합니다 (wandb.init 호출).
import wandb
from fastai.vision.all import *
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback
wandb.require(experiment="service")
path = rank0_first(lambda: untar_data(URLs.PETS) / "images")
def train():
cb = []
dls = ImageDataLoaders.from_name_func(
path,
get_image_files(path),
valid_pct=0.2,
label_func=lambda x: x[0].isupper(),
item_tfms=Resize(224),
)
if rank_distrib() == 0:
run = wandb.init("fastai_ddp", entity="capecape")
cb = WandbCallback()
learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
with learn.distrib_ctx(sync_bn=False):
learn.fit(1)
if __name__ == "__main__":
train()
터미널에서 다음을 호출합니다.
$ torchrun --nproc_per_node 2 train.py
import wandb
from fastai.vision.all import *
from accelerate import notebook_launcher
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback
wandb.require(experiment="service")
path = untar_data(URLs.PETS) / "images"
def train():
cb = []
dls = ImageDataLoaders.from_name_func(
path,
get_image_files(path),
valid_pct=0.2,
label_func=lambda x: x[0].isupper(),
item_tfms=Resize(224),
)
if rank_distrib() == 0:
run = wandb.init("fastai_ddp", entity="capecape")
cb = WandbCallback()
learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
with learn.distrib_ctx(in_notebook=True, sync_bn=False):
learn.fit(1)
notebook_launcher(train, num_processes=2)
fastai v1을 사용하는 스크립트의 경우, 모델 토폴로지, 손실, 메트릭, 가중치, 그레이디언트, 샘플 예측 및 최적 트레이닝된 모델을 자동으로 기록할 수 있는 콜백이 있습니다.
import wandb
from wandb.fastai import WandbCallback
wandb.init()
learn = cnn_learner(data, model, callback_fns=WandbCallback)
learn.fit(epochs)
요청된 기록 데이터는 콜백 생성자를 통해 구성할 수 있습니다.
from functools import partial
learn = cnn_learner(
data, model, callback_fns=partial(WandbCallback, input_type="images")
)
트레이닝을 시작할 때만 WandbCallback을 사용하는 것도 가능합니다. 이 경우 인스턴스화해야 합니다.
learn.fit(epochs, callbacks=WandbCallback(learn))
사용자 지정 파라미터를 해당 단계에서 제공할 수도 있습니다.
learn.fit(epochs, callbacks=WandbCallback(learn, input_type="images"))
이 통합이 어떻게 작동하는지 보여주는 몇 가지 예제를 만들었습니다.
Fastai v1
WandbCallback() 클래스는 다음과 같은 여러 옵션을 지원합니다.
| 키워드 인수 | 기본값 | 설명 |
|---|---|---|
| learn | N/A | 연결할 fast.ai 학습기입니다. |
| save_model | True | 각 단계에서 향상되면 모델을 저장합니다. 트레이닝이 끝나면 최적 모델도 로드합니다. |
| mode | auto | min, max 또는 auto: 단계 간에 monitor에 지정된 트레이닝 메트릭을 비교하는 방법입니다. |
| monitor | None | 최적 모델을 저장하기 위한 성능을 측정하는 데 사용되는 트레이닝 메트릭입니다. None은 유효성 검사 손실을 기본값으로 합니다. |
| log | gradients | gradients, parameters, all 또는 None. 손실 및 메트릭은 항상 기록됩니다. |
| input_type | None | images 또는 None. 샘플 예측을 표시하는 데 사용됩니다. |
| validation_data | None | input_type이 설정된 경우 샘플 예측에 사용되는 데이터입니다. |
| predictions | 36 | input_type이 설정되고 validation_data가 None인 경우 수행할 예측 횟수입니다. |
| seed | 12345 | input_type이 설정되고 validation_data가 None인 경우 샘플 예측을 위해 난수 생성기를 초기화합니다. |
Hugging Face Transformers 라이브러리를 사용하면 최첨단 NLP 모델(예: BERT)과 혼합 정밀도 및 그레이디언트 체크포인트와 같은 트레이닝 기술을 쉽게 사용할 수 있습니다. W&B 통합은 사용 편의성을 유지하면서도 대화형 중앙 집중식 대시보드에 풍부하고 유연한 실험 추적 및 모델 버전 관리를 추가합니다.
os.environ["WANDB_PROJECT"] = "<my-amazing-project>" # W&B 프로젝트 이름 지정
os.environ["WANDB_LOG_MODEL"] = "checkpoint" # 모든 모델 체크포인트 로깅
from transformers import TrainingArguments, Trainer
args = TrainingArguments(..., report_to="wandb") # W&B 로깅 켜기
trainer = Trainer(..., args=args)
API 키는 사용자의 컴퓨터가 W&B에 인증되도록 합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인wandb 라이브러리를 로컬에 설치하고 로그인하는 방법:
WANDB_API_KEY 환경 변수를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
W&B를 처음 사용하는 경우 퀵스타트를 확인하는 것이 좋습니다.
W&B Project는 관련 Runs에서 기록된 모든 차트, 데이터 및 Models가 저장되는 곳입니다. 프로젝트 이름을 지정하면 작업을 구성하고 단일 프로젝트에 대한 모든 정보를 한 곳에 보관하는 데 도움이 됩니다.
Run을 프로젝트에 추가하려면 WANDB_PROJECT 환경 변수를 프로젝트 이름으로 설정하기만 하면 됩니다. WandbCallback은 이 프로젝트 이름 환경 변수를 가져와 Run을 설정할 때 사용합니다.
WANDB_PROJECT=amazon_sentiment_analysis
import os
os.environ["WANDB_PROJECT"]="amazon_sentiment_analysis"
%env WANDB_PROJECT=amazon_sentiment_analysis
Trainer를 초기화하기 전에 프로젝트 이름을 설정해야 합니다.프로젝트 이름이 지정되지 않은 경우 프로젝트 이름은 기본적으로 huggingface로 설정됩니다.
Trainer 트레이닝 인수를 정의할 때 코드 내부 또는 커맨드라인에서 가장 중요한 단계는 W&B를 사용하여 로깅을 활성화하기 위해 report_to를 "wandb"로 설정하는 것입니다.
TrainingArguments의 logging_steps 인수는 트레이닝 중에 트레이닝 메트릭이 W&B로 푸시되는 빈도를 제어합니다. run_name 인수를 사용하여 W&B에서 트레이닝 Run의 이름을 지정할 수도 있습니다.
이제 모델이 트레이닝하는 동안 손실, 평가 메트릭, 모델 토폴로지 및 그레이디언트를 W&B에 로깅합니다.
python run_glue.py \ # Python 스크립트 실행
--report_to wandb \ # W&B에 로깅 활성화
--run_name bert-base-high-lr \ # W&B Run 이름(선택 사항)
# 기타 커맨드라인 인수
from transformers import TrainingArguments, Trainer
args = TrainingArguments(
# 기타 인수 및 kwargs
report_to="wandb", # W&B에 로깅 활성화
run_name="bert-base-high-lr", # W&B Run 이름(선택 사항)
logging_steps=1, # W&B에 로깅 빈도
)
trainer = Trainer(
# 기타 인수 및 kwargs
args=args, # 트레이닝 인수
)
trainer.train() # 트레이닝을 시작하고 W&B에 로깅
Trainer를 TensorFlow TFTrainer로 바꾸기만 하세요.Artifacts를 사용하면 최대 100GB의 Models 및 Datasets를 무료로 저장한 다음 Weights & Biases Registry를 사용할 수 있습니다. Registry를 사용하면 Models를 등록하여 탐색하고 평가하고, 스테이징을 준비하거나 프로덕션 환경에 배포할 수 있습니다.
Hugging Face 모델 체크포인트를 Artifacts에 로깅하려면 WANDB_LOG_MODEL 환경 변수를 다음 _중 하나_로 설정합니다.
checkpoint: TrainingArguments에서 args.save_steps마다 체크포인트를 업로드합니다.end: load_best_model_at_end도 설정된 경우 트레이닝이 끝나면 모델을 업로드합니다.false: 모델을 업로드하지 않습니다.WANDB_LOG_MODEL="checkpoint"
import os
os.environ["WANDB_LOG_MODEL"] = "checkpoint"
%env WANDB_LOG_MODEL="checkpoint"
이제부터 초기화하는 모든 Transformers Trainer는 Models를 W&B Project에 업로드합니다. 로깅하는 모델 체크포인트는 Artifacts UI를 통해 볼 수 있으며 전체 모델 계보가 포함됩니다(UI에서 예제 모델 체크포인트를 보려면 여기 참조).
WANDB_LOG_MODEL이 end로 설정된 경우 모델은 model-{run_id}로 W&B Artifacts에 저장되고, WANDB_LOG_MODEL이 checkpoint로 설정된 경우 checkpoint-{run_id}로 저장됩니다.
그러나 TrainingArguments에서 run_name을 전달하면 모델은 model-{run_name} 또는 checkpoint-{run_name}로 저장됩니다.체크포인트를 Artifacts에 로깅한 후에는 **Registry**를 사용하여 최고의 모델 체크포인트를 등록하고 팀 전체에서 중앙 집중화할 수 있습니다. Registry를 사용하면 작업별로 최고의 Models를 구성하고, Models의 라이프사이클을 관리하고, 전체 ML 라이프사이클을 추적 및 감사하고, 다운스트림 작업을 자동화할 수 있습니다.
모델 Artifact를 연결하려면 Registry를 참조하세요.
트레이닝 또는 평가 중 모델 출력을 시각화하는 것은 모델 트레이닝 방식을 실제로 이해하는 데 종종 필수적입니다.
Transformers Trainer의 콜백 시스템을 사용하면 모델의 텍스트 생성 출력 또는 기타 예측과 같은 추가적인 유용한 데이터를 W&B Tables에 로깅할 수 있습니다.
아래의 **사용자 지정 로깅 섹션**에서 트레이닝 중 평가 출력을 로깅하여 다음과 같은 W&B Table에 로깅하는 방법에 대한 전체 가이드를 참조하세요.
트레이닝이 Python 스크립트에 캡슐화된 경우 스크립트가 완료되면 W&B Run이 종료됩니다.
Jupyter 또는 Google Colab 노트북을 사용하는 경우 wandb.finish()를 호출하여 트레이닝이 완료되었음을 알려야 합니다.
trainer.train() # 트레이닝을 시작하고 W&B에 로깅
# 트레이닝 후 분석, 테스트, 기타 로깅된 코드
wandb.finish()
트레이닝 결과를 로깅했으면 W&B Dashboard에서 결과를 동적으로 탐색할 수 있습니다. 유연하고 대화형 시각화를 통해 한 번에 수십 개의 Runs를 비교하고, 흥미로운 발견을 확대하고, 복잡한 데이터에서 통찰력을 얻는 것이 쉽습니다.
TrainingArguments를 load_best_model_at_end=True로 Trainer에 전달하면 W&B는 가장 성능이 좋은 모델 체크포인트를 Artifacts에 저장합니다.
모델 체크포인트를 Artifacts로 저장하는 경우 Registry로 승격할 수 있습니다. Registry에서 다음을 수행할 수 있습니다.
WANDB_LOG_MODEL을 사용하여 모델을 W&B Artifacts에 저장한 경우 추가 트레이닝을 위해 또는 추론을 실행하기 위해 모델 가중치를 다운로드할 수 있습니다. 이전과 동일한 Hugging Face 아키텍처에 다시 로드하기만 하면 됩니다.
# 새 Run 만들기
with wandb.init(project="amazon_sentiment_analysis") as run:
# Artifact 이름 및 버전 전달
my_model_name = "model-bert-base-high-lr:latest"
my_model_artifact = run.use_artifact(my_model_name)
# 모델 가중치를 폴더에 다운로드하고 경로 반환
model_dir = my_model_artifact.download()
# 동일한 모델 클래스를 사용하여 해당 폴더에서 Hugging Face 모델 로드
model = AutoModelForSequenceClassification.from_pretrained(
model_dir, num_labels=num_labels
)
# 추가 트레이닝 또는 추론 실행
WANDB_LOG_MODEL='checkpoint'를 설정한 경우 model_dir을 TrainingArguments의 model_name_or_path 인수로 사용하고 resume_from_checkpoint=True를 Trainer에 전달하여 트레이닝을 재개할 수도 있습니다.
last_run_id = "xxxxxxxx" # wandb Workspace에서 run_id 가져오기
# run_id에서 W&B Run 재개
with wandb.init(
project=os.environ["WANDB_PROJECT"],
id=last_run_id,
resume="must",
) as run:
# Artifact를 Run에 연결
my_checkpoint_name = f"checkpoint-{last_run_id}:latest"
my_checkpoint_artifact = run.use_artifact(my_model_name)
# 체크포인트를 폴더에 다운로드하고 경로 반환
checkpoint_dir = my_checkpoint_artifact.download()
# 모델 및 Trainer 다시 초기화
model = AutoModelForSequenceClassification.from_pretrained(
"<model_name>", num_labels=num_labels
)
# 멋진 트레이닝 인수
training_args = TrainingArguments()
trainer = Trainer(model=model, args=training_args)
# 체크포인트 디렉터리를 사용하여 체크포인트에서 트레이닝을 재개해야 합니다.
trainer.train(resume_from_checkpoint=checkpoint_dir)
Transformers Trainer를 통해 W&B에 로깅하는 것은 Transformers 라이브러리의 WandbCallback에서 처리합니다. Hugging Face 로깅을 사용자 지정해야 하는 경우 WandbCallback을 서브클래싱하고 Trainer 클래스의 추가적인 메서드를 활용하는 추가적인 기능을 추가하여 이 콜백을 수정할 수 있습니다.
아래는 이 새로운 콜백을 HF Trainer에 추가하는 일반적인 패턴이며, 아래에는 평가 출력을 W&B Table에 로깅하는 코드 완성 예제가 있습니다.
# Trainer를 정상적으로 인스턴스화
trainer = Trainer()
# Trainer 오브젝트를 전달하여 새로운 로깅 콜백 인스턴스화
evals_callback = WandbEvalsCallback(trainer, tokenizer, ...)
# Trainer에 콜백 추가
trainer.add_callback(evals_callback)
# Trainer 트레이닝을 정상적으로 시작
trainer.train()
다음 섹션에서는 모델 예측을 실행하고 트레이닝 중에 평가 샘플을 W&B Table에 로깅하도록 WandbCallback을 사용자 지정하는 방법을 보여줍니다. Trainer 콜백의 on_evaluate 메서드를 사용하여 모든 eval_steps에서 수행합니다.
여기서는 토크나이저를 사용하여 모델 출력에서 예측 및 레이블을 디코딩하는 decode_predictions 함수를 작성했습니다.
그런 다음 예측 및 레이블에서 pandas DataFrame을 만들고 DataFrame에 epoch 열을 추가합니다.
마지막으로 DataFrame에서 wandb.Table을 만들고 wandb에 로깅합니다.
또한 예측을 freq 에포크마다 로깅하여 로깅 빈도를 제어할 수 있습니다.
참고: 일반적인 WandbCallback과 달리 이 사용자 지정 콜백은 Trainer를 인스턴스화한 후에 Trainer에 추가해야 하며 Trainer 초기화 중에는 추가하면 안 됩니다.
Trainer 인스턴스는 초기화 중에 콜백에 전달되기 때문입니다.
from transformers.integrations import WandbCallback
import pandas as pd
def decode_predictions(tokenizer, predictions):
labels = tokenizer.batch_decode(predictions.label_ids)
logits = predictions.predictions.argmax(axis=-1)
prediction_text = tokenizer.batch_decode(logits)
return {"labels": labels, "predictions": prediction_text}
class WandbPredictionProgressCallback(WandbCallback):
"""트레이닝 중에 모델 예측을 로깅하는 사용자 지정 WandbCallback입니다.
이 콜백은 트레이닝 중 각 로깅 단계에서 모델 예측과 레이블을 wandb.Table에 로깅합니다.
트레이닝이 진행됨에 따라 모델 예측을 시각화할 수 있습니다.
특성:
trainer (Trainer): Hugging Face Trainer 인스턴스입니다.
tokenizer (AutoTokenizer): 모델과 연결된 토크나이저입니다.
sample_dataset (Dataset): 예측 생성을 위한 유효성 검사 데이터셋의 서브셋입니다.
num_samples (int, optional): 예측 생성을 위해 유효성 검사 데이터셋에서 선택할 샘플 수입니다. 기본값은 100입니다.
freq (int, optional): 로깅 빈도입니다. 기본값은 2입니다.
"""
def __init__(self, trainer, tokenizer, val_dataset, num_samples=100, freq=2):
"""WandbPredictionProgressCallback 인스턴스를 초기화합니다.
인수:
trainer (Trainer): Hugging Face Trainer 인스턴스입니다.
tokenizer (AutoTokenizer): 모델과 연결된 토크나이저입니다.
val_dataset (Dataset): 유효성 검사 데이터셋입니다.
num_samples (int, optional): 예측 생성을 위해 유효성 검사 데이터셋에서 선택할 샘플 수입니다.
기본값은 100입니다.
freq (int, optional): 로깅 빈도입니다. 기본값은 2입니다.
"""
super().__init__()
self.trainer = trainer
self.tokenizer = tokenizer
self.sample_dataset = val_dataset.select(range(num_samples))
self.freq = freq
def on_evaluate(self, args, state, control, **kwargs):
super().on_evaluate(args, state, control, **kwargs)
# `freq` 에포크마다 예측을 로깅하여 로깅 빈도 제어
if state.epoch % self.freq == 0:
# 예측 생성
predictions = self.trainer.predict(self.sample_dataset)
# 예측 및 레이블 디코딩
predictions = decode_predictions(self.tokenizer, predictions)
# wandb.Table에 예측 추가
predictions_df = pd.DataFrame(predictions)
predictions_df["epoch"] = state.epoch
records_table = self._wandb.Table(dataframe=predictions_df)
# 테이블을 wandb에 로깅
self._wandb.log({"sample_predictions": records_table})
# 먼저 Trainer 인스턴스화
trainer = Trainer(
model=model,
args=training_args,
train_dataset=lm_datasets["train"],
eval_dataset=lm_datasets["validation"],
)
# WandbPredictionProgressCallback 인스턴스화
progress_callback = WandbPredictionProgressCallback(
trainer=trainer,
tokenizer=tokenizer,
val_dataset=lm_dataset["validation"],
num_samples=10,
freq=2,
)
# Trainer에 콜백 추가
trainer.add_callback(progress_callback)
자세한 예제는 이 colab을 참조하세요.
환경 변수를 설정하여 Trainer로 로깅되는 항목을 추가로 구성할 수 있습니다. W&B 환경 변수의 전체 목록은 여기에서 찾을 수 있습니다.
| 환경 변수 | 사용법 |
|---|---|
WANDB_PROJECT |
프로젝트 이름 지정(기본값: huggingface) |
WANDB_LOG_MODEL |
모델 체크포인트를 W&B Artifact로 로깅(기본값:
|
WANDB_WATCH |
모델 그레이디언트, 파라미터 또는 둘 다를 로깅할지 여부 설정
|
WANDB_DISABLED |
true로 설정하여 로깅을 완전히 끕니다(기본값: false) |
WANDB_SILENT |
true로 설정하여 wandb에서 인쇄된 출력을 표시하지 않습니다(기본값: false) |
WANDB_WATCH=all
WANDB_SILENT=true
%env WANDB_WATCH=all
%env WANDB_SILENT=true
wandb.init를 사용자 지정하는 방법은 무엇인가요?Trainer가 사용하는 WandbCallback은 Trainer가 초기화될 때 내부적으로 wandb.init를 호출합니다. 또는 Trainer를 초기화하기 전에 wandb.init를 호출하여 Run을 수동으로 설정할 수 있습니다. 이렇게 하면 W&B Run 구성을 완전히 제어할 수 있습니다.
init에 전달할 수 있는 예는 아래와 같습니다. wandb.init를 사용하는 방법에 대한 자세한 내용은 참조 설명서를 확인하세요.
wandb.init(
project="amazon_sentiment_analysis",
name="bert-base-high-lr",
tags=["baseline", "high-lr"],
group="bert",
)
다음은 Transformer 및 W&B 관련 기사 6가지입니다.
전체 리포트는 여기에서 읽어보세요.
전체 리포트는 여기에서 읽어보세요.
전체 리포트는 여기에서 읽어보세요.
전체 리포트는 여기에서 읽어보세요.
tf.keras.callbacks.EarlyStopping 콜백을 사용하는 것과 간단합니다.전체 리포트는 여기에서 읽어보세요.
사용자 지정 IMDB 데이터셋에서 감정 분석(이진 분류)을 위해 DistilBERT Transformer를 파인튜닝합니다.
전체 리포트는 여기에서 읽어보세요.
Hugging Face W&B 통합에 대한 문제, 질문 또는 기능 요청이 있는 경우 Hugging Face 포럼의 이 스레드에 게시하거나 Hugging Face Transformers GitHub 리포에 문제를 여유롭게 게시하세요.
Hugging Face Diffusers는 이미지, 오디오, 심지어 분자의 3D 구조를 생성하기 위한 최첨단 사전학습된 diffusion model을 위한 라이브러리입니다. Weights & Biases 인테그레이션은 사용 편의성을 유지하면서도 대화형 중앙 집중식 대시보드에 풍부하고 유연한 실험 추적, 미디어 시각화, 파이프라인 아키텍처 및 설정 관리를 추가합니다.
단 2줄의 코드를 추가하는 것만으로도 실험과 관련된 모든 프롬프트, 부정적 프롬프트, 생성된 미디어 및 설정을 기록할 수 있습니다. 다음은 로깅을 시작하기 위한 2줄의 코드입니다.
# import the autolog function
from wandb.integration.diffusers import autolog
# call the autolog before calling the pipeline
autolog(init=dict(project="diffusers_logging"))
 |
|---|
| 실험 결과가 기록되는 방식의 예시입니다. |
diffusers, transformers, accelerate 및 wandb를 설치합니다.
커맨드라인:
pip install --upgrade diffusers transformers accelerate wandb
노트북:
!pip install --upgrade diffusers transformers accelerate wandb
autolog를 사용하여 Weights & Biases run을 초기화하고 지원되는 모든 파이프라인 호출에서 입력 및 출력을 자동으로 추적합니다.
wandb.init()에 필요한 파라미터의 dictionary를 받는 init 파라미터로 autolog() 함수를 호출할 수 있습니다.
autolog()를 호출하면 Weights & Biases run이 초기화되고 지원되는 모든 파이프라인 호출에서 입력과 출력을 자동으로 추적합니다.
wandb.Table에 기록됩니다.지원되는 파이프라인 호출 목록은 [여기](https://github.com/wandb/wandb/blob/main/wandb/integration/diffusers/autologger.py#L12-L72)에서 확인할 수 있습니다. 이 인테그레이션의 새로운 기능을 요청하거나 관련 버그를 보고하려면 [https://github.com/wandb/wandb/issues](https://github.com/wandb/wandb/issues)에 이슈를 여십시오.
다음은 autolog의 간단한 엔드투엔드 예시입니다.
import torch
from diffusers import DiffusionPipeline
# import the autolog function
from wandb.integration.diffusers import autolog
# call the autolog before calling the pipeline
autolog(init=dict(project="diffusers_logging"))
# Initialize the diffusion pipeline
pipeline = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
).to("cuda")
# Define the prompts, negative prompts, and seed.
prompt = ["a photograph of an astronaut riding a horse", "a photograph of a dragon"]
negative_prompt = ["ugly, deformed", "ugly, deformed"]
generator = torch.Generator(device="cpu").manual_seed(10)
# call the pipeline to generate the images
images = pipeline(
prompt,
negative_prompt=negative_prompt,
num_images_per_prompt=2,
generator=generator,
)
import torch
from diffusers import DiffusionPipeline
import wandb
# import the autolog function
from wandb.integration.diffusers import autolog
# call the autolog before calling the pipeline
autolog(init=dict(project="diffusers_logging"))
# Initialize the diffusion pipeline
pipeline = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
).to("cuda")
# Define the prompts, negative prompts, and seed.
prompt = ["a photograph of an astronaut riding a horse", "a photograph of a dragon"]
negative_prompt = ["ugly, deformed", "ugly, deformed"]
generator = torch.Generator(device="cpu").manual_seed(10)
# call the pipeline to generate the images
images = pipeline(
prompt,
negative_prompt=negative_prompt,
num_images_per_prompt=2,
generator=generator,
)
# Finish the experiment
wandb.finish()
단일 실험의 결과:
여러 실험의 결과:
실험의 설정:
wandb.finish()를 명시적으로 호출해야 합니다. Python 스크립트를 실행할 때는 필요하지 않습니다.이 섹션에서는 StableDiffusionXLPipeline에서 생성된 잠재 변수가 해당 리파이너에 의해 개선되는 일반적인 Stable Diffusion XL + Refiner 워크플로우에서 autolog를 시연합니다.
import torch
from diffusers import StableDiffusionXLImg2ImgPipeline, StableDiffusionXLPipeline
from wandb.integration.diffusers import autolog
# initialize the SDXL base pipeline
base_pipeline = StableDiffusionXLPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0",
torch_dtype=torch.float16,
variant="fp16",
use_safetensors=True,
)
base_pipeline.enable_model_cpu_offload()
# initialize the SDXL refiner pipeline
refiner_pipeline = StableDiffusionXLImg2ImgPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-refiner-1.0",
text_encoder_2=base_pipeline.text_encoder_2,
vae=base_pipeline.vae,
torch_dtype=torch.float16,
use_safetensors=True,
variant="fp16",
)
refiner_pipeline.enable_model_cpu_offload()
prompt = "a photo of an astronaut riding a horse on mars"
negative_prompt = "static, frame, painting, illustration, sd character, low quality, low resolution, greyscale, monochrome, nose, cropped, lowres, jpeg artifacts, deformed iris, deformed pupils, bad eyes, semi-realistic worst quality, bad lips, deformed mouth, deformed face, deformed fingers, deformed toes standing still, posing"
# Make the experiment reproducible by controlling randomness.
# The seed would be automatically logged to WandB.
seed = 42
generator_base = torch.Generator(device="cuda").manual_seed(seed)
generator_refiner = torch.Generator(device="cuda").manual_seed(seed)
# Call WandB Autolog for Diffusers. This would automatically log
# the prompts, generated images, pipeline architecture and all
# associated experiment configs to Weights & Biases, thus making your
# image generation experiments easy to reproduce, share and analyze.
autolog(init=dict(project="sdxl"))
# Call the base pipeline to generate the latents
image = base_pipeline(
prompt=prompt,
negative_prompt=negative_prompt,
output_type="latent",
generator=generator_base,
).images[0]
# Call the refiner pipeline to generate the refined image
image = refiner_pipeline(
prompt=prompt,
negative_prompt=negative_prompt,
image=image[None, :],
generator=generator_refiner,
).images[0]
import torch
from diffusers import StableDiffusionXLImg2ImgPipeline, StableDiffusionXLPipeline
import wandb
from wandb.integration.diffusers import autolog
# initialize the SDXL base pipeline
base_pipeline = StableDiffusionXLPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0",
torch_dtype=torch.float16,
variant="fp16",
use_safetensors=True,
)
base_pipeline.enable_model_cpu_offload()
# initialize the SDXL refiner pipeline
refiner_pipeline = StableDiffusionXLImg2ImgPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-refiner-1.0",
text_encoder_2=base_pipeline.text_encoder_2,
vae=base_pipeline.vae,
torch_dtype=torch.float16,
use_safetensors=True,
variant="fp16",
)
refiner_pipeline.enable_model_cpu_offload()
prompt = "a photo of an astronaut riding a horse on mars"
negative_prompt = "static, frame, painting, illustration, sd character, low quality, low resolution, greyscale, monochrome, nose, cropped, lowres, jpeg artifacts, deformed iris, deformed pupils, bad eyes, semi-realistic worst quality, bad lips, deformed mouth, deformed face, deformed fingers, deformed toes standing still, posing"
# Make the experiment reproducible by controlling randomness.
# The seed would be automatically logged to WandB.
seed = 42
generator_base = torch.Generator(device="cuda").manual_seed(seed)
generator_refiner = torch.Generator(device="cuda").manual_seed(seed)
# Call WandB Autolog for Diffusers. This would automatically log
# the prompts, generated images, pipeline architecture and all
# associated experiment configs to Weights & Biases, thus making your
# image generation experiments easy to reproduce, share and analyze.
autolog(init=dict(project="sdxl"))
# Call the base pipeline to generate the latents
image = base_pipeline(
prompt=prompt,
negative_prompt=negative_prompt,
output_type="latent",
generator=generator_base,
).images[0]
# Call the refiner pipeline to generate the refined image
image = refiner_pipeline(
prompt=prompt,
negative_prompt=negative_prompt,
image=image[None, :],
generator=generator_refiner,
).images[0]
# Finish the experiment
wandb.finish()
Hugging Face AutoTrain은 자연어 처리 (NLP) 작업, 컴퓨터 비전 (CV) 작업, 음성 작업 및 테이블 형식 작업을 위한 최첨단 모델을 트레이닝하는 노코드 툴입니다.
Weights & Biases는 Hugging Face AutoTrain에 직접 통합되어 experiment 추적 및 config 관리를 제공합니다. 실험을 위해 CLI 코맨드에서 단일 파라미터를 사용하는 것만큼 쉽습니다.
autotrain-advanced 및 wandb를 설치합니다.
pip install --upgrade autotrain-advanced wandb
!pip install --upgrade autotrain-advanced wandb
이러한 변경 사항을 보여주기 위해 이 페이지에서는 수학 데이터셋에서 LLM을 fine-tune하여 GSM8k Benchmarks에서 pass@1로 SoTA 결과를 달성합니다.
Hugging Face AutoTrain은 제대로 작동하기 위해 CSV 커스텀 데이터셋에 특정 형식이 필요합니다.
트레이닝 파일에는 트레이닝에 사용되는 text 열이 있어야 합니다. 최상의 결과를 얻으려면 text 열의 데이터가 ### Human: Question?### Assistant: Answer. 형식을 준수해야 합니다. timdettmers/openassistant-guanaco에서 훌륭한 예를 검토하십시오.
그러나 MetaMathQA 데이터셋에는 query, response 및 type 열이 포함되어 있습니다. 먼저 이 데이터셋을 전처리합니다. type 열을 제거하고 query 및 response 열의 내용을 ### Human: Query?### Assistant: Response. 형식의 새 text 열로 결합합니다. 트레이닝은 결과 데이터셋인 rishiraj/guanaco-style-metamath를 사용합니다.
autotrain을 사용하여 트레이닝커맨드 라인 또는 노트북에서 autotrain advanced를 사용하여 트레이닝을 시작할 수 있습니다. --log 인수를 사용하거나 --log wandb를 사용하여 결과를 W&B run에 기록합니다.
autotrain llm \
--train \
--model HuggingFaceH4/zephyr-7b-alpha \
--project-name zephyr-math \
--log wandb \
--data-path data/ \
--text-column text \
--lr 2e-5 \
--batch-size 4 \
--epochs 3 \
--block-size 1024 \
--warmup-ratio 0.03 \
--lora-r 16 \
--lora-alpha 32 \
--lora-dropout 0.05 \
--weight-decay 0.0 \
--gradient-accumulation 4 \
--logging_steps 10 \
--fp16 \
--use-peft \
--use-int4 \
--merge-adapter \
--push-to-hub \
--token <huggingface-token> \
--repo-id <huggingface-repository-address>
# 하이퍼파라미터 설정
learning_rate = 2e-5
num_epochs = 3
batch_size = 4
block_size = 1024
trainer = "sft"
warmup_ratio = 0.03
weight_decay = 0.
gradient_accumulation = 4
lora_r = 16
lora_alpha = 32
lora_dropout = 0.05
logging_steps = 10
# 트레이닝 실행
!autotrain llm \
--train \
--model "HuggingFaceH4/zephyr-7b-alpha" \
--project-name "zephyr-math" \
--log "wandb" \
--data-path data/ \
--text-column text \
--lr str(learning_rate) \
--batch-size str(batch_size) \
--epochs str(num_epochs) \
--block-size str(block_size) \
--warmup-ratio str(warmup_ratio) \
--lora-r str(lora_r) \
--lora-alpha str(lora_alpha) \
--lora-dropout str(lora_dropout) \
--weight-decay str(weight_decay) \
--gradient-accumulation str(gradient_accumulation) \
--logging-steps str(logging_steps) \
--fp16 \
--use-peft \
--use-int4 \
--merge-adapter \
--push-to-hub \
--token str(hf_token) \
--repo-id "rishiraj/zephyr-math"
Hugging Face Accelerate는 분산 설정 전반에서 동일한 PyTorch 코드를 실행하여 대규모 모델 트레이닝 및 추론을 간소화하는 라이브러리입니다.
Accelerate에는 아래에서 사용하는 방법을 보여주는 Weights & Biases Tracker가 포함되어 있습니다. Accelerate Trackers에 대한 자세한 내용은 여기에서 해당 문서를 참조하십시오
Accelerate 및 Weights & Biases를 시작하려면 아래의 의사 코드를 따르십시오.
from accelerate import Accelerator
# Accelerator 오브젝트에게 wandb 로 로그하도록 지시
accelerator = Accelerator(log_with="wandb")
# wandb run을 초기화하고 wandb 파라미터 및 모든 설정 정보 전달
accelerator.init_trackers(
project_name="my_project",
config={"dropout": 0.1, "learning_rate": 1e-2}
init_kwargs={"wandb": {"entity": "my-wandb-team"}}
)
...
# `accelerator.log`를 호출하여 wandb에 로그, `step`은 선택 사항
accelerator.log({"train_loss": 1.12, "valid_loss": 0.8}, step=global_step)
# wandb tracker가 올바르게 완료되었는지 확인
accelerator.end_training()
자세히 설명하자면 다음이 필요합니다.
log_with="wandb"를 전달합니다.init_trackers 메소드를 호출하고 다음을 전달합니다.project_name을 통해 프로젝트 이름wandb.init에 전달할 파라미터는 init_kwargs에 전달config를 통해 wandb run에 로그할 다른 모든 실험 설정 정보.log 메소드를 사용하여 Weights & Biases에 로그합니다. step 인수는 선택 사항입니다..end_training을 호출합니다.W&B tracker에 액세스하려면 Accelerator.get_tracker() 메소드를 사용하십시오. tracker의 .name 속성에 해당하는 문자열을 전달하면 main 프로세스에서 tracker가 반환됩니다.
wandb_tracker = accelerator.get_tracker("wandb")
거기에서 평소처럼 wandb의 run 오브젝트와 상호 작용할 수 있습니다.
wandb_tracker.log_artifact(some_artifact_to_log)
Accelerate에 내장된 Trackers는 올바른 프로세스에서 자동으로 실행되므로, tracker가 main 프로세스에서만 실행되도록 설계된 경우 자동으로 실행됩니다.
Accelerate의 래핑을 완전히 제거하려면 다음과 같이 동일한 결과를 얻을 수 있습니다.
wandb_tracker = accelerator.get_tracker("wandb", unwrap=True)
with accelerator.on_main_process:
wandb_tracker.log_artifact(some_artifact_to_log)
다음은 즐겨보실 만한 Accelerate 관련 기사입니다.
전체 리포트는 여기에서 읽어보세요.
Hydra는 연구 및 기타 복잡한 애플리케이션 개발을 간소화하는 오픈 소스 Python 프레임워크입니다. 주요 기능은 구성 파일을 통해 계층적 설정을 동적으로 생성하고 커맨드 라인에서 이를 재정의하는 기능입니다.
W&B의 강력한 기능을 활용하면서 Hydra를 구성 관리용으로 계속 사용할 수 있습니다.
wandb.init 및 wandb.log를 사용하여 평소처럼 메트릭을 추적하세요. 여기서 wandb.entity 및 wandb.project는 hydra 설정 파일 내에 정의됩니다.
import wandb
@hydra.main(config_path="configs/", config_name="defaults")
def run_experiment(cfg):
run = wandb.init(entity=cfg.wandb.entity, project=cfg.wandb.project)
wandb.log({"loss": loss})
Hydra는 구성 사전에 연결하는 기본 방법으로 omegaconf를 사용합니다. OmegaConf의 사전은 기본 사전의 서브클래스가 아니므로 Hydra의 Config를 wandb.config에 직접 전달하면 대시보드에서 예기치 않은 결과가 발생합니다. omegaconf.DictConfig를 wandb.config에 전달하기 전에 기본 dict 유형으로 변환해야 합니다.
@hydra.main(config_path="configs/", config_name="defaults")
def run_experiment(cfg):
wandb.config = omegaconf.OmegaConf.to_container(
cfg, resolve=True, throw_on_missing=True
)
wandb.init(entity=cfg.wandb.entity, project=cfg.wandb.project)
wandb.log({"loss": loss})
model = Model(**wandb.config.model.configs)
프로세스가 시작될 때 멈추면 알려진 문제로 인해 발생할 수 있습니다. 이 문제를 해결하려면 다음을 수행하여 wandb.init에 추가 설정 파라미터를 추가하여 wandb의 다중 처리 프로토콜을 변경해 보세요.
wandb.init(settings=wandb.Settings(start_method="thread"))
또는 셸에서 전역 환경 변수를 설정합니다.
$ export WANDB_START_METHOD=thread
W&B Sweeps는 확장성이 뛰어난 하이퍼파라미터 검색 플랫폼으로, 최소한의 코딩 공간으로 W&B Experiments에 대한 흥미로운 통찰력과 시각화를 제공합니다. Sweeps는 코딩 요구 사항 없이 Hydra Projects와 원활하게 통합됩니다. 필요한 것은 스윕할 다양한 파라미터를 설명하는 구성 파일뿐입니다.
간단한 sweep.yaml 파일의 예는 다음과 같습니다.
program: main.py
method: bayes
metric:
goal: maximize
name: test/accuracy
parameters:
dataset:
values: [mnist, cifar10]
command:
- ${env}
- python
- ${program}
- ${args_no_hyphens}
스윕을 호출합니다.
wandb sweep sweep.yaml` \
W&B는 자동으로 프로젝트 내부에 스윕을 생성하고 각 머신에서 스윕을 실행할 수 있도록 wandb agent 코맨드를 반환합니다.
Hydra는 커맨드 앞에 +를 사용하여 기본 구성 파일에 없는 추가 파라미터를 커맨드 라인을 통해 전달할 수 있도록 지원합니다. 예를 들어 다음과 같이 호출하여 일부 값이 있는 추가 파라미터를 전달할 수 있습니다.
$ python program.py +experiment=some_experiment
Hydra Experiments를 구성하는 동안 수행하는 작업과 유사하게 이러한 + 구성을 스윕할 수 없습니다. 이를 해결하려면 기본 빈 파일로 experiment 파라미터를 초기화하고 W&B Sweep을 사용하여 각 호출에서 해당 빈 설정을 재정의할 수 있습니다. 자세한 내용은 이 W&B Report를 참조하세요.
W&B는 wandb v0.13.4부터 사용할 수 있는 Keras용 콜백 세 가지를 제공합니다. 기존 WandbCallback은 아래로 스크롤하세요.
WandbMetricsLogger : Experiment 추적에 이 콜백을 사용하세요. 트레이닝 및 검증 메트릭과 시스템 메트릭을 Weights & Biases에 기록합니다.
WandbModelCheckpoint : 모델 체크포인트를 Weight and Biases Artifacts에 기록하려면 이 콜백을 사용하세요.
WandbEvalCallback: 이 기본 콜백은 모델 예측값을 대화형 시각화를 위해 Weights and Biases Tables에 기록합니다.
이 새로운 콜백은 다음과 같은 특징이 있습니다.
WandbCallback)을 사용하는 데 따른 인지적 부담을 줄입니다.WandbMetricsLogger로 Experiments 추적WandbMetricsLogger는 on_epoch_end, on_batch_end 등과 같은 콜백 메서드가 인수로 사용하는 Keras의 logs 사전을 자동으로 기록합니다.
다음 항목을 추적합니다.
model.compile에 정의된 트레이닝 및 검증 메트릭.import wandb
from wandb.integration.keras import WandbMetricsLogger
# 새로운 W&B run 초기화
wandb.init(config={"bs": 12})
# WandbMetricsLogger를 model.fit에 전달
model.fit(
X_train, y_train, validation_data=(X_test, y_test), callbacks=[WandbMetricsLogger()]
)
WandbMetricsLogger 참조| 파라미터 | 설명 |
|---|---|
log_freq |
(epoch, batch 또는 int): epoch인 경우 각 에포크가 끝날 때 메트릭을 기록합니다. batch인 경우 각 배치가 끝날 때 메트릭을 기록합니다. int인 경우 해당 배치 수만큼 끝날 때 메트릭을 기록합니다. 기본값은 epoch입니다. |
initial_global_step |
(int): 학습률 스케줄러가 사용되고 일부 initial_epoch에서 트레이닝을 재개할 때 학습률을 올바르게 기록하려면 이 인수를 사용하세요. 이는 step_size * initial_step으로 계산할 수 있습니다. 기본값은 0입니다. |
WandbModelCheckpoint를 사용하여 모델 체크포인트WandbModelCheckpoint 콜백을 사용하여 Keras 모델(SavedModel 형식) 또는 모델 가중치를 주기적으로 저장하고 모델 버전 관리를 위해 wandb.Artifact로 W&B에 업로드합니다.
이 콜백은 tf.keras.callbacks.ModelCheckpoint에서 서브클래싱되므로 체크포인트 로직은 상위 콜백에서 처리합니다.
이 콜백은 다음을 저장합니다.
SavedModel 형식 또는 .h5 형식의 모델.WandbMetricsLogger와 함께 이 콜백을 사용하세요.
import wandb
from wandb.integration.keras import WandbMetricsLogger, WandbModelCheckpoint
# 새로운 W&B run 초기화
wandb.init(config={"bs": 12})
# WandbModelCheckpoint를 model.fit에 전달
model.fit(
X_train,
y_train,
validation_data=(X_test, y_test),
callbacks=[
WandbMetricsLogger(),
WandbModelCheckpoint("models"),
],
)
WandbModelCheckpoint 참조| 파라미터 | 설명 |
|---|---|
filepath |
(str): 모드 파일을 저장할 경로입니다. |
monitor |
(str): 모니터링할 메트릭 이름입니다. |
verbose |
(int): 상세 모드, 0 또는 1. 모드 0은 자동이고 모드 1은 콜백이 작업을 수행할 때 메시지를 표시합니다. |
save_best_only |
(Boolean): save_best_only=True인 경우 monitor 및 mode 속성으로 정의된 대로 최신 모델 또는 가장 적합하다고 간주되는 모델만 저장합니다. |
save_weights_only |
(Boolean): True인 경우 모델의 가중치만 저장합니다. |
mode |
(auto, min 또는 max): val_acc의 경우 max로 설정하고 val_loss의 경우 min으로 설정하는 식입니다. |
save_freq |
(“epoch” 또는 int): ‘epoch’를 사용하는 경우 콜백은 각 에포크 후에 모델을 저장합니다. 정수를 사용하는 경우 콜백은 이만큼의 배치가 끝날 때 모델을 저장합니다. val_acc 또는 val_loss와 같은 검증 메트릭을 모니터링할 때 이러한 메트릭은 에포크가 끝날 때만 사용할 수 있으므로 save_freq를 “epoch"로 설정해야 합니다. |
options |
(str): save_weights_only가 true인 경우 선택적 tf.train.CheckpointOptions 오브젝트이거나 save_weights_only가 false인 경우 선택적 tf.saved_model.SaveOptions 오브젝트입니다. |
initial_value_threshold |
(float): 모니터링할 메트릭의 부동 소수점 초기 “최상” 값입니다. |
기본적으로(save_freq="epoch") 콜백은 각 에포크 후에 체크포인트를 만들고 아티팩트로 업로드합니다. 특정 수의 배치 후에 체크포인트를 만들려면 save_freq를 정수로 설정합니다. N 에포크 후에 체크포인트를 만들려면 train 데이터 로더의 카디널리티를 계산하여 save_freq에 전달합니다.
WandbModelCheckpoint(
filepath="models/",
save_freq=int((trainloader.cardinality()*N).numpy())
)
TPU에서 체크포인트를 만드는 동안 UnimplementedError: File system scheme '[local]' not implemented 오류 메시지가 발생할 수 있습니다. 이는 모델 디렉토리(filepath)가 클라우드 스토리지 버킷 경로(gs://bucket-name/...)를 사용해야 하고 이 버킷에 TPU 서버에서 엑세스할 수 있어야 하기 때문에 발생합니다. 그러나 체크포인트를 만드는 데 로컬 경로를 사용할 수 있으며, 이는 Artifacts로 업로드됩니다.
checkpoint_options = tf.saved_model.SaveOptions(experimental_io_device="/job:localhost")
WandbModelCheckpoint(
filepath="models/,
options=checkpoint_options,
)
WandbEvalCallback을 사용하여 모델 예측 시각화WandbEvalCallback은 주로 모델 예측을 위해, 그리고 부차적으로 데이터셋 시각화를 위해 Keras 콜백을 빌드하는 데 사용되는 추상 기본 클래스입니다.
이 추상 콜백은 데이터셋 및 작업과 관련하여 독립적입니다. 이를 사용하려면 이 기본 WandbEvalCallback 콜백 클래스에서 상속하고 add_ground_truth 및 add_model_prediction 메서드를 구현합니다.
WandbEvalCallback은 다음과 같은 메서드를 제공하는 유틸리티 클래스입니다.
wandb.Table 인스턴스를 만듭니다.wandb.Artifact로 기록합니다.on_train_begin에 데이터 테이블을 기록합니다.on_epoch_end에 예측 테이블을 기록합니다.다음 예제에서는 이미지 분류 작업에 WandbClfEvalCallback을 사용합니다. 이 예제 콜백은 검증 데이터(data_table)를 W&B에 기록하고 추론을 수행한 다음 모든 에포크가 끝날 때 예측(pred_table)을 W&B에 기록합니다.
import wandb
from wandb.integration.keras import WandbMetricsLogger, WandbEvalCallback
# 모델 예측 시각화 콜백 구현
class WandbClfEvalCallback(WandbEvalCallback):
def __init__(
self, validation_data, data_table_columns, pred_table_columns, num_samples=100
):
super().__init__(data_table_columns, pred_table_columns)
self.x = validation_data[0]
self.y = validation_data[1]
def add_ground_truth(self, logs=None):
for idx, (image, label) in enumerate(zip(self.x, self.y)):
self.data_table.add_data(idx, wandb.Image(image), label)
def add_model_predictions(self, epoch, logs=None):
preds = self.model.predict(self.x, verbose=0)
preds = tf.argmax(preds, axis=-1)
table_idxs = self.data_table_ref.get_index()
for idx in table_idxs:
pred = preds[idx]
self.pred_table.add_data(
epoch,
self.data_table_ref.data[idx][0],
self.data_table_ref.data[idx][1],
self.data_table_ref.data[idx][2],
pred,
)
# ...
# 새로운 W&B run 초기화
wandb.init(config={"hyper": "parameter"})
# 콜백을 Model.fit에 추가
model.fit(
X_train,
y_train,
validation_data=(X_test, y_test),
callbacks=[
WandbMetricsLogger(),
WandbClfEvalCallback(
validation_data=(X_test, y_test),
data_table_columns=["idx", "image", "label"],
pred_table_columns=["epoch", "idx", "image", "label", "pred"],
),
],
)
WandbEvalCallback 참조| 파라미터 | 설명 |
|---|---|
data_table_columns |
(list) data_table의 열 이름 목록입니다. |
pred_table_columns |
(list) pred_table의 열 이름 목록입니다. |
on_train_begin 메서드가 호출되면 data_table을 W&B에 기록합니다. W&B Artifact로 업로드되면 data_table_ref 클래스 변수를 사용하여 엑세스할 수 있는 이 테이블에 대한 참조가 생성됩니다. data_table_ref는 self.data_table_ref[idx][n]과 같이 인덱싱할 수 있는 2D 목록이며, 여기서 idx는 행 번호이고 n은 열 번호입니다. 아래 예에서 사용법을 살펴보겠습니다.
on_train_begin 또는 on_epoch_end 메서드를 재정의하여 더 세분화된 제어를 할 수 있습니다. N 배치 후에 샘플을 기록하려면 on_train_batch_end 메서드를 구현하면 됩니다.
WandbEvalCallback을 상속하여 모델 예측 시각화를 위한 콜백을 구현하고 있으며 설명이 필요하거나 수정해야 할 사항이 있는 경우 문제를 열어 알려주시기 바랍니다.WandbCallback [기존]W&B 라이브러리 WandbCallback 클래스를 사용하여 model.fit에서 추적된 모든 메트릭 및 손실 값을 자동으로 저장합니다.
import wandb
from wandb.integration.keras import WandbCallback
wandb.init(config={"hyper": "parameter"})
... # Keras에서 모델을 설정하는 코드
# 콜백을 model.fit에 전달
model.fit(
X_train, y_train, validation_data=(X_test, y_test), callbacks=[WandbCallback()]
)
짧은 비디오 1분 이내에 Keras 및 Weights & Biases 시작하기를 시청할 수 있습니다.
자세한 내용은 비디오 Weights & Biases를 Keras와 통합하기를 시청하세요. Colab Jupyter Notebook을 검토할 수 있습니다.
WandbCallback 클래스는 모니터링할 메트릭 지정, 가중치 및 그레이디언트 추적, training_data 및 validation_data에 대한 예측 기록 등 다양한 로깅 구성 옵션을 지원합니다.
자세한 내용은 keras.WandbCallback에 대한 참조 문서를 확인하세요.
WandbCallback
keras_model.compile()에 전달된 항목)에서 기록 데이터를 자동으로 기록합니다.monitor 및 mode 속성으로 정의된 대로 “최상” 트레이닝 단계와 연결된 run에 대한 요약 메트릭을 설정합니다. 기본값은 최소 val_loss가 있는 에포크입니다. WandbCallback은 기본적으로 최상의 epoch와 연결된 모델을 저장합니다.WandbCallback 참조| 인수 | |
|---|---|
monitor |
(str) 모니터링할 메트릭 이름입니다. 기본값은 val_loss입니다. |
mode |
(str) {auto, min, max} 중 하나입니다. min - 모니터가 최소화될 때 모델 저장 max - 모니터가 최대화될 때 모델 저장 auto - 모델을 저장할 시기를 추측하려고 시도합니다(기본값). |
save_model |
True - 모니터가 이전의 모든 에포크보다 나을 때 모델 저장 False - 모델을 저장하지 않음 |
save_graph |
(boolean) True인 경우 모델 그래프를 wandb에 저장합니다(기본값은 True). |
save_weights_only |
(boolean) True인 경우 모델의 가중치(model.save_weights(filepath))만 저장합니다. 그렇지 않으면 전체 모델을 저장합니다. |
log_weights |
(boolean) True인 경우 모델 레이어의 가중치 히스토그램을 저장합니다. |
log_gradients |
(boolean) True인 경우 트레이닝 그레이디언트의 히스토그램을 기록합니다. |
training_data |
(tuple) model.fit에 전달된 것과 동일한 형식 (X,y)입니다. 그레이디언트 계산에 필요합니다. log_gradients가 True인 경우 필수입니다. |
validation_data |
(tuple) model.fit에 전달된 것과 동일한 형식 (X,y)입니다. wandb가 시각화할 데이터 세트입니다. 이 필드를 설정하면 모든 에포크에서 wandb는 적은 수의 예측을 수행하고 나중에 시각화할 수 있도록 결과를 저장합니다. |
generator |
(generator) wandb가 시각화할 검증 데이터를 반환하는 생성기입니다. 이 생성기는 튜플 (X,y)를 반환해야 합니다. wandb가 특정 데이터 예제를 시각화하려면 validate_data 또는 생성기를 설정해야 합니다. |
validation_steps |
(int) validation_data가 생성기인 경우 전체 검증 세트에 대해 생성기를 실행할 단계 수입니다. |
labels |
(list) wandb로 데이터를 시각화하는 경우 이 레이블 목록은 여러 클래스로 분류기를 빌드하는 경우 숫자 출력을 이해하기 쉬운 문자열로 변환합니다. 이진 분류기의 경우 두 개의 레이블 목록([false 레이블, true 레이블])을 전달할 수 있습니다. validate_data 및 generator가 모두 false인 경우 아무 작업도 수행하지 않습니다. |
predictions |
(int) 각 에포크에서 시각화를 위해 수행할 예측 수이며, 최대값은 100입니다. |
input_type |
(string) 시각화를 돕기 위한 모델 입력 유형입니다. (image, images, segmentation_mask) 중 하나일 수 있습니다. |
output_type |
(string) 시각화를 돕기 위한 모델 출력 유형입니다. (image, images, segmentation_mask) 중 하나일 수 있습니다. |
log_evaluation |
(boolean) True인 경우 각 에포크에서 검증 데이터와 모델의 예측을 포함하는 Table을 저장합니다. 자세한 내용은 validation_indexes, validation_row_processor 및 output_row_processor를 참조하세요. |
class_colors |
([float, float, float]) 입력 또는 출력이 분할 마스크인 경우 각 클래스에 대한 rgb 튜플(범위 0-1)을 포함하는 배열입니다. |
log_batch_frequency |
(integer) None인 경우 콜백은 모든 에포크를 기록합니다. 정수로 설정된 경우 콜백은 log_batch_frequency 배치마다 트레이닝 메트릭을 기록합니다. |
log_best_prefix |
(string) None인 경우 추가 요약 메트릭을 저장하지 않습니다. 문자열로 설정된 경우 모니터링된 메트릭과 에포크 앞에 접두사를 붙이고 결과를 요약 메트릭으로 저장합니다. |
validation_indexes |
([wandb.data_types._TableLinkMixin]) 각 검증 예제와 연결할 인덱스 키의 정렬된 목록입니다. log_evaluation이 True이고 validation_indexes를 제공하는 경우 검증 데이터 Table을 만들지 않습니다. 대신 각 예측을 TableLinkMixin으로 표시된 행과 연결합니다. 행 키 목록을 가져오려면 Table.get_index()를 사용하세요. |
validation_row_processor |
(Callable) 검증 데이터에 적용할 함수로, 일반적으로 데이터를 시각화하는 데 사용됩니다. 이 함수는 ndx(int)와 row(dict)를 받습니다. 모델에 입력이 하나 있는 경우 row["input"]에 행에 대한 입력 데이터가 포함됩니다. 그렇지 않으면 입력 슬롯의 이름이 포함됩니다. 적합 함수가 대상이 하나인 경우 row["target"]에 행에 대한 대상 데이터가 포함됩니다. 그렇지 않으면 출력 슬롯의 이름이 포함됩니다. 예를 들어 입력 데이터가 단일 배열인 경우 데이터를 이미지로 시각화하려면 lambda ndx, row: {"img": wandb.Image(row["input"])}를 프로세서로 제공합니다. log_evaluation이 False이거나 validation_indexes가 있는 경우 무시됩니다. |
output_row_processor |
(Callable) validation_row_processor와 동일하지만 모델의 출력에 적용됩니다. row["output"]에 모델 출력 결과가 포함됩니다. |
infer_missing_processors |
(Boolean) 누락된 경우 validation_row_processor 및 output_row_processor를 유추할지 여부를 결정합니다. 기본값은 True입니다. labels를 제공하는 경우 W&B는 적절한 분류 유형 프로세서를 유추하려고 시도합니다. |
log_evaluation_frequency |
(int) 평가 결과를 기록하는 빈도를 결정합니다. 기본값은 트레이닝이 끝날 때만 기록하는 0입니다. 모든 에포크를 기록하려면 1로 설정하고, 다른 모든 에포크를 기록하려면 2로 설정하는 식입니다. log_evaluation이 False인 경우 아무런 효과가 없습니다. |
wandb로 Keras 멀티프로세싱을 어떻게 사용합니까?use_multiprocessing=True를 설정하면 다음 오류가 발생할 수 있습니다.
Error("You must call wandb.init() before wandb.config.batch_size")
해결 방법:
Sequence 클래스 구성에서 wandb.init(group='...')를 추가합니다.main에서 if __name__ == "__main__":를 사용하고 있는지 확인하고 스크립트 로직의 나머지 부분을 그 안에 넣습니다.Kubeflow Pipelines (kfp) 는 Docker 컨테이너를 기반으로 구축된 휴대 가능하고 확장 가능한 기계 학습(ML) 워크플로우를 구축하고 배포하기 위한 플랫폼입니다.
이 통합을 통해 사용자는 데코레이터를 kfp python functional components에 적용하여 파라미터와 Artifacts를 W&B에 자동으로 기록할 수 있습니다.
이 기능은 wandb==0.12.11에서 활성화되었으며 kfp<2.0.0이 필요합니다.
API 키는 사용자의 머신을 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리를 설치하고 로그인합니다로컬에서 wandb 라이브러리를 설치하고 로그인하려면 다음을 수행합니다.
WANDB_API_KEY 환경 변수를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
@wandb_log 데코레이터를 추가하고 평소처럼 컴포넌트를 생성합니다. 이렇게 하면 파이프라인을 실행할 때마다 입력/출력 파라미터와 Artifacts가 자동으로 W&B에 기록됩니다.
from kfp import components
from wandb.integration.kfp import wandb_log
@wandb_log
def add(a: float, b: float) -> float:
return a + b
add = components.create_component_from_func(add)
환경 변수를 컨테이너에 명시적으로 전달해야 할 수 있습니다. 양방향 연결을 위해서는 환경 변수 WANDB_KUBEFLOW_URL을 Kubeflow Pipelines 인스턴스의 기본 URL로 설정해야 합니다. 예를 들어, https://kubeflow.mysite.com과 같습니다.
import os
from kubernetes.client.models import V1EnvVar
def add_wandb_env_variables(op):
env = {
"WANDB_API_KEY": os.getenv("WANDB_API_KEY"),
"WANDB_BASE_URL": os.getenv("WANDB_BASE_URL"),
}
for name, value in env.items():
op = op.add_env_variable(V1EnvVar(name, value))
return op
@dsl.pipeline(name="example-pipeline")
def example_pipeline(param1: str, param2: int):
conf = dsl.get_pipeline_conf()
conf.add_op_transformer(add_wandb_env_variables)
W&B로 로깅된 Kubeflow Pipelines UI에서 Run을 클릭합니다.
Input/Output 및 ML Metadata 탭에서 입력 및 출력에 대한 자세한 내용을 확인합니다.Visualizations 탭에서 W&B 웹 앱을 봅니다.
웹 앱 UI는 Kubeflow Pipelines의 Visualizations 탭과 동일한 콘텐츠를 가지고 있지만 공간이 더 넓습니다. 여기에서 웹 앱 UI에 대해 자세히 알아보세요.
다음은 Kubeflow Pipelines 컨셉에서 W&B로의 매핑입니다.
| Kubeflow Pipelines | W&B | W&B의 위치 |
|---|---|---|
| Input Scalar | config |
Overview 탭 |
| Output Scalar | summary |
Overview 탭 |
| Input Artifact | Input Artifact | Artifacts 탭 |
| Output Artifact | Output Artifact | Artifacts 탭 |
로깅을 더 세밀하게 제어하려면 컴포넌트에 wandb.log 및 wandb.log_artifact 호출을 추가할 수 있습니다.
wandb.log_artifacts 호출 사용아래 예에서는 모델을 트레이닝하고 있습니다. @wandb_log 데코레이터는 관련 입력 및 출력을 자동으로 추적합니다. 트레이닝 프로세스를 기록하려면 다음과 같이 로깅을 명시적으로 추가할 수 있습니다.
@wandb_log
def train_model(
train_dataloader_path: components.InputPath("dataloader"),
test_dataloader_path: components.InputPath("dataloader"),
model_path: components.OutputPath("pytorch_model"),
):
...
for epoch in epochs:
for batch_idx, (data, target) in enumerate(train_dataloader):
...
if batch_idx % log_interval == 0:
wandb.log(
{"epoch": epoch, "step": batch_idx * len(data), "loss": loss.item()}
)
...
wandb.log_artifact(model_artifact)
지원하는 프레임워크 통합을 사용하는 경우 콜백을 직접 전달할 수도 있습니다.
@wandb_log
def train_model(
train_dataloader_path: components.InputPath("dataloader"),
test_dataloader_path: components.InputPath("dataloader"),
model_path: components.OutputPath("pytorch_model"),
):
from pytorch_lightning.loggers import WandbLogger
from pytorch_lightning import Trainer
trainer = Trainer(logger=WandbLogger())
... # do training
wandb 라이브러리에는 LightGBM을 위한 특별한 콜백이 포함되어 있습니다. 또한 Weights & Biases의 일반적인 로깅 기능을 사용하여 하이퍼파라미터 스윕과 같은 대규모 Experiments를 쉽게 추적할 수 있습니다.
from wandb.integration.lightgbm import wandb_callback, log_summary
import lightgbm as lgb
# Log metrics to W&B
gbm = lgb.train(..., callbacks=[wandb_callback()])
# Log feature importance plot and upload model checkpoint to W&B
log_summary(gbm, save_model_checkpoint=True)
모델에서 최대 성능을 얻으려면 트리 깊이 및 학습률과 같은 하이퍼파라미터를 조정해야 합니다. Weights & Biases에는 대규모 하이퍼파라미터 테스트 Experiments를 구성, 조정 및 분석하기 위한 강력한 툴킷인 Sweeps가 포함되어 있습니다.
이러한 툴에 대해 자세히 알아보고 XGBoost와 함께 Sweeps를 사용하는 방법에 대한 예제를 보려면 이 대화형 Colab 노트북을 확인하세요.
Metaflow는 ML 워크플로우를 생성하고 실행하기 위해 Netflix에서 만든 프레임워크입니다.
이 인테그레이션을 통해 사용자는 Metaflow 단계 및 흐름에 데코레이터를 적용하여 파라미터와 Artifacts를 W&B에 자동으로 기록할 수 있습니다.
API 키는 사용자의 장치를 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인wandb 라이브러리를 로컬에 설치하고 로그인하려면:
WANDB_API_KEY 환경 변수를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install -Uqqq metaflow fastcore wandb
wandb login
pip install -Uqqq metaflow fastcore wandb
import wandb
wandb.login()
!pip install -Uqqq metaflow fastcore wandb
import wandb
wandb.login()
단계를 데코레이팅하면 해당 단계 내의 특정 유형에 대한 로깅이 켜지거나 꺼집니다.
이 예에서는 start의 모든 데이터셋과 Models가 기록됩니다.
from wandb.integration.metaflow import wandb_log
class WandbExampleFlow(FlowSpec):
@wandb_log(datasets=True, models=True, settings=wandb.Settings(...))
@step
def start(self):
self.raw_df = pd.read_csv(...). # pd.DataFrame -> upload as dataset
self.model_file = torch.load(...) # nn.Module -> upload as model
self.next(self.transform)
흐름을 데코레이팅하는 것은 구성 단계를 모두 기본값으로 데코레이팅하는 것과 같습니다.
이 경우 WandbExampleFlow의 모든 단계는 기본적으로 데이터셋과 Models를 기록하도록 기본 설정되어 있습니다. 이는 각 단계를 @wandb_log(datasets=True, models=True)로 데코레이팅하는 것과 같습니다.
from wandb.integration.metaflow import wandb_log
@wandb_log(datasets=True, models=True) # decorate all @step
class WandbExampleFlow(FlowSpec):
@step
def start(self):
self.raw_df = pd.read_csv(...). # pd.DataFrame -> upload as dataset
self.model_file = torch.load(...) # nn.Module -> upload as model
self.next(self.transform)
흐름을 데코레이팅하는 것은 모든 단계를 기본값으로 데코레이팅하는 것과 같습니다. 즉, 나중에 다른 @wandb_log로 단계를 데코레이팅하면 흐름 수준 데코레이션이 재정의됩니다.
이 예에서:
start 및 mid는 데이터셋과 Models를 모두 기록합니다.end는 데이터셋과 Models를 모두 기록하지 않습니다.from wandb.integration.metaflow import wandb_log
@wandb_log(datasets=True, models=True) # same as decorating start and mid
class WandbExampleFlow(FlowSpec):
# this step will log datasets and models
@step
def start(self):
self.raw_df = pd.read_csv(...). # pd.DataFrame -> upload as dataset
self.model_file = torch.load(...) # nn.Module -> upload as model
self.next(self.mid)
# this step will also log datasets and models
@step
def mid(self):
self.raw_df = pd.read_csv(...). # pd.DataFrame -> upload as dataset
self.model_file = torch.load(...) # nn.Module -> upload as model
self.next(self.end)
# this step is overwritten and will NOT log datasets OR models
@wandb_log(datasets=False, models=False)
@step
def end(self):
self.raw_df = pd.read_csv(...).
self.model_file = torch.load(...)
wandb 클라이언트 라이브러리를 사용하여 기록 중인 원래 Python 프로세스 내부, 웹 앱 UI 또는 Public API를 사용하여 프로그램 방식으로 캡처한 정보에 액세스할 수 있습니다. Parameter는 W&B의 config에 저장되며 Overview 탭에서 찾을 수 있습니다. datasets, models 및 others는 W&B Artifacts에 저장되며 Artifacts 탭에서 찾을 수 있습니다. 기본 Python 유형은 W&B의 summary 사전에 저장되며 Overview 탭에서 찾을 수 있습니다. API를 사용하여 외부에서 이 정보를 프로그램 방식으로 가져오는 방법에 대한 자세한 내용은 Public API 가이드를 참조하십시오.
| 데이터 | 클라이언트 라이브러리 | UI |
|---|---|---|
Parameter(...) |
wandb.config |
Overview 탭, Config |
datasets, models, others |
wandb.use_artifact("{var_name}:latest") |
Artifacts 탭 |
기본 Python 유형 (dict, list, str, etc.) |
wandb.summary |
Overview 탭, Summary |
wandb_log kwargs| kwarg | 옵션 |
|---|---|
datasets |
|
models |
|
others |
|
settings |
기본적으로:
|
wandb_log는 인스턴스 변수만 기록합니다. 로컬 변수는 절대 기록되지 않습니다. 이는 불필요한 데이터 로깅을 피하는 데 유용합니다.
현재 다음과 같은 유형을 지원합니다.
| 로깅 설정 | 유형 |
|---|---|
| 기본값 (항상 켜짐) |
|
datasets |
|
models |
|
others |
|
| 변수 종류 | 행동 | 예 | 데이터 유형 |
|---|---|---|---|
| 인스턴스 | 자동 기록 | self.accuracy |
float |
| 인스턴스 | datasets=True인 경우 기록 |
self.df |
pd.DataFrame |
| 인스턴스 | datasets=False인 경우 기록 안 함 |
self.df |
pd.DataFrame |
| 로컬 | 절대 기록 안 함 | accuracy |
float |
| 로컬 | 절대 기록 안 함 | df |
pd.DataFrame |
예. Artifact가 A 단계의 출력이고 B 단계의 입력인 경우 계보 DAG가 자동으로 구성됩니다.
이 행동의 예는 이 노트북과 해당 W&B Artifacts 페이지를 참조하십시오.
MMEngine은 OpenMMLab에서 만든 PyTorch 기반 딥러닝 모델 트레이닝을 위한 기본 라이브러리입니다. MMEngine은 OpenMMLab 알고리즘 라이브러리를 위한 차세대 트레이닝 아키텍처를 구현하여 OpenMMLab 내의 30개 이상의 알고리즘 라이브러리에 통합된 실행 기반을 제공합니다. 핵심 구성 요소로는 트레이닝 엔진, 평가 엔진 및 모듈 관리가 있습니다.
Weights and Biases는 전용 WandbVisBackend를 통해 MMEngine에 직접 통합되어 다음 작업을 수행할 수 있습니다.
openmim 및 wandb를 설치합니다.
pip install -q -U openmim wandb
!pip install -q -U openmim wandb
다음으로, mim을 사용하여 mmengine 및 mmcv를 설치합니다.
mim install -q mmengine mmcv
!mim install -q mmengine mmcv
WandbVisBackend 사용이 섹션에서는 mmengine.runner.Runner를 사용하여 WandbVisBackend를 사용하는 일반적인 워크플로우를 보여줍니다.
시각화 config에서 visualizer를 정의합니다.
from mmengine.visualization import Visualizer
# define the visualization configs
visualization_cfg = dict(
name="wandb_visualizer",
vis_backends=[
dict(
type='WandbVisBackend',
init_kwargs=dict(project="mmengine"),
)
],
save_dir="runs/wandb"
)
# get the visualizer from the visualization configs
visualizer = Visualizer.get_instance(**visualization_cfg)
[W&B run 초기화](/ko/ref/python/init/) 입력 파라미터에 대한 인수의 사전을 `init_kwargs`에 전달합니다.
visualizer로 runner를 초기화하고 runner.train()을 호출합니다.
from mmengine.runner import Runner
# build the mmengine Runner which is a training helper for PyTorch
runner = Runner(
model,
work_dir='runs/gan/',
train_dataloader=train_dataloader,
train_cfg=train_cfg,
optim_wrapper=opt_wrapper_dict,
visualizer=visualizer, # pass the visualizer
)
# start training
runner.train()
WandbVisBackend 사용WandbVisBackend를 사용하여 MMDetection과 같은 OpenMMLab 컴퓨터 비전 라이브러리로 Experiments를 쉽게 추적할 수도 있습니다.
# inherit base configs from the default runtime configs
_base_ = ["../_base_/default_runtime.py"]
# Assign the `WandbVisBackend` config dictionary to the
# `vis_backends` of the `visualizer` from the base configs
_base_.visualizer.vis_backends = [
dict(
type='WandbVisBackend',
init_kwargs={
'project': 'mmdet',
'entity': 'geekyrakshit'
},
),
]
Meta AI의 MMF 라이브러리의 WandbLogger 클래스를 사용하면 Weights & Biases가 트레이닝/유효성 검사 메트릭, 시스템 (GPU 및 CPU) 메트릭, 모델 체크포인트 및 구성 파라미터를 기록할 수 있습니다.
MMF의 WandbLogger에서 현재 지원하는 기능은 다음과 같습니다.
wandb 로깅을 활성화하고 사용자 정의하기 위해 MMF 구성에서 다음 옵션을 사용할 수 있습니다.
training:
wandb:
enabled: true
# 엔터티는 Runs을 보내는 사용자 이름 또는 팀 이름입니다.
# 기본적으로 사용자 계정에 Run을 기록합니다.
entity: null
# wandb로 실험을 기록하는 동안 사용할 프로젝트 이름
project: mmf
# wandb로 프로젝트에서 실험을 기록하는 데 사용할 실험/run 이름
# 기본 실험 이름은 다음과 같습니다: ${training.experiment_name}
name: ${training.experiment_name}
# 모델 체크포인트 설정을 켜고 체크포인트를 W&B Artifacts에 저장합니다
log_model_checkpoint: true
# wandb.init()에 전달할 추가 인수 값입니다.
# 사용 가능한 인수를 보려면 /ref/python/init에서 설명서를 확인하세요(예:
# job_type: 'train'
# tags: ['tag1', 'tag2']
env:
# wandb 메타데이터가 저장될 디렉토리의 경로를 변경하려면(기본값: env.log_dir):
wandb_logdir: ${env:MMF_WANDB_LOGDIR,}
Composer는 신경망을 더 좋고, 더 빠르고, 더 저렴하게 트레이닝하기 위한 라이브러리입니다. 여기에는 신경망 트레이닝을 가속화하고 일반화를 개선하기 위한 최첨단 메소드가 많이 포함되어 있으며, 다양한 개선 사항을 쉽게 구성 할 수 있는 선택적 Trainer API가 함께 제공됩니다.
Weights & Biases는 ML Experiments 로깅을 위한 간단한 래퍼를 제공합니다. 하지만 직접 결합할 필요가 없습니다. W&B는 WandBLogger를 통해 Composer 라이브러리에 직접 통합됩니다.
from composer import Trainer
from composer.loggers import WandBLogger
trainer = Trainer(..., logger=WandBLogger())
WandBLogger 사용Composer 라이브러리는 Trainer에서 WandBLogger 클래스를 사용하여 메트릭을 Weights and Biases에 기록합니다. 로거를 인스턴스화하고 Trainer에 전달하는 것만큼 간단합니다.
wandb_logger = WandBLogger(project="gpt-5", log_artifacts=True)
trainer = Trainer(logger=wandb_logger)
아래는 WandbLogger에 대한 파라미터입니다. 전체 목록 및 설명은 Composer 설명서를 참조하세요.
| 파라미터 | 설명 |
|---|---|
project |
W&B 프로젝트 이름 (str, optional) |
group |
W&B 그룹 이름 (str, optional) |
name |
W&B run 이름. 지정하지 않으면 State.run_name이 사용됩니다 (str, optional) |
entity |
사용자 이름 또는 W&B Team 이름과 같은 W&B 엔티티 이름 (str, optional) |
tags |
W&B 태그 (List[str], optional) |
log_artifacts |
체크포인트를 wandb에 기록할지 여부, 기본값: false (bool, optional) |
rank_zero_only |
rank-zero 프로세스에서만 기록할지 여부. Artifacts를 기록할 때는 모든 순위에서 기록하는 것이 좋습니다. 순위 ≥1의 Artifacts는 저장되지 않으므로 관련 정보가 삭제될 수 있습니다. 예를 들어 Deepspeed ZeRO를 사용하는 경우 모든 순위의 Artifacts 없이는 체크포인트에서 복원할 수 없습니다. 기본값: True (bool, optional) |
init_kwargs |
wandb config 등과 같은 wandb.init에 전달할 파라미터 전체 목록은 여기에서 wandb.init이 허용하는 파라미터를 참조하세요. |
일반적인 사용법은 다음과 같습니다.
init_kwargs = {"notes":"이 실험에서 더 높은 학습률 테스트",
"config":{"arch":"Llama",
"use_mixed_precision":True
}
}
wandb_logger = WandBLogger(log_artifacts=True, init_kwargs=init_kwargs)
Composer의 콜백 시스템을 사용하여 WandBLogger를 통해 Weights & Biases에 로깅할 시기를 제어할 수 있습니다. 이 예에서는 유효성 검사 이미지 및 예측 샘플이 기록됩니다.
import wandb
from composer import Callback, State, Logger
class LogPredictions(Callback):
def __init__(self, num_samples=100, seed=1234):
super().__init__()
self.num_samples = num_samples
self.data = []
def eval_batch_end(self, state: State, logger: Logger):
"""배치당 예측을 계산하고 self.data에 저장합니다."""
if state.timer.epoch == state.max_duration: #마지막 val 에포크에서
if len(self.data) < self.num_samples:
n = self.num_samples
x, y = state.batch_pair
outputs = state.outputs.argmax(-1)
data = [[wandb.Image(x_i), y_i, y_pred] for x_i, y_i, y_pred in list(zip(x[:n], y[:n], outputs[:n]))]
self.data += data
def eval_end(self, state: State, logger: Logger):
"wandb.Table을 생성하고 기록합니다."
columns = ['image', 'ground truth', 'prediction']
table = wandb.Table(columns=columns, data=self.data[:self.num_samples])
wandb.log({'sample_table':table}, step=int(state.timer.batch))
...
trainer = Trainer(
...
loggers=[WandBLogger()],
callbacks=[LogPredictions()]
)
W&B OpenAI API 인테그레이션을 사용하여 모든 OpenAI 모델 (파인튜닝된 모델 포함)에 대한 요청, 응답, 토큰 수 및 모델 메타데이터를 기록합니다.
API 입력 및 출력을 기록하면 다양한 프롬프트의 성능을 빠르게 평가하고, 다양한 모델 설정 (예: temperature)을 비교하고, 토큰 사용량과 같은 기타 사용량 메트릭을 추적할 수 있습니다.
W&B autolog 인테그레이션은 OpenAI 버전 0.28.1 이하에서 작동합니다.
OpenAI Python API 버전 0.28.1을 설치하려면 다음을 실행합니다.
pip install openai==0.28.1
먼저 wandb.integration.openai에서 autolog를 임포트하고 초기화합니다.
import os
import openai
from wandb.integration.openai import autolog
autolog({"project": "gpt5"})
선택적으로 wandb.init()이 허용하는 인수가 있는 사전을 autolog에 전달할 수 있습니다. 여기에는 프로젝트 이름, 팀 이름, Entity 등이 포함됩니다. wandb.init에 대한 자세한 내용은 API Reference Guide를 참조하세요.
OpenAI API를 호출할 때마다 W&B에 자동으로 기록됩니다.
os.environ["OPENAI_API_KEY"] = "XXX"
chat_request_kwargs = dict(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Who won the world series in 2020?"},
{"role": "assistant", "content": "The Los Angeles Dodgers"},
{"role": "user", "content": "Where was it played?"},
],
)
response = openai.ChatCompletion.create(**chat_request_kwargs)
1단계에서 autolog에 의해 생성된 W&B run 링크를 클릭합니다. 그러면 W&B 앱의 프로젝트 Workspace로 리디렉션됩니다.
생성한 Run을 선택하여 추적 테이블, 추적 타임라인 및 사용된 OpenAI LLM의 모델 아키텍처를 봅니다.
OpenAI API 사용을 마친 후에는 모든 W&B 프로세스를 닫기 위해 disable()을 호출하는 것이 좋습니다.
autolog.disable()
이제 입력 및 완료가 W&B에 기록되어 분석하거나 동료와 공유할 수 있습니다.
OpenAI GPT-3.5 또는 GPT-4 모델의 파인튜닝 메트릭 및 설정을 W&B에 기록하세요. W&B 에코시스템을 활용하여 파인튜닝 Experiments, Models, Datasets을 추적하고 동료와 결과를 공유하세요.
OpenAI와 W&B를 파인튜닝과 통합하는 방법에 대한 추가 정보는 OpenAI 문서의 Weights and Biases Integration 섹션을 참조하세요.
W&B OpenAI 파인튜닝 통합은 OpenAI 버전 1.0 이상에서 작동합니다. OpenAI Python API 라이브러리의 최신 버전은 PyPI 문서를 참조하세요.
OpenAI Python API를 설치하려면 다음을 실행하세요:
pip install openai
OpenAI Python API가 이미 설치되어 있는 경우 다음을 사용하여 업데이트할 수 있습니다:
pip install -U openai
W&B를 OpenAI의 파인튜닝 API와 통합하여 파인튜닝 메트릭과 설정을 W&B에 기록합니다. 이를 위해 wandb.integration.openai.fine_tuning 모듈의 WandbLogger 클래스를 사용합니다.
from wandb.integration.openai.fine_tuning import WandbLogger
# Finetuning logic
WandbLogger.sync(fine_tune_job_id=FINETUNE_JOB_ID)
스크립트에서 결과를 동기화합니다.
from wandb.integration.openai.fine_tuning import WandbLogger
# 한 줄 코맨드
WandbLogger.sync()
# 옵션 파라미터 전달
WandbLogger.sync(
fine_tune_job_id=None,
num_fine_tunes=None,
project="OpenAI-Fine-Tune",
entity=None,
overwrite=False,
model_artifact_name="model-metadata",
model_artifact_type="model",
**kwargs_wandb_init
)
| 인수 | 설명 |
|---|---|
| fine_tune_job_id | 이는 client.fine_tuning.jobs.create를 사용하여 파인튜닝 job을 생성할 때 얻는 OpenAI Fine-Tune ID입니다. 이 인수가 None(기본값)인 경우, 아직 동기화되지 않은 모든 OpenAI 파인튜닝 job이 W&B에 동기화됩니다. |
| openai_client | 초기화된 OpenAI 클라이언트를 sync에 전달합니다. 클라이언트가 제공되지 않으면 로거 자체에서 초기화됩니다. 기본적으로 None입니다. |
| num_fine_tunes | ID가 제공되지 않으면 동기화되지 않은 모든 파인튜닝이 W&B에 기록됩니다. 이 인수를 사용하면 동기화할 최근 파인튜닝 수를 선택할 수 있습니다. num_fine_tunes가 5이면 가장 최근의 파인튜닝 5개를 선택합니다. |
| project | 파인튜닝 메트릭, Models, Data 등이 기록될 Weights & Biases 프로젝트 이름입니다. 기본적으로 프로젝트 이름은 “OpenAI-Fine-Tune"입니다. |
| entity | Runs을 보낼 W&B 사용자 이름 또는 팀 이름입니다. 기본적으로 기본 엔터티가 사용되며, 이는 일반적으로 사용자 이름입니다. |
| overwrite | 동일한 파인튜닝 job의 기존 wandb run을 강제로 로깅하고 덮어씁니다. 기본적으로 False입니다. |
| wait_for_job_success | OpenAI 파인튜닝 job이 시작되면 일반적으로 시간이 좀 걸립니다. 파인튜닝 job이 완료되는 즉시 메트릭이 W&B에 기록되도록 하려면 이 설정을 통해 파인튜닝 job 상태가 succeeded로 변경되는지 60초마다 확인합니다. 파인튜닝 job이 성공한 것으로 감지되면 메트릭이 자동으로 W&B에 동기화됩니다. 기본적으로 True로 설정됩니다. |
| model_artifact_name | 기록되는 Model 아티팩트의 이름입니다. 기본값은 "model-metadata"입니다. |
| model_artifact_type | 기록되는 Model 아티팩트의 유형입니다. 기본값은 "model"입니다. |
| **kwargs_wandb_init | wandb.init()에 직접 전달되는 추가 인수입니다. |
파인튜닝을 위해 OpenAI에 업로드하는 트레이닝 및 검증 데이터는 더 쉬운 버전 관리를 위해 자동으로 W&B Artifacts로 기록됩니다. 아래는 Artifacts의 트레이닝 파일 보기입니다. 여기서 이 파일을 기록한 W&B run, 기록된 시기, 이 데이터셋의 버전, 메타데이터 및 트레이닝 Data에서 트레이닝된 Model까지의 DAG 계보를 확인할 수 있습니다.
Datasets은 W&B Tables로 시각화되어 데이터셋을 탐색, 검색 및 상호 작용할 수 있습니다. 아래에서 W&B Tables를 사용하여 시각화된 트레이닝 샘플을 확인하세요.
OpenAI는 파인튜닝된 Model의 ID를 제공합니다. Model 가중치에 엑세스할 수 없으므로 WandbLogger는 Model의 모든 세부 정보 (하이퍼파라미터, Data 파일 ID 등)와 fine_tuned_model ID가 포함된 model_metadata.json 파일을 생성하고 W&B Artifacts로 기록합니다.
이 Model (메타데이터) 아티팩트는 W&B Registry의 Model에 추가로 연결될 수 있습니다.
다음을 사용하여 팀 계정에 파인튜닝 job을 기록합니다:
WandbLogger.sync(entity="YOUR_TEAM_NAME")
W&B Runs은 자동으로 구성되며 job 유형, 기본 Model, 학습률, 트레이닝 파일 이름 및 기타 하이퍼파라미터와 같은 모든 구성 파라미터를 기반으로 필터링/정렬할 수 있습니다.
또한 Runs 이름을 바꾸거나 메모를 추가하거나 태그를 만들어 그룹화할 수 있습니다.
만족스러우면 워크스페이스를 저장하고 이를 사용하여 리포트를 생성하고 Runs 및 저장된 Artifacts (트레이닝/검증 파일)에서 Data를 가져올 수 있습니다.
파인튜닝된 Model ID는 Artifacts(model_metadata.json) 및 구성으로 W&B에 기록됩니다.
import wandb
ft_artifact = wandb.run.use_artifact("ENTITY/PROJECT/model_metadata:VERSION")
artifact_dir = artifact.download()
여기서 VERSION은 다음 중 하나입니다.
v2와 같은 버전 번호ft-xxxxxxxxx와 같은 파인튜닝 IDlatest 또는 수동으로 추가된 에일리어스그런 다음 다운로드한 model_metadata.json 파일을 읽어 fine_tuned_model ID에 엑세스할 수 있습니다.
파인튜닝이 W&B에 성공적으로 기록되지 않은 경우 overwrite=True를 사용하고 파인튜닝 job ID를 전달할 수 있습니다.
WandbLogger.sync(
fine_tune_job_id="FINE_TUNE_JOB_ID",
overwrite=True,
)
트레이닝 및 검증 Data는 자동으로 W&B에 Artifacts로 기록됩니다. 파인튜닝된 Model의 ID를 포함한 메타데이터도 Artifacts로 기록됩니다.
wandb.Artifact, wandb.log 등과 같은 하위 레벨 wandb API를 사용하여 항상 파이프라인을 제어할 수 있습니다. 이렇게 하면 Data 및 Models을 완벽하게 추적할 수 있습니다.
“2021년부터 Gym을 유지 관리해 온 팀은 향후 모든 개발을 Gym의 대체품인 Gymnasium으로 이전했으며(gymnasium을 gym으로 가져오기), Gym은 더 이상 업데이트를 받지 않습니다.” (출처)
Gym은 더 이상 활발하게 유지 관리되는 프로젝트가 아니므로 Gymnasium과의 통합을 사용해 보십시오.
OpenAI Gym을 사용하는 경우, Weights & Biases는 gym.wrappers.Monitor에 의해 생성된 환경 비디오를 자동으로 기록합니다. monitor_gym 키워드 인수를 wandb.init에 True로 설정하거나 wandb.gym.monitor()를 호출하기만 하면 됩니다.
저희 gym integration은 매우 가볍습니다. gym에서 기록된 비디오 파일의 이름을 확인하여 그에 따라 이름을 지정하거나 일치하는 항목을 찾지 못하면 "videos"로 대체합니다. 더 많은 제어를 원하시면 언제든지 수동으로 비디오를 기록할 수 있습니다.
CleanRL의 OpenRL Benchmark는 OpenAI Gym 예제에 이 integration을 사용합니다. gym과 함께 사용하는 방법을 보여주는 소스 코드(특정 run에 사용된 특정 코드 포함)를 찾을 수 있습니다.
PaddleDetection은 PaddlePaddle 기반의 엔드투엔드 오브젝트 검출 개발 키트입니다. 다양한 주류 오브젝트를 검출하고, 인스턴스를 분할하며, 네트워크 컴포넌트, 데이터 증강, 손실과 같은 구성 가능한 모듈을 사용하여 키포인트를 추적하고 검출합니다.
PaddleDetection에는 이제 모든 트레이닝 및 검증 메트릭과 모델 체크포인트 및 해당 메타데이터를 기록하는 기본 제공 W&B 인테그레이션이 포함되어 있습니다.
PaddleDetection WandbLogger는 트레이닝 중 트레이닝 및 평가 메트릭을 Weights & Biases에 기록하고 모델 체크포인트를 기록합니다.
W&B 블로그 게시물 읽기 COCO2017 데이터셋의 서브셋에서 YOLOX 모델을 PaddleDetection과 통합하는 방법을 보여줍니다.
API 키는 W&B에 대한 머신을 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리를 설치하고 로그인합니다로컬에서 wandb 라이브러리를 설치하고 로그인하려면:
WANDB_API_KEY 환경 변수를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
WandbLogger 활성화하기PaddleDetection에서 train.py에 대한 인수를 통해 wandb를 사용하려면:
--use_wandb 플래그를 추가합니다.-o로 시작해야 합니다 (한 번만 전달하면 됨).wandb- 접두사를 포함해야 합니다. 예를 들어 wandb.init에 전달될 인수는 wandb- 접두사를 가져옵니다.python tools/train.py
-c config.yml \
--use_wandb \
-o \
wandb-project=MyDetector \
wandb-entity=MyTeam \
wandb-save_dir=./logs
wandb 키 아래의 config.yml 파일에 wandb 인수를 추가합니다.
wandb:
project: MyProject
entity: MyTeam
save_dir: ./logs
train.py 파일을 실행하면 W&B 대시보드에 대한 링크가 생성됩니다.
Weights & Biases 인테그레이션에 대한 피드백이나 문제가 있는 경우 PaddleDetection GitHub에서 이슈를 열거나 support@wandb.com으로 이메일을 보내주세요.
PaddleOCR 은 PaddlePaddle에 구현되어 사용자가 더 나은 모델을 트레이닝하고 실제에 적용할 수 있도록 다국어, 멋진, 선도적이고 실용적인 OCR 툴을 만드는 것을 목표로 합니다. PaddleOCR은 OCR과 관련된 다양한 최첨단 알고리즘을 지원하고 산업 솔루션을 개발했습니다. PaddleOCR은 이제 해당 메타데이터와 함께 모델 체크포인트와 함께 트레이닝 및 평가 메트릭을 로깅하기 위한 Weights & Biases 통합 기능을 제공합니다.
ICDAR2015 데이터셋에서 PaddleOCR로 모델을 트레이닝하는 방법은 여기 에서 확인하세요. Google Colab 도 함께 제공되며, 해당 라이브 W&B 대시보드는 여기 에서 확인할 수 있습니다. 이 블로그의 중국어 버전은 W&B对您的OCR模型进行训练和调试 에서 확인할 수 있습니다.
API 키는 사용자의 머신을 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인wandb 라이브러리를 로컬에 설치하고 로그인하려면 다음을 수행합니다.
WANDB_API_KEY 환경 변수 를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
config.yml 파일에 wandb 추가PaddleOCR은 yaml 파일을 사용하여 구성 변수를 제공해야 합니다. 구성 yaml 파일의 끝에 다음 스니펫을 추가하면 모든 트레이닝 및 유효성 검사 메트릭이 모델 체크포인트와 함께 W&B 대시보드에 자동으로 기록됩니다.
Global:
use_wandb: True
wandb.init 에 전달하려는 추가적인 선택적 인수는 yaml 파일의 wandb 헤더 아래에 추가할 수도 있습니다.
wandb:
project: CoolOCR # (선택 사항) wandb 프로젝트 이름입니다.
entity: my_team # (선택 사항) wandb Team을 사용하는 경우 Team 이름을 여기에 전달할 수 있습니다.
name: MyOCRModel # (선택 사항) wandb run의 이름입니다.
config.yml 파일을 train.py 에 전달그런 다음 yaml 파일은 PaddleOCR 저장소에서 사용할 수 있는 트레이닝 스크립트 에 인수로 제공됩니다.
python tools/train.py -c config.yml
Weights & Biases가 켜진 상태에서 train.py 파일을 실행하면 W&B 대시보드로 이동하는 링크가 생성됩니다.
Weights & Biases 통합에 대한 피드백이나 문제가 있는 경우 PaddleOCR GitHub 에 문제를 열거나 support@wandb.com 으로 이메일을 보내주세요.
Prodigy 는 기계 학습 모델, 오류 분석, 데이터 검사 및 정리을 위한 트레이닝 및 평가 데이터를 생성하기 위한 주석 툴입니다. W&B Tables 를 사용하면 W&B 내에서 데이터셋 (및 더 많은 것!) 을 기록, 시각화, 분석 및 공유할 수 있습니다.
Prodigy 와의 W&B 통합 은 Prodigy 로 주석이 달린 데이터셋을 Tables 에서 사용할 수 있도록 W&B 에 직접 업로드하는 간단하고 사용하기 쉬운 기능을 추가합니다.
다음과 같은 몇 줄의 코드를 실행합니다.
import wandb
from wandb.integration.prodigy import upload_dataset
with wandb.init(project="prodigy"):
upload_dataset("news_headlines_ner")
다음과 같은 시각적이고, 상호 작용적이며, 공유 가능한 테이블을 얻으세요.
wandb.integration.prodigy.upload_dataset 을 사용하여 주석이 달린 Prodigy 데이터셋을 로컬 Prodigy 데이터베이스에서 W&B 의 Table 형식으로 직접 업로드합니다. 설치 및 설정을 포함한 Prodigy 에 대한 자세한 내용은 Prodigy documentation 을 참조하십시오.
W&B 는 이미지 및 명명된 엔티티 필드를 wandb.Image 및 wandb.Html 로 자동 변환하려고 시도합니다. 이러한 시각화를 포함하기 위해 결과 테이블에 추가 열이 추가될 수 있습니다.
W&B Prodigy integration 으로 생성된 시각화 예제는 Visualizing Prodigy Datasets Using W&B Tables 을 살펴보세요.
W&B 는 spaCy 와도 통합되어 있습니다. 여기에서 문서 를 참조하세요.
PyTorch는 Python에서 딥러닝을 위한 가장 인기 있는 프레임워크 중 하나이며, 특히 연구자들 사이에서 인기가 높습니다. W&B는 gradient 로깅부터 CPU 및 GPU에서 코드 프로파일링에 이르기까지 PyTorch에 대한 최고의 지원을 제공합니다.
Colab 노트북에서 W&B 인테그레이션을 사용해 보세요.
예제 레포에서 스크립트를 볼 수도 있습니다. 여기에는 Fashion MNIST에서 Hyperband를 사용하여 하이퍼파라미터 최적화에 대한 스크립트와 생성된 W&B 대시보드가 포함되어 있습니다.
wandb.watch로 gradient 로그gradient를 자동으로 기록하려면 wandb.watch를 호출하고 PyTorch model을 전달하면 됩니다.
import wandb
wandb.init(config=args)
model = ... # set up your model
# Magic
wandb.watch(model, log_freq=100)
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
if batch_idx % args.log_interval == 0:
wandb.log({"loss": loss})
동일한 스크립트에서 여러 model을 추적해야 하는 경우 각 model에서 wandb.watch를 개별적으로 호출할 수 있습니다. 이 함수에 대한 참조 문서는 여기에 있습니다.
wandb.log가 호출될 때까지 기록되지 않습니다.이미지 데이터가 포함된 PyTorch Tensors를 wandb.Image로 전달할 수 있으며, torchvision의 유틸리티가 자동으로 이미지를 변환하는 데 사용됩니다.
images_t = ... # generate or load images as PyTorch Tensors
wandb.log({"examples": [wandb.Image(im) for im in images_t]})
PyTorch 및 기타 프레임워크에서 W&B에 rich media를 로깅하는 방법에 대한 자세한 내용은 미디어 로깅 가이드를 확인하세요.
model의 예측 또는 파생 메트릭과 같은 정보를 미디어와 함께 포함하려면 wandb.Table을 사용하세요.
my_table = wandb.Table()
my_table.add_column("image", images_t)
my_table.add_column("label", labels)
my_table.add_column("class_prediction", predictions_t)
# Log your Table to W&B
wandb.log({"mnist_predictions": my_table})
데이터셋 및 model 로깅 및 시각화에 대한 자세한 내용은 W&B Tables 가이드를 확인하세요.
W&B는 PyTorch Kineto의 Tensorboard plugin과 직접 통합되어 PyTorch 코드 프로파일링, CPU 및 GPU 통신 세부 정보 검사, 병목 현상 및 최적화 식별을 위한 툴을 제공합니다.
profile_dir = "path/to/run/tbprofile/"
profiler = torch.profiler.profile(
schedule=schedule, # see the profiler docs for details on scheduling
on_trace_ready=torch.profiler.tensorboard_trace_handler(profile_dir),
with_stack=True,
)
with profiler:
... # run the code you want to profile here
# see the profiler docs for detailed usage information
# create a wandb Artifact
profile_art = wandb.Artifact("trace", type="profile")
# add the pt.trace.json files to the Artifact
profile_art.add_file(glob.glob(profile_dir + ".pt.trace.json"))
# log the artifact
profile_art.save()
이 Colab에서 작업 예제 코드를 보고 실행하세요.
PyTorch Geometric 또는 PyG는 기하 딥러닝을 위한 가장 인기 있는 라이브러리 중 하나이며, W&B는 그래프 시각화 및 experiments 추적을 위해 이 라이브러리와 매우 잘 연동됩니다.
Pytorch Geometric을 설치한 후 다음 단계에 따라 시작하세요.
API 키는 사용자의 머신을 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인wandb 라이브러리를 로컬에 설치하고 로그인하려면 다음을 수행합니다.
WANDB_API_KEY 환경 변수를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
엣지 수, 노드 수 등 입력 그래프에 대한 세부 정보를 저장할 수 있습니다. W&B는 Plotly 차트 및 HTML 패널 로깅을 지원하므로 그래프에 대해 생성하는 모든 시각화를 W&B에 로깅할 수도 있습니다.
다음 스니펫은 PyVis 및 HTML을 사용하여 이를 수행하는 방법을 보여줍니다.
from pyvis.network import Network
Import wandb
wandb.init(project=’graph_vis’)
net = Network(height="750px", width="100%", bgcolor="#222222", font_color="white")
# Add the edges from the PyG graph to the PyVis network
for e in tqdm(g.edge_index.T):
src = e[0].item()
dst = e[1].item()
net.add_node(dst)
net.add_node(src)
net.add_edge(src, dst, value=0.1)
# Save the PyVis visualisation to a HTML file
net.show("graph.html")
wandb.log({"eda/graph": wandb.Html("graph.html")})
wandb.finish()
Plotly를 사용하여 그래프 시각화를 만들려면 먼저 PyG 그래프를 networkx 오브젝트로 변환해야 합니다. 다음으로 노드와 엣지 모두에 대해 Plotly 산점도를 만들어야 합니다. 아래 스니펫을 이 작업에 사용할 수 있습니다.
def create_vis(graph):
G = to_networkx(graph)
pos = nx.spring_layout(G)
edge_x = []
edge_y = []
for edge in G.edges():
x0, y0 = pos[edge[0]]
x1, y1 = pos[edge[1]]
edge_x.append(x0)
edge_x.append(x1)
edge_x.append(None)
edge_y.append(y0)
edge_y.append(y1)
edge_y.append(None)
edge_trace = go.Scatter(
x=edge_x, y=edge_y,
line=dict(width=0.5, color='#888'),
hoverinfo='none',
mode='lines'
)
node_x = []
node_y = []
for node in G.nodes():
x, y = pos[node]
node_x.append(x)
node_y.append(y)
node_trace = go.Scatter(
x=node_x, y=node_y,
mode='markers',
hoverinfo='text',
line_width=2
)
fig = go.Figure(data=[edge_trace, node_trace], layout=go.Layout())
return fig
wandb.init(project=’visualize_graph’)
wandb.log({‘graph’: wandb.Plotly(create_vis(graph))})
wandb.finish()
W&B를 사용하여 experiments 및 관련 메트릭(예: 손실 함수, 정확도 등)을 추적할 수 있습니다. 다음 줄을 트레이닝 루프에 추가합니다.
wandb.log({
‘train/loss’: training_loss,
‘train/acc’: training_acc,
‘val/loss’: validation_loss,
‘val/acc’: validation_acc
})
torchtune 은 대규모 언어 모델 (LLM) 의 작성, 미세 조정 및 실험 프로세스를 간소화하도록 설계된 PyTorch 기반 라이브러리입니다. 또한 torchtune 은 W&B 로깅을 기본적으로 지원하여 트레이닝 프로세스의 추적 및 시각화를 향상시킵니다.
torchtune 을 사용한 Mistral 7B 미세 조정에 대한 W&B 블로그 게시물을 확인하세요.
실행 시 커맨드라인 인수를 재정의합니다:
tune run lora_finetune_single_device --config llama3/8B_lora_single_device \
metric_logger._component_=torchtune.utils.metric_logging.WandBLogger \
metric_logger.project="llama3_lora" \
log_every_n_steps=5
레시피 구성에서 W&B 로깅을 활성화합니다:
# inside llama3/8B_lora_single_device.yaml
metric_logger:
_component_: torchtune.utils.metric_logging.WandBLogger
project: llama3_lora
log_every_n_steps: 5
metric_logger 섹션을 수정하여 레시피 구성 파일에서 W&B 로깅을 활성화합니다. _component_ 를 torchtune.utils.metric_logging.WandBLogger 클래스로 변경합니다. project 이름과 log_every_n_steps 를 전달하여 로깅 행동을 사용자 정의할 수도 있습니다.
wandb.init 메소드에 전달하는 것처럼 다른 kwargs 를 전달할 수도 있습니다. 예를 들어 팀에서 작업하는 경우 entity 인수를 WandBLogger 클래스에 전달하여 팀 이름을 지정할 수 있습니다.
# inside llama3/8B_lora_single_device.yaml
metric_logger:
_component_: torchtune.utils.metric_logging.WandBLogger
project: llama3_lora
entity: my_project
job_type: lora_finetune_single_device
group: my_awesome_experiments
log_every_n_steps: 5
tune run lora_finetune_single_device --config llama3/8B_lora_single_device \
metric_logger._component_=torchtune.utils.metric_logging.WandBLogger \
metric_logger.project="llama3_lora" \
metric_logger.entity="my_project" \
metric_logger.job_type="lora_finetune_single_device" \
metric_logger.group="my_awesome_experiments" \
log_every_n_steps=5
W&B 대시보드를 탐색하여 기록된 메트릭을 확인할 수 있습니다. 기본적으로 W&B 는 구성 파일 및 실행 재정의의 모든 하이퍼파라미터를 기록합니다.
W&B 는 Overview 탭에서 확인된 구성을 캡처합니다. W&B 는 또한 YAML 형식으로 파일 탭에 구성을 저장합니다.
각 레시피에는 자체 트레이닝 루프가 있습니다. 각 개별 레시피를 확인하여 기본적으로 포함되는 로깅된 메트릭을 확인하십시오.
| Metric | Description |
|---|---|
loss |
모델의 손실 |
lr |
학습률 |
tokens_per_second |
모델의 초당 토큰 수 |
grad_norm |
모델의 그레이디언트 norm |
global_step |
트레이닝 루프의 현재 단계를 나타냅니다. 그레이디언트 누적을 고려하며, 기본적으로 옵티마이저 단계가 수행될 때마다 모델이 업데이트되고, 그레이디언트가 누적되며, 모델은 gradient_accumulation_steps 마다 한 번 업데이트됩니다. |
global_step 은 트레이닝 단계 수와 동일하지 않습니다. 트레이닝 루프의 현재 단계를 나타냅니다. 그레이디언트 누적을 고려하며, 기본적으로 옵티마이저 단계가 수행될 때마다 global_step 은 1 씩 증가합니다. 예를 들어 데이터 로더에 10 개의 배치, 그레이디언트 누적 단계가 2 이고 3 에포크 동안 실행되는 경우 옵티마이저는 15 번 단계별로 진행되며, 이 경우 global_step 은 1 에서 15 까지입니다.torchtune 의 간소화된 설계를 통해 사용자 정의 메트릭을 쉽게 추가하거나 기존 메트릭을 수정할 수 있습니다. 예를 들어, 레시피 파일을 수정하여 총 에포크 수의 백분율로 current_epoch 을 계산하여 로깅할 수 있습니다.
# inside `train.py` function in the recipe file
self._metric_logger.log_dict(
{"current_epoch": self.epochs * self.global_step / self._steps_per_epoch},
step=self.global_step,
)
self._metric_logger.* 함수를 호출해야 합니다.torchtune 라이브러리는 다양한 체크포인트 형식을 지원합니다. 사용 중인 모델의 출처에 따라 적절한 체크포인터 클래스로 전환해야 합니다.
모델 체크포인트를 W&B Artifacts에 저장하려면 해당 레시피 내에서 save_checkpoint 함수를 재정의하는 것이 가장 간단한 해결책입니다.
다음은 모델 체크포인트를 W&B Artifacts 에 저장하기 위해 save_checkpoint 함수를 재정의하는 방법의 예입니다.
def save_checkpoint(self, epoch: int) -> None:
...
## Let's save the checkpoint to W&B
## depending on the Checkpointer Class the file will be named differently
## Here is an example for the full_finetune case
checkpoint_file = Path.joinpath(
self._checkpointer._output_dir, f"torchtune_model_{epoch}"
).with_suffix(".pt")
wandb_artifact = wandb.Artifact(
name=f"torchtune_model_{epoch}",
type="model",
# description of the model checkpoint
description="Model checkpoint",
# you can add whatever metadata you want as a dict
metadata={
utils.SEED_KEY: self.seed,
utils.EPOCHS_KEY: self.epochs_run,
utils.TOTAL_EPOCHS_KEY: self.total_epochs,
utils.MAX_STEPS_KEY: self.max_steps_per_epoch,
},
)
wandb_artifact.add_file(checkpoint_file)
wandb.log_artifact(wandb_artifact)
Ignite는 트레이닝 및 검증 중에 메트릭, 모델/옵티마이저 파라미터, 그레이디언트를 기록하기 위해 Weights & Biases 핸들러를 지원합니다. 또한 모델 체크포인트를 Weights & Biases cloud에 기록하는 데 사용할 수도 있습니다. 이 클래스는 wandb 모듈의 래퍼이기도 합니다. 즉, 이 래퍼를 사용하여 모든 wandb 함수를 호출할 수 있습니다. 모델 파라미터와 그레이디언트를 저장하는 방법에 대한 예시를 참조하세요.
from argparse import ArgumentParser
import wandb
import torch
from torch import nn
from torch.optim import SGD
from torch.utils.data import DataLoader
import torch.nn.functional as F
from torchvision.transforms import Compose, ToTensor, Normalize
from torchvision.datasets import MNIST
from ignite.engine import Events, create_supervised_trainer, create_supervised_evaluator
from ignite.metrics import Accuracy, Loss
from tqdm import tqdm
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=-1)
def get_data_loaders(train_batch_size, val_batch_size):
data_transform = Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])
train_loader = DataLoader(MNIST(download=True, root=".", transform=data_transform, train=True),
batch_size=train_batch_size, shuffle=True)
val_loader = DataLoader(MNIST(download=False, root=".", transform=data_transform, train=False),
batch_size=val_batch_size, shuffle=False)
return train_loader, val_loader
ignite에서 WandBLogger를 사용하는 것은 모듈식 프로세스입니다. 먼저, WandBLogger 오브젝트를 만듭니다. 다음으로, 메트릭을 자동으로 기록하기 위해 트레이너 또는 평가기에 연결합니다. 다음은 이 예시입니다.
from ignite.contrib.handlers.wandb_logger import *
def run(train_batch_size, val_batch_size, epochs, lr, momentum, log_interval):
train_loader, val_loader = get_data_loaders(train_batch_size, val_batch_size)
model = Net()
device = 'cpu'
if torch.cuda.is_available():
device = 'cuda'
optimizer = SGD(model.parameters(), lr=lr, momentum=momentum)
trainer = create_supervised_trainer(model, optimizer, F.nll_loss, device=device)
evaluator = create_supervised_evaluator(model,
metrics={'accuracy': Accuracy(),
'nll': Loss(F.nll_loss)},
device=device)
desc = "ITERATION - loss: {:.2f}"
pbar = tqdm(
initial=0, leave=False, total=len(train_loader),
desc=desc.format(0)
)
#WandBlogger 오브젝트 생성
wandb_logger = WandBLogger(
project="pytorch-ignite-integration",
name="cnn-mnist",
config={"max_epochs": epochs,"batch_size":train_batch_size},
tags=["pytorch-ignite", "mninst"]
)
wandb_logger.attach_output_handler(
trainer,
event_name=Events.ITERATION_COMPLETED,
tag="training",
output_transform=lambda loss: {"loss": loss}
)
wandb_logger.attach_output_handler(
evaluator,
event_name=Events.EPOCH_COMPLETED,
tag="training",
metric_names=["nll", "accuracy"],
global_step_transform=lambda *_: trainer.state.iteration,
)
wandb_logger.attach_opt_params_handler(
trainer,
event_name=Events.ITERATION_STARTED,
optimizer=optimizer,
param_name='lr' # optional
)
wandb_logger.watch(model)
선택적으로 ignite EVENTS를 활용하여 메트릭을 터미널에 직접 기록할 수 있습니다.
@trainer.on(Events.ITERATION_COMPLETED(every=log_interval))
def log_training_loss(engine):
pbar.desc = desc.format(engine.state.output)
pbar.update(log_interval)
@trainer.on(Events.EPOCH_COMPLETED)
def log_training_results(engine):
pbar.refresh()
evaluator.run(train_loader)
metrics = evaluator.state.metrics
avg_accuracy = metrics['accuracy']
avg_nll = metrics['nll']
tqdm.write(
"Training Results - Epoch: {} Avg accuracy: {:.2f} Avg loss: {:.2f}"
.format(engine.state.epoch, avg_accuracy, avg_nll)
)
@trainer.on(Events.EPOCH_COMPLETED)
def log_validation_results(engine):
evaluator.run(val_loader)
metrics = evaluator.state.metrics
avg_accuracy = metrics['accuracy']
avg_nll = metrics['nll']
tqdm.write(
"Validation Results - Epoch: {} Avg accuracy: {:.2f} Avg loss: {:.2f}"
.format(engine.state.epoch, avg_accuracy, avg_nll))
pbar.n = pbar.last_print_n = 0
trainer.run(train_loader, max_epochs=epochs)
pbar.close()
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument('--batch_size', type=int, default=64,
help='input batch size for training (default: 64)')
parser.add_argument('--val_batch_size', type=int, default=1000,
help='input batch size for validation (default: 1000)')
parser.add_argument('--epochs', type=int, default=10,
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5,
help='SGD momentum (default: 0.5)')
parser.add_argument('--log_interval', type=int, default=10,
help='how many batches to wait before logging training status')
args = parser.parse_args()
run(args.batch_size, args.val_batch_size, args.epochs, args.lr, args.momentum, args.log_interval)
이 코드는 다음 시각화 자료를 생성합니다.
자세한 내용은 Ignite Docs를 참조하세요.
PyTorch Lightning 은 PyTorch 코드를 구성하고 분산 트레이닝 및 16비트 정밀도와 같은 고급 기능을 쉽게 추가할 수 있는 가벼운 래퍼를 제공합니다. W&B는 ML Experiments을 로깅하기 위한 가벼운 래퍼를 제공합니다. 하지만 이 둘을 직접 결합할 필요는 없습니다. Weights & Biases는 WandbLogger를 통해 PyTorch Lightning 라이브러리에 직접 통합됩니다.
from lightning.pytorch.loggers import WandbLogger
from lightning.pytorch import Trainer
wandb_logger = WandbLogger(log_model="all")
trainer = Trainer(logger=wandb_logger)
wandb.log() 사용: WandbLogger는 Trainer의 global_step을 사용하여 W&B에 로깅합니다. 코드에서 wandb.log를 직접 추가로 호출하는 경우 wandb.log()에서 step 인수를 사용하지 마십시오.
대신 다른 메트릭과 마찬가지로 Trainer의 global_step을 로깅합니다.
wandb.log({"accuracy":0.99, "trainer/global_step": step})
import lightning as L
from wandb.integration.lightning.fabric import WandbLogger
wandb_logger = WandbLogger(log_model="all")
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
fabric.log_dict({"important_metric": important_metric})
API 키는 사용자의 머신을 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인wandb 라이브러리를 로컬에 설치하고 로그인하려면:
API 키로 WANDB_API_KEY 환경 변수를 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
WandbLogger 사용PyTorch Lightning에는 메트릭 및 모델 weights, 미디어 등을 로깅하는 여러 WandbLogger 클래스가 있습니다.
Lightning과 통합하려면 WandbLogger를 인스턴스화하고 Lightning의 Trainer 또는 Fabric에 전달합니다.
trainer = Trainer(logger=wandb_logger)
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
fabric.log_dict({
"important_metric": important_metric
})
다음은 WandbLogger에서 가장 많이 사용되는 파라미터 중 일부입니다. 모든 로거 인수에 대한 자세한 내용은 PyTorch Lightning 설명서를 검토하십시오.
| 파라미터 | 설명 |
|---|---|
project |
로깅할 wandb Project를 정의합니다. |
name |
wandb run에 이름을 지정합니다. |
log_model |
log_model="all"인 경우 모든 모델을 로깅하고 log_model=True인 경우 트레이닝 종료 시 로깅합니다. |
save_dir |
데이터가 저장되는 경로입니다. |
class LitModule(LightningModule):
def __init__(self, *args, **kwarg):
self.save_hyperparameters()
wandb_logger.log_hyperparams(
{
"hyperparameter_1": hyperparameter_1,
"hyperparameter_2": hyperparameter_2,
}
)
# 파라미터 하나 추가
wandb_logger.experiment.config["key"] = value
# 여러 파라미터 추가
wandb_logger.experiment.config.update({key1: val1, key2: val2})
# wandb 모듈을 직접 사용
wandb.config["key"] = value
wandb.config.update()
모델 오브젝트를 wandblogger.watch()에 전달하여 트레이닝하는 동안 모델의 그레이디언트와 파라미터를 모니터링할 수 있습니다. PyTorch Lightning WandbLogger 설명서를 참조하십시오.
training_step 또는 validation_step methods와 같이 LightningModule 내에서 self.log('my_metric_name', metric_vale)을 호출하여 WandbLogger를 사용할 때 메트릭을 W&B에 로깅할 수 있습니다.
아래 코드 조각은 메트릭과 LightningModule 하이퍼파라미터를 로깅하도록 LightningModule을 정의하는 방법을 보여줍니다. 이 예제에서는 torchmetrics 라이브러리를 사용하여 메트릭을 계산합니다.
import torch
from torch.nn import Linear, CrossEntropyLoss, functional as F
from torch.optim import Adam
from torchmetrics.functional import accuracy
from lightning.pytorch import LightningModule
class My_LitModule(LightningModule):
def __init__(self, n_classes=10, n_layer_1=128, n_layer_2=256, lr=1e-3):
"""모델 파라미터를 정의하는 데 사용되는 메소드"""
super().__init__()
# mnist 이미지는 (1, 28, 28) (채널, 너비, 높이)입니다.
self.layer_1 = Linear(28 * 28, n_layer_1)
self.layer_2 = Linear(n_layer_1, n_layer_2)
self.layer_3 = Linear(n_layer_2, n_classes)
self.loss = CrossEntropyLoss()
self.lr = lr
# 하이퍼파라미터를 self.hparams에 저장합니다(W&B에서 자동 로깅).
self.save_hyperparameters()
def forward(self, x):
"""추론 입력 -> 출력에 사용되는 메소드"""
# (b, 1, 28, 28) -> (b, 1*28*28)
batch_size, channels, width, height = x.size()
x = x.view(batch_size, -1)
# 3 x (linear + relu)를 수행해 보겠습니다.
x = F.relu(self.layer_1(x))
x = F.relu(self.layer_2(x))
x = self.layer_3(x)
return x
def training_step(self, batch, batch_idx):
"""단일 배치에서 손실을 반환해야 합니다."""
_, loss, acc = self._get_preds_loss_accuracy(batch)
# 손실 및 메트릭 로깅
self.log("train_loss", loss)
self.log("train_accuracy", acc)
return loss
def validation_step(self, batch, batch_idx):
"""메트릭 로깅에 사용"""
preds, loss, acc = self._get_preds_loss_accuracy(batch)
# 손실 및 메트릭 로깅
self.log("val_loss", loss)
self.log("val_accuracy", acc)
return preds
def configure_optimizers(self):
"""모델 옵티마이저를 정의합니다."""
return Adam(self.parameters(), lr=self.lr)
def _get_preds_loss_accuracy(self, batch):
"""train/valid/test 단계가 유사하므로 편의 함수"""
x, y = batch
logits = self(x)
preds = torch.argmax(logits, dim=1)
loss = self.loss(logits, y)
acc = accuracy(preds, y)
return preds, loss, acc
import lightning as L
import torch
import torchvision as tv
from wandb.integration.lightning.fabric import WandbLogger
import wandb
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
model = tv.models.resnet18()
optimizer = torch.optim.SGD(model.parameters(), lr=lr)
model, optimizer = fabric.setup(model, optimizer)
train_dataloader = fabric.setup_dataloaders(
torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)
)
model.train()
for epoch in range(num_epochs):
for batch in train_dataloader:
optimizer.zero_grad()
loss = model(batch)
loss.backward()
optimizer.step()
fabric.log_dict({"loss": loss})
wandb의 define_metric 함수를 사용하여 W&B 요약 메트릭에 해당 메트릭의 최소, 최대, 평균 또는 최적값을 표시할지 여부를 정의할 수 있습니다. define_metric _이(가) 사용되지 않으면 로깅된 마지막 값이 요약 메트릭에 나타납니다. define_metric 참조 문서(여기)와 가이드(여기)를 참조하십시오.
W&B가 W&B 요약 메트릭에서 최대 검증 정확도를 추적하도록 지시하려면 트레이닝 시작 시 wandb.define_metric을 한 번만 호출하십시오.
class My_LitModule(LightningModule):
...
def validation_step(self, batch, batch_idx):
if trainer.global_step == 0:
wandb.define_metric("val_accuracy", summary="max")
preds, loss, acc = self._get_preds_loss_accuracy(batch)
# 손실 및 메트릭 로깅
self.log("val_loss", loss)
self.log("val_accuracy", acc)
return preds
wandb.define_metric("val_accuracy", summary="max")
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
fabric.log_dict({"val_accuracy": val_accuracy})
모델 체크포인트를 W&B Artifacts로 저장하려면 Lightning ModelCheckpoint 콜백을 사용하고 WandbLogger에서 log_model 인수를 설정합니다.
trainer = Trainer(logger=wandb_logger, callbacks=[checkpoint_callback])
fabric = L.Fabric(loggers=[wandb_logger], callbacks=[checkpoint_callback])
latest 및 best 에일리어스는 W&B Artifact에서 모델 체크포인트를 쉽게 검색할 수 있도록 자동으로 설정됩니다.
# 아티팩트 패널에서 레퍼런스를 검색할 수 있습니다.
# "VERSION"은 버전("v2" 등) 또는 에일리어스("latest" 또는 "best")일 수 있습니다.
checkpoint_reference = "USER/PROJECT/MODEL-RUN_ID:VERSION"
# 체크포인트를 로컬로 다운로드합니다(이미 캐시되지 않은 경우).
wandb_logger.download_artifact(checkpoint_reference, artifact_type="model")
# 체크포인트를 로컬로 다운로드합니다(이미 캐시되지 않은 경우).
run = wandb.init(project="MNIST")
artifact = run.use_artifact(checkpoint_reference, type="model")
artifact_dir = artifact.download()
# 체크포인트 로드
model = LitModule.load_from_checkpoint(Path(artifact_dir) / "model.ckpt")
# 원시 체크포인트 요청
full_checkpoint = fabric.load(Path(artifact_dir) / "model.ckpt")
model.load_state_dict(full_checkpoint["model"])
optimizer.load_state_dict(full_checkpoint["optimizer"])
로깅하는 모델 체크포인트는 W&B Artifacts UI를 통해 볼 수 있으며 전체 모델 계보를 포함합니다(UI의 예제 모델 체크포인트는 여기 참조).
최고의 모델 체크포인트를 북마크하고 팀 전체에서 중앙 집중화하려면 W&B Model Registry에 연결하면 됩니다.
여기에서 작업별로 최고의 모델을 구성하고, 모델 수명 주기를 관리하고, ML 수명 주기 전반에 걸쳐 쉬운 추적 및 감사를 용이하게 하고, 웹후크 또는 작업을 통해 다운스트림 작업을 자동화할 수 있습니다.
WandbLogger에는 미디어를 로깅하기 위한 log_image, log_text 및 log_table 메소드가 있습니다.
wandb.log 또는 trainer.logger.experiment.log를 직접 호출하여 오디오, 분자, 포인트 클라우드, 3D 오브젝트 등과 같은 다른 미디어 유형을 로깅할 수도 있습니다.
# 텐서, numpy 어레이 또는 PIL 이미지 사용
wandb_logger.log_image(key="samples", images=[img1, img2])
# 캡션 추가
wandb_logger.log_image(key="samples", images=[img1, img2], caption=["tree", "person"])
# 파일 경로 사용
wandb_logger.log_image(key="samples", images=["img_1.jpg", "img_2.jpg"])
# 트레이너에서 .log 사용
trainer.logger.experiment.log(
{"samples": [wandb.Image(img, caption=caption) for (img, caption) in my_images]},
step=current_trainer_global_step,
)
# 데이터는 목록 목록이어야 합니다.
columns = ["input", "label", "prediction"]
my_data = [["cheese", "english", "english"], ["fromage", "french", "spanish"]]
# 열 및 데이터 사용
wandb_logger.log_text(key="my_samples", columns=columns, data=my_data)
# pandas DataFrame 사용
wandb_logger.log_text(key="my_samples", dataframe=my_dataframe)
# 텍스트 캡션, 이미지 및 오디오가 있는 W&B Table 로깅
columns = ["caption", "image", "sound"]
# 데이터는 목록 목록이어야 합니다.
my_data = [
["cheese", wandb.Image(img_1), wandb.Audio(snd_1)],
["wine", wandb.Image(img_2), wandb.Audio(snd_2)],
]
# Table 로깅
wandb_logger.log_table(key="my_samples", columns=columns, data=data)
Lightning의 콜백 시스템을 사용하여 WandbLogger를 통해 Weights & Biases에 로깅하는 시점을 제어할 수 있습니다. 이 예에서는 검증 이미지 및 예측 샘플을 로깅합니다.
import torch
import wandb
import lightning.pytorch as pl
from lightning.pytorch.loggers import WandbLogger
# 또는
# from wandb.integration.lightning.fabric import WandbLogger
class LogPredictionSamplesCallback(Callback):
def on_validation_batch_end(
self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx
):
"""검증 배치가 종료되면 호출됩니다."""
# `outputs`는 `LightningModule.validation_step`에서 가져옵니다.
# 이 경우 모델 예측에 해당합니다.
# 첫 번째 배치에서 20개의 샘플 이미지 예측을 로깅해 보겠습니다.
if batch_idx == 0:
n = 20
x, y = batch
images = [img for img in x[:n]]
captions = [
f"Ground Truth: {y_i} - Prediction: {y_pred}"
for y_i, y_pred in zip(y[:n], outputs[:n])
]
# 옵션 1: `WandbLogger.log_image`로 이미지 로깅
wandb_logger.log_image(key="sample_images", images=images, caption=captions)
# 옵션 2: 이미지 및 예측을 W&B Table로 로깅
columns = ["image", "ground truth", "prediction"]
data = [
[wandb.Image(x_i), y_i, y_pred] or x_i,
y_i,
y_pred in list(zip(x[:n], y[:n], outputs[:n])),
]
wandb_logger.log_table(key="sample_table", columns=columns, data=data)
trainer = pl.Trainer(callbacks=[LogPredictionSamplesCallback()])
PyTorch Lightning은 DDP 인터페이스를 통해 Multi-GPU를 지원합니다. 그러나 PyTorch Lightning의 디자인에서는 GPU를 인스턴스화하는 방법에 주의해야 합니다.
Lightning은 트레이닝 루프의 각 GPU(또는 순위)가 동일한 초기 조건으로 정확히 동일한 방식으로 인스턴스화되어야 한다고 가정합니다. 그러나 순위 0 프로세스만 wandb.run 오브젝트에 엑세스할 수 있으며 0이 아닌 순위 프로세스의 경우 wandb.run = None입니다. 이로 인해 0이 아닌 프로세스가 실패할 수 있습니다. 이러한 상황은 순위 0 프로세스가 이미 충돌한 0이 아닌 순위 프로세스가 조인될 때까지 대기하기 때문에 교착 상태에 놓일 수 있습니다.
이러한 이유로 트레이닝 코드를 설정하는 방법에 주의하십시오. 설정하는 데 권장되는 방법은 코드가 wandb.run 오브젝트와 독립적이도록 하는 것입니다.
class MNISTClassifier(pl.LightningModule):
def __init__(self):
super(MNISTClassifier, self).__init__()
self.model = nn.Sequential(
nn.Flatten(),
nn.Linear(28 * 28, 128),
nn.ReLU(),
nn.Linear(128, 10),
)
self.loss = nn.CrossEntropyLoss()
def forward(self, x):
return self.model(x)
def training_step(self, batch, batch_idx):
x, y = batch
y_hat = self.forward(x)
loss = self.loss(y_hat, y)
self.log("train/loss", loss)
return {"train_loss": loss}
def validation_step(self, batch, batch_idx):
x, y = batch
y_hat = self.forward(x)
loss = self.loss(y_hat, y)
self.log("val/loss", loss)
return {"val_loss": loss}
def configure_optimizers(self):
return torch.optim.Adam(self.parameters(), lr=0.001)
def main():
# 모든 랜덤 시드를 동일한 값으로 설정합니다.
# 이는 분산 트레이닝 설정에서 중요합니다.
# 각 순위는 자체 초기 weights 집합을 가져옵니다.
# 일치하지 않으면 그레이디언트도 일치하지 않습니다.
# 수렴하지 않을 수 있는 트레이닝으로 이어집니다.
pl.seed_everything(1)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, num_workers=4)
model = MNISTClassifier()
wandb_logger = WandbLogger(project="<project_name>")
callbacks = [
ModelCheckpoint(
dirpath="checkpoints",
every_n_train_steps=100,
),
]
trainer = pl.Trainer(
max_epochs=3, gpus=2, logger=wandb_logger, strategy="ddp", callbacks=callbacks
)
trainer.fit(model, train_loader, val_loader)
Colab 여기에서 비디오 튜토리얼을 따라갈 수 있습니다.
코어 통합은 프레임워크에 구애받지 않는 방식으로 대부분의 로깅 코드를 작성할 수 있도록 해주는 Lightning loggers API를 기반으로 합니다. Logger는 Lightning Trainer에 전달되고 해당 API의 풍부한 훅 및 콜백 시스템을 기반으로 트리거됩니다. 이를 통해 연구 코드는 엔지니어링 및 로깅 코드와 잘 분리됩니다.
모델 체크포인트를 W&B에 저장하여 볼 수 있거나 향후 run에서 사용하기 위해 다운로드할 수 있습니다. 또한 GPU 사용량 및 네트워크 I/O와 같은 시스템 메트릭, 하드웨어 및 OS 정보와 같은 환경 정보, 코드 상태 (git 커밋 및 차이 패치, 노트북 콘텐츠 및 세션 기록 포함) 및 표준 출력에 인쇄된 모든 항목을 캡처합니다.
wandb.run을 사용해야 하는 경우는 어떻게 해야 합니까?엑세스해야 하는 변수의 범위를 직접 확장해야 합니다. 즉, 모든 프로세스에서 초기 조건이 동일한지 확인하십시오.
if os.environ.get("LOCAL_RANK", None) is None:
os.environ["WANDB_DIR"] = wandb.run.dir
그렇다면 os.environ["WANDB_DIR"]을 사용하여 모델 체크포인트 디렉토리를 설정할 수 있습니다. 이렇게 하면 0이 아닌 모든 순위 프로세스가 wandb.run.dir에 엑세스할 수 있습니다.
W&B는 두 가지 경량 인테그레이션을 제공하여 Ray와 통합됩니다.
WandbLoggerCallback 함수는 Tune에 보고된 메트릭을 Wandb API에 자동으로 로그합니다.setup_wandb() 함수는 Tune의 트레이닝 정보로 Wandb API를 자동으로 초기화합니다. wandb.log()를 사용하여 트레이닝 프로세스를 기록하는 등, 평소와 같이 Wandb API를 사용할 수 있습니다.from ray.air.integrations.wandb import WandbLoggerCallback
Wandb 설정은 tune.run()의 config 파라미터에 wandb 키를 전달하여 수행됩니다 (아래 예제 참조).
wandb config 항목의 내용은 wandb.init()에 키워드 인수로 전달됩니다. 예외는 WandbLoggerCallback 자체를 구성하는 데 사용되는 다음 설정입니다.
project (str): Wandb 프로젝트 이름. 필수 항목입니다.
api_key_file (str): Wandb API 키가 포함된 파일의 경로입니다.
api_key (str): Wandb API 키. api_key_file 설정의 대안입니다.
excludes (list): 로그에서 제외할 메트릭 목록입니다.
log_config (bool): results 사전의 config 파라미터를 기록할지 여부입니다. 기본값은 False입니다.
upload_checkpoints (bool): True이면 모델 체크포인트가 Artifacts로 업로드됩니다. 기본값은 False입니다.
from ray import tune, train
from ray.air.integrations.wandb import WandbLoggerCallback
def train_fc(config):
for i in range(10):
train.report({"mean_accuracy": (i + config["alpha"]) / 10})
tuner = tune.Tuner(
train_fc,
param_space={
"alpha": tune.grid_search([0.1, 0.2, 0.3]),
"beta": tune.uniform(0.5, 1.0),
},
run_config=train.RunConfig(
callbacks=[
WandbLoggerCallback(
project="<your-project>", api_key="<your-api-key>", log_config=True
)
]
),
)
results = tuner.fit()
from ray.air.integrations.wandb import setup_wandb
이 유틸리티 함수는 Ray Tune과 함께 사용하기 위해 Wandb를 초기화하는 데 도움이 됩니다. 기본 사용법은 트레이닝 함수에서 setup_wandb()를 호출하는 것입니다.
from ray.air.integrations.wandb import setup_wandb
def train_fn(config):
# Initialize wandb
wandb = setup_wandb(config)
for i in range(10):
loss = config["a"] + config["b"]
wandb.log({"loss": loss})
tune.report(loss=loss)
tuner = tune.Tuner(
train_fn,
param_space={
# define search space here
"a": tune.choice([1, 2, 3]),
"b": tune.choice([4, 5, 6]),
# wandb configuration
"wandb": {"project": "Optimization_Project", "api_key_file": "/path/to/file"},
},
)
results = tuner.fit()
인테그레이션 작동 방식을 보여주는 몇 가지 예제를 만들었습니다.
W&B 는 Amazon SageMaker 와 통합되어 하이퍼파라미터를 자동으로 읽고, 분산된 Runs 를 그룹화하며, 체크포인트에서 Runs 를 재개합니다.
W&B 는 트레이닝 스크립트와 관련된 secrets.env 라는 파일을 찾고 wandb.init() 가 호출될 때 해당 파일을 환경에 로드합니다. secrets.env 파일은 실험을 시작하는 데 사용하는 스크립트에서 wandb.sagemaker_auth(path="source_dir") 를 호출하여 생성할 수 있습니다. 이 파일을 .gitignore 에 추가해야 합니다!
SageMaker 의 사전 구성된 estimator 중 하나를 사용하는 경우, wandb 를 포함하는 requirements.txt 를 소스 디렉터리에 추가해야 합니다.
wandb
Python 2 를 실행하는 estimator 를 사용하는 경우, wandb 를 설치하기 전에 이 wheel 에서 psutil 을 직접 설치해야 합니다.
https://wheels.galaxyproject.org/packages/psutil-5.4.8-cp27-cp27mu-manylinux1_x86_64.whl
wandb
GitHub 에서 전체 예제를 검토하고, 블로그 에서 자세한 내용을 읽어보세요.
SageMaker 와 W&B 를 사용하여 감성 분석기를 배포하는 방법에 대한 튜토리얼 도 읽어볼 수 있습니다.
W&B 스윕 에이전트는 SageMaker 통합이 꺼져 있는 경우에만 SageMaker 작업에서 예상대로 작동합니다. wandb.init 호출을 수정하여 SageMaker 통합을 끕니다.
wandb.init(..., settings=wandb.Settings(sagemaker_disable=True))
몇 줄의 코드를 사용하여 scikit-learn 모델의 성능을 시각화하고 비교하기 위해 wandb를 사용할 수 있습니다. 예제 사용해보기 →
API 키는 W&B에 대한 장치의 인증을 수행합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인로컬에서 wandb 라이브러리를 설치하고 로그인하려면:
API 키에 대해 WANDB_API_KEY 환경 변수를 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
import wandb
wandb.init(project="visualize-sklearn")
y_pred = clf.predict(X_test)
accuracy = sklearn.metrics.accuracy_score(y_true, y_pred)
# If logging metrics over time, then use wandb.log
wandb.log({"accuracy": accuracy})
# OR to log a final metric at the end of training you can also use wandb.summary
wandb.summary["accuracy"] = accuracy
import wandb
wandb.init(project="visualize-sklearn")
모델을 트레이닝하고 예측을 수행한 후 wandb에서 플롯을 생성하여 예측을 분석할 수 있습니다. 지원되는 차트의 전체 목록은 아래의 지원되는 플롯 섹션을 참조하십시오
# Visualize single plot
wandb.sklearn.plot_confusion_matrix(y_true, y_pred, labels)
W&B에는 여러 관련 플롯을 표시하는 plot_classifier와 같은 기능이 있습니다.
# Visualize all classifier plots
wandb.sklearn.plot_classifier(
clf,
X_train,
X_test,
y_train,
y_test,
y_pred,
y_probas,
labels,
model_name="SVC",
feature_names=None,
)
# All regression plots
wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, model_name="Ridge")
# All clustering plots
wandb.sklearn.plot_clusterer(
kmeans, X_train, cluster_labels, labels=None, model_name="KMeans"
)
Matplotlib에서 생성된 플롯도 W&B 대시보드에 기록할 수 있습니다. 이를 위해서는 먼저 plotly를 설치해야 합니다.
pip install plotly
마지막으로, 다음과 같이 W&B의 대시보드에 플롯을 기록할 수 있습니다.
import matplotlib.pyplot as plt
import wandb
wandb.init(project="visualize-sklearn")
# do all the plt.plot(), plt.scatter(), etc. here.
# ...
# instead of doing plt.show() do:
wandb.log({"plot": plt})
다양한 길이의 데이터셋에서 모델을 트레이닝하고 트레이닝 및 테스트 세트 모두에 대해 교차 검증된 점수 대 데이터셋 크기의 플롯을 생성합니다.
wandb.sklearn.plot_learning_curve(model, X, y)
ROC 곡선은 참 긍정 비율(y축) 대 거짓 긍정 비율(x축)을 표시합니다. 이상적인 점수는 TPR = 1 및 FPR = 0이며, 이는 왼쪽 상단의 점입니다. 일반적으로 ROC 곡선 아래 영역(AUC-ROC)을 계산하며 AUC-ROC가 클수록 좋습니다.
wandb.sklearn.plot_roc(y_true, y_probas, labels)
트레이닝 및 테스트 세트에서 목표 클래스의 분포를 표시합니다. 불균형 클래스를 감지하고 한 클래스가 모델에 불균형적인 영향을 미치지 않도록 하는 데 유용합니다.
wandb.sklearn.plot_class_proportions(y_train, y_test, ['dog', 'cat', 'owl'])
서로 다른 임계값에 대한 정밀도와 재현율 간의 균형을 계산합니다. 곡선 아래의 높은 영역은 높은 재현율과 높은 정밀도를 모두 나타냅니다. 여기서 높은 정밀도는 낮은 거짓 긍정 비율과 관련이 있고 높은 재현율은 낮은 거짓 부정 비율과 관련이 있습니다.
두 점수 모두 높으면 분류 모델이 정확한 결과(높은 정밀도)를 반환할 뿐만 아니라 모든 긍정적인 결과의 대부분(높은 재현율)을 반환한다는 것을 나타냅니다. PR 곡선은 클래스가 매우 불균형할 때 유용합니다.
wandb.sklearn.plot_precision_recall(y_true, y_probas, labels)
분류 작업에 대한 각 특징의 중요도를 평가하고 표시합니다. 트리와 같이 feature_importances_ 속성이 있는 분류 모델에서만 작동합니다.
wandb.sklearn.plot_feature_importances(model, ['width', 'height, 'length'])
분류 모델의 예측 확률이 얼마나 잘 보정되었는지, 보정되지 않은 분류 모델을 보정하는 방법을 표시합니다. 베이스라인 로지스틱 회귀 모델, 인수로 전달된 모델, 등방성 보정 및 시그모이드 보정 모두에 의해 추정된 예측 확률을 비교합니다.
보정 곡선이 대각선에 가까울수록 좋습니다. 전치된 시그모이드와 같은 곡선은 과적합된 분류 모델을 나타내고 시그모이드와 같은 곡선은 과소적합된 분류 모델을 나타냅니다. 모델의 등방성 및 시그모이드 보정을 트레이닝하고 해당 곡선을 비교하여 모델이 과적합 또는 과소적합되었는지, 그렇다면 어떤 보정(시그모이드 또는 등방성)이 이를 수정하는 데 도움이 될 수 있는지 파악할 수 있습니다.
자세한 내용은 sklearn 문서를 참조하십시오.
wandb.sklearn.plot_calibration_curve(clf, X, y, 'RandomForestClassifier')
혼동 행렬을 계산하여 분류의 정확도를 평가합니다. 모델 예측의 품질을 평가하고 모델이 잘못된 예측에서 패턴을 찾는 데 유용합니다. 대각선은 실제 레이블이 예측 레이블과 같은 경우와 같이 모델이 올바르게 가져온 예측을 나타냅니다.
wandb.sklearn.plot_confusion_matrix(y_true, y_pred, labels)
mse, mae 및 r2 점수와 같은 분류에 대한 요약 메트릭을 계산합니다.f1, 정확도, 정밀도 및 재현율과 같은 회귀에 대한 요약 메트릭을 계산합니다.wandb.sklearn.plot_summary_metrics(model, X_train, y_train, X_test, y_test)
클러스터 수의 함수로 설명된 분산의 백분율과 트레이닝 시간을 측정하고 표시합니다. 최적의 클러스터 수를 선택하는 데 유용합니다.
wandb.sklearn.plot_elbow_curve(model, X_train)
한 클러스터의 각 점이 인접한 클러스터의 점에 얼마나 가까운지 측정하고 표시합니다. 클러스터의 두께는 클러스터 크기에 해당합니다. 수직선은 모든 점의 평균 실루엣 점수를 나타냅니다.
+1에 가까운 실루엣 계수는 샘플이 인접한 클러스터에서 멀리 떨어져 있음을 나타냅니다. 0 값은 샘플이 두 개의 인접한 클러스터 사이의 결정 경계에 있거나 매우 가까이에 있음을 나타내고 음수 값은 해당 샘플이 잘못된 클러스터에 할당되었을 수 있음을 나타냅니다.
일반적으로 모든 실루엣 클러스터 점수가 평균 이상(빨간색 선을 지나)이고 가능한 한 1에 가깝기를 바랍니다. 또한 데이터의 기본 패턴을 반영하는 클러스터 크기를 선호합니다.
wandb.sklearn.plot_silhouette(model, X_train, ['spam', 'not spam'])
쿡 거리를 통해 회귀 모델에 대한 데이터 포인트의 영향을 측정합니다. 심하게 치우친 영향을 미치는 인스턴스는 잠재적으로 이상치일 수 있습니다. 이상치 탐지에 유용합니다.
wandb.sklearn.plot_outlier_candidates(model, X, y)
예측된 목표 값(y축)과 실제 목표 값과 예측된 목표 값의 차이(x축), 잔차 오류의 분포를 측정하고 표시합니다.
일반적으로 적합한 모델의 잔차는 임의로 분포되어야 합니다. 왜냐하면 좋은 모델은 임의 오류를 제외하고 데이터셋의 대부분의 현상을 설명하기 때문입니다.
wandb.sklearn.plot_residuals(model, X, y)
model (regressor): 적합된 분류 모델을 사용합니다.
X (arr): 트레이닝 세트 특징.
y (arr): 트레이닝 세트 레이블.
질문이 있으시면 slack 커뮤니티에서 답변해 드리겠습니다.
이 라이브러리는 Hugging Face의 Transformers 라이브러리를 기반으로 합니다. Simple Transformers를 사용하면 Transformer 모델을 빠르게 트레이닝하고 평가할 수 있습니다. 모델을 초기화하고, 모델을 트레이닝하고, 모델을 평가하는 데 단 3줄의 코드만 필요합니다. Sequence Classification, Token Classification (NER), Question Answering, Language Model Fine-Tuning, Language Model Training, Language Generation, T5 Model, Seq2Seq Tasks, Multi-Modal Classification 및 Conversational AI를 지원합니다.
모델 트레이닝을 시각화하기 위해 Weights and Biases를 사용하려면 args dictionary의 wandb_project 속성에서 W&B에 대한 프로젝트 이름을 설정하세요. 이렇게 하면 모든 하이퍼파라미터 값, 트레이닝 손실 및 평가 메트릭이 지정된 프로젝트에 기록됩니다.
model = ClassificationModel('roberta', 'roberta-base', args={'wandb_project': 'project-name'})
wandb.init에 들어가는 추가 인수는 wandb_kwargs로 전달할 수 있습니다.
이 라이브러리는 모든 NLP 작업을 위한 별도의 클래스를 갖도록 설계되었습니다. 유사한 기능을 제공하는 클래스는 함께 그룹화됩니다.
simpletransformers.classification - 모든 Classification 모델을 포함합니다.
ClassificationModelMultiLabelClassificationModelsimpletransformers.ner - 모든 Named Entity Recognition 모델을 포함합니다.
NERModelsimpletransformers.question_answering - 모든 Question Answering 모델을 포함합니다.
QuestionAnsweringModel다음은 몇 가지 최소한의 예입니다.
model = MultiLabelClassificationModel("distilbert","distilbert-base-uncased",num_labels=6,
args={"reprocess_input_data": True, "overwrite_output_dir": True, "num_train_epochs":epochs,'learning_rate':learning_rate,
'wandb_project': "simpletransformers"},
)
# 모델 트레이닝
model.train_model(train_df)
# 모델 평가
result, model_outputs, wrong_predictions = model.eval_model(eval_df)
train_args = {
'learning_rate': wandb.config.learning_rate,
'num_train_epochs': 2,
'max_seq_length': 128,
'doc_stride': 64,
'overwrite_output_dir': True,
'reprocess_input_data': False,
'train_batch_size': 2,
'fp16': False,
'wandb_project': "simpletransformers"
}
model = QuestionAnsweringModel('distilbert', 'distilbert-base-cased', args=train_args)
model.train_model(train_data)
SimpleTransformers는 모든 일반적인 자연어 작업에 대한 클래스와 트레이닝 스크립트를 제공합니다. 다음은 라이브러리에서 지원하는 전역 인수와 기본 인수들의 전체 목록입니다.
global_args = {
"adam_epsilon": 1e-8,
"best_model_dir": "outputs/best_model",
"cache_dir": "cache_dir/",
"config": {},
"do_lower_case": False,
"early_stopping_consider_epochs": False,
"early_stopping_delta": 0,
"early_stopping_metric": "eval_loss",
"early_stopping_metric_minimize": True,
"early_stopping_patience": 3,
"encoding": None,
"eval_batch_size": 8,
"evaluate_during_training": False,
"evaluate_during_training_silent": True,
"evaluate_during_training_steps": 2000,
"evaluate_during_training_verbose": False,
"fp16": True,
"fp16_opt_level": "O1",
"gradient_accumulation_steps": 1,
"learning_rate": 4e-5,
"local_rank": -1,
"logging_steps": 50,
"manual_seed": None,
"max_grad_norm": 1.0,
"max_seq_length": 128,
"multiprocessing_chunksize": 500,
"n_gpu": 1,
"no_cache": False,
"no_save": False,
"num_train_epochs": 1,
"output_dir": "outputs/",
"overwrite_output_dir": False,
"process_count": cpu_count() - 2 if cpu_count() > 2 else 1,
"reprocess_input_data": True,
"save_best_model": True,
"save_eval_checkpoints": True,
"save_model_every_epoch": True,
"save_steps": 2000,
"save_optimizer_and_scheduler": True,
"silent": False,
"tensorboard_dir": None,
"train_batch_size": 8,
"use_cached_eval_features": False,
"use_early_stopping": False,
"use_multiprocessing": True,
"wandb_kwargs": {},
"wandb_project": None,
"warmup_ratio": 0.06,
"warmup_steps": 0,
"weight_decay": 0,
}
자세한 내용은 github의 simpletransformers를 참조하세요.
가장 인기 있는 GLUE 벤치마크 데이터셋에서 트랜스포머 트레이닝을 다루는 이 Weights and Biases report를 확인하세요. colab에서 직접 사용해 보세요.
Skorch와 함께 Weights & Biases를 사용하여 모든 모델 성능 메트릭, 모델 토폴로지 및 컴퓨팅 리소스와 함께 최고의 성능을 보이는 모델을 각 에포크 후에 자동으로 기록할 수 있습니다. wandb_run.dir에 저장된 모든 파일은 자동으로 W&B 서버에 기록됩니다.
예제 run을 참조하세요.
| 파라미터 | 타입 | 설명 |
|---|---|---|
wandb_run |
wandb.wandb_run. Run |
데이터를 기록하는 데 사용되는 wandb run입니다. |
save_model |
bool (default=True) | 최고의 모델의 체크포인트를 저장하고 W&B 서버의 Run에 업로드할지 여부입니다. |
keys_ignored |
str 또는 str 리스트 (default=None) | 텐서보드에 기록하지 않아야 하는 키 또는 키 리스트입니다. 사용자가 제공한 키 외에도 event_로 시작하거나 _best로 끝나는 키는 기본적으로 무시됩니다. |
통합이 어떻게 작동하는지 보여주는 몇 가지 예제를 만들었습니다.
# wandb 설치
... pip install wandb
import wandb
from skorch.callbacks import WandbLogger
# wandb Run 생성
wandb_run = wandb.init()
# 대안: W&B 계정 없이 wandb Run 생성
wandb_run = wandb.init(anonymous="allow")
# 하이퍼 파라미터 기록 (선택 사항)
wandb_run.config.update({"learning rate": 1e-3, "batch size": 32})
net = NeuralNet(..., callbacks=[WandbLogger(wandb_run)])
net.fit(X, y)
| 메소드 | 설명 |
|---|---|
initialize() |
콜백의 초기 상태를 (다시) 설정합니다. |
on_batch_begin(net[, X, y, training]) |
각 배치 시작 시 호출됩니다. |
on_batch_end(net[, X, y, training]) |
각 배치 종료 시 호출됩니다. |
on_epoch_begin(net[, dataset_train, …]) |
각 에포크 시작 시 호출됩니다. |
on_epoch_end(net, **kwargs) |
마지막 기록 단계의 값을 기록하고 최고의 모델을 저장합니다. |
on_grad_computed(net, named_parameters[, X, …]) |
그레이디언트가 계산되었지만 업데이트 단계가 수행되기 전에 배치당 한 번 호출됩니다. |
on_train_begin(net, **kwargs) |
모델 토폴로지를 기록하고 그레이디언트에 대한 훅을 추가합니다. |
on_train_end(net[, X, y]) |
트레이닝 종료 시 호출됩니다. |
spaCy는 빠르고 정확한 모델을 간편하게 사용할 수 있도록 하는 유명한 “산업용” NLP 라이브러리입니다. spaCy v3부터는 Weights & Biases를 spacy train과 함께 사용하여 spaCy 모델의 트레이닝 메트릭을 추적하고 모델과 데이터셋을 저장 및 버저닝할 수 있습니다. 설정에 몇 줄만 추가하면 됩니다.
API 키는 사용자의 머신이 W&B에 인증되도록 합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인wandb 라이브러리를 로컬에 설치하고 로그인하려면 다음을 수행합니다.
API 키로 WANDB_API_KEY 환경 변수를 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
WandbLogger 추가spaCy 설정 파일은 로깅뿐만 아니라 트레이닝의 모든 측면(GPU 할당, 옵티마이저 선택, 데이터셋 경로 등)을 지정하는 데 사용됩니다. 최소한 [training.logger] 아래에 @loggers 키를 값 "spacy.WandbLogger.v3"와 함께 제공하고 project_name을 제공해야 합니다.
[training.logger]
@loggers = "spacy.WandbLogger.v3"
project_name = "my_spacy_project"
remove_config_values = ["paths.train", "paths.dev", "corpora.train.path", "corpora.dev.path"]
log_dataset_dir = "./corpus"
model_log_interval = 1000
| 이름 | 설명 |
|---|---|
project_name |
str. W&B Project의 이름입니다. 아직 존재하지 않으면 프로젝트가 자동으로 생성됩니다. |
remove_config_values |
List[str] . W&B에 업로드하기 전에 설정에서 제외할 값의 목록입니다. 기본적으로 []입니다. |
model_log_interval |
Optional int. 기본적으로 None입니다. 설정되면 Artifacts를 사용하여 모델 버전 관리를 활성화합니다. 모델 체크포인트를 로깅하는 사이의 단계 수를 전달합니다. 기본적으로 None입니다. |
log_dataset_dir |
Optional str. 경로가 전달되면 트레이닝 시작 시 데이터셋이 Artifact로 업로드됩니다. 기본적으로 None입니다. |
entity |
Optional str . 전달되면 지정된 엔터티에 run이 생성됩니다. |
run_name |
Optional str . 지정되면 지정된 이름으로 run이 생성됩니다. |
spaCy 트레이닝 설정에 WandbLogger를 추가했으면 평소와 같이 spacy train을 실행할 수 있습니다.
python -m spacy train \
config.cfg \
--output ./output \
--paths.train ./train \
--paths.dev ./dev
python -m spacy train \
config.cfg \
--output ./output \
--paths.train ./train \
--paths.dev ./dev
!python -m spacy train \
config.cfg \
--output ./output \
--paths.train ./train \
--paths.dev ./dev
트레이닝이 시작되면 트레이닝 run의 W&B page 링크가 출력되어 Weights & Biases 웹 UI에서 이 run의 실험 추적 대시보드로 이동합니다.
Stable Baselines 3 (SB3)는 PyTorch에서 강화학습 알고리즘을 안정적으로 구현한 것입니다. W&B의 SB3 인테그레이션은 다음과 같습니다:
W&B를 사용한 SB3 트레이닝 run의 예시를 검토하세요.
from wandb.integration.sb3 import WandbCallback
model.learn(..., callback=WandbCallback())
| 인수 | 사용법 |
|---|---|
verbose |
sb3 출력의 상세 정도 |
model_save_path |
모델이 저장될 폴더 경로. 기본값은 `None`이며, 모델은 기록되지 않습니다 |
model_save_freq |
모델 저장 빈도 |
gradient_save_freq |
그래디언트를 기록하는 빈도. 기본값은 0이며, 그래디언트는 기록되지 않습니다 |
W&B SB3 인테그레이션은 TensorBoard에서 출력된 로그를 사용하여 메트릭을 기록합니다.
import gym
from stable_baselines3 import PPO
from stable_baselines3.common.monitor import Monitor
from stable_baselines3.common.vec_env import DummyVecEnv, VecVideoRecorder
import wandb
from wandb.integration.sb3 import WandbCallback
config = {
"policy_type": "MlpPolicy",
"total_timesteps": 25000,
"env_name": "CartPole-v1",
}
run = wandb.init(
project="sb3",
config=config,
sync_tensorboard=True, # auto-upload sb3's tensorboard metrics
monitor_gym=True, # auto-upload the videos of agents playing the game
save_code=True, # optional
)
def make_env():
env = gym.make(config["env_name"])
env = Monitor(env) # record stats such as returns
return env
env = DummyVecEnv([make_env])
env = VecVideoRecorder(
env,
f"videos/{run.id}",
record_video_trigger=lambda x: x % 2000 == 0,
video_length=200,
)
model = PPO(config["policy_type"], env, verbose=1, tensorboard_log=f"runs/{run.id}")
model.learn(
total_timesteps=config["total_timesteps"],
callback=WandbCallback(
gradient_save_freq=100,
model_save_path=f"models/{run.id}",
verbose=2,
),
)
run.finish()
TensorBoard 로그를 클라우드에 업로드하고, 동료 및 급우들 사이에서 결과를 빠르게 공유하고, 분석을 한 곳에서 중앙 집중식으로 관리하세요.
import wandb
# `sync_tensorboard=True`로 wandb run을 시작합니다.
wandb.init(project="my-project", sync_tensorboard=True)
# TensorBoard를 사용하는 트레이닝 코드
...
# [선택 사항] W&B에 tensorboard 로그를 업로드하기 위해 wandb run을 완료합니다(노트북에서 실행하는 경우).
wandb.finish()
예시를 검토하세요.
run이 완료되면 W&B에서 TensorBoard 이벤트 파일에 엑세스할 수 있으며 시스템의 CPU 또는 GPU 사용률, git 상태, run에서 사용한 터미널 코맨드 등과 같은 추가 유용한 정보와 함께 기본 W&B 차트에서 메트릭을 시각화할 수 있습니다.
TensorBoard에 기록되지 않은 추가 사용자 정의 메트릭을 기록해야 하는 경우 코드에서 wandb.log를 호출할 수 있습니다. wandb.log({"custom": 0.8})
Tensorboard를 동기화할 때 wandb.log에서 step 인수를 설정하는 기능은 꺼져 있습니다. 다른 step 카운트를 설정하려면 다음과 같이 step 메트릭으로 메트릭을 기록할 수 있습니다.
wandb.log({"custom": 0.8, "global_step": global_step})
wandb와 함께 Tensorboard를 사용할 때 Tensorboard를 어떻게 구성합니까?TensorBoard 패치 방법을 보다 세밀하게 제어하려면 wandb.init에 sync_tensorboard=True를 전달하는 대신 wandb.tensorboard.patch를 호출할 수 있습니다.
import wandb
wandb.tensorboard.patch(root_logdir="<logging_directory>")
wandb.init()
# W&B에 tensorboard 로그를 업로드하기 위해 wandb run을 완료합니다(노트북에서 실행하는 경우).
wandb.finish()
TensorBoard > 1.14를 PyTorch와 함께 사용하는 경우 vanilla TensorBoard가 패치되었는지 확인하려면 tensorboard_x=False를 이 메소드에 전달하고, 패치되었는지 확인하려면 pytorch=True를 전달할 수 있습니다. 이러한 옵션은 모두 이러한 라이브러리의 버전에 따라 스마트 기본값을 갖습니다.
기본적으로 tfevents 파일과 모든 .pbtxt 파일도 동기화합니다. 이를 통해 사용자를 대신하여 TensorBoard 인스턴스를 시작할 수 있습니다. run 페이지에 TensorBoard 탭이 표시됩니다. 이 동작은 wandb.tensorboard.patch에 save=False를 전달하여 끌 수 있습니다.
import wandb
wandb.init()
wandb.tensorboard.patch(save=False, tensorboard_x=True)
# 노트북에서 실행하는 경우 W&B에 tensorboard 로그를 업로드하기 위해 wandb run을 완료합니다.
wandb.finish()
tf.summary.create_file_writer를 호출하거나 torch.utils.tensorboard를 통해 SummaryWriter를 구성하기 전에 wandb.init 또는 wandb.tensorboard.patch를 호출해야 합니다.로컬에 저장된 기존 tfevents 파일이 있고 이를 W&B로 가져오려면 wandb sync log_dir을 실행합니다. 여기서 log_dir은 tfevents 파일이 포함된 로컬 디렉토리입니다.
Jupyter 또는 Colab 노트북에서 코드를 실행하는 경우 트레이닝이 끝나면 wandb.finish()를 호출해야 합니다. 이렇게 하면 wandb run이 완료되고 tensorboard 로그가 W&B에 업로드되어 시각화할 수 있습니다. .py 스크립트가 완료되면 wandb가 자동으로 완료되므로 이는 필요하지 않습니다.
노트북 환경에서 셸 코맨드를 실행하려면 !wandb sync directoryname과 같이 !를 앞에 붙여야 합니다.
PyTorch의 TensorBoard 인테그레이션을 사용하는 경우 PyTorch Profiler JSON 파일을 수동으로 업로드해야 할 수 있습니다.
wandb.save(glob.glob(f"runs/*.pt.trace.json")[0], base_path=f"runs")
TensorBoard를 이미 사용하고 있다면 wandb와 쉽게 통합할 수 있습니다.
import tensorflow as tf
import wandb
wandb.init(config=tf.flags.FLAGS, sync_tensorboard=True)
TensorBoard에 기록되지 않은 추가 사용자 정의 메트릭을 기록해야 하는 경우 코드에서 wandb.log를 호출할 수 있습니다. wandb.log({"custom": 0.8})
Tensorboard를 동기화할 때 wandb.log에서 step 인수를 설정하는 기능은 꺼집니다. 다른 step count를 설정하려면 다음과 같이 step 메트릭으로 메트릭을 기록하면 됩니다.
wandb.log({"custom": 0.8, "global_step":global_step}, step=global_step)
무엇이 기록되는지 더 세부적으로 제어하려면 wandb는 TensorFlow estimator에 대한 훅도 제공합니다. 그래프의 모든 tf.summary 값을 기록합니다.
import tensorflow as tf
import wandb
wandb.init(config=tf.FLAGS)
estimator.train(hooks=[wandb.tensorflow.WandbHook(steps_per_log=1000)])
TensorFlow에서 메트릭을 기록하는 가장 간단한 방법은 TensorFlow 로거를 사용하여 tf.summary를 기록하는 것입니다.
import wandb
with tf.Session() as sess:
# ...
wandb.tensorflow.log(tf.summary.merge_all())
TensorFlow 2에서는 사용자 정의 루프를 사용하여 모델을 트레이닝하는 권장 방법은 tf.GradientTape를 사용하는 것입니다. 자세한 내용은 여기에서 확인할 수 있습니다. 사용자 정의 TensorFlow 트레이닝 루프에서 메트릭을 기록하기 위해 wandb를 통합하려면 다음 스니펫을 따르세요.
with tf.GradientTape() as tape:
# 예측값 가져오기
predictions = model(features)
# 손실 계산
loss = loss_func(labels, predictions)
# 메트릭 기록
wandb.log("loss": loss.numpy())
# 그레이디언트 가져오기
gradients = tape.gradient(loss, model.trainable_variables)
# 가중치 업데이트
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
전체 예제는 여기에서 볼 수 있습니다.
공동 창립자들이 W&B 작업을 시작했을 때 OpenAI의 불만을 가진 TensorBoard 사용자들을 위한 툴을 구축하라는 영감을 받았습니다. 개선에 집중한 몇 가지 사항은 다음과 같습니다.
무료 계정으로 시작하세요.
통합이 어떻게 작동하는지 보여주는 몇 가지 예제를 만들었습니다.
Julia 프로그래밍 언어로 기계 학습 Experiments 를 실행하는 사용자를 위해 커뮤니티 기여자가 wandb.jl 이라는 비공식 Julia 바인딩 세트를 만들었습니다.
wandb.jl 저장소의 documentation 에서 예제를 찾을 수 있습니다. “Getting Started” 예제는 다음과 같습니다.
using Wandb, Dates, Logging
# Start a new run, tracking hyperparameters in config
lg = WandbLogger(project = "Wandb.jl",
name = "wandbjl-demo-$(now())",
config = Dict("learning_rate" => 0.01,
"dropout" => 0.2,
"architecture" => "CNN",
"dataset" => "CIFAR-100"))
# Use LoggingExtras.jl to log to multiple loggers together
global_logger(lg)
# Simulating the training or evaluation loop
for x ∈ 1:50
acc = log(1 + x + rand() * get_config(lg, "learning_rate") + rand() + get_config(lg, "dropout"))
loss = 10 - log(1 + x + rand() + x * get_config(lg, "learning_rate") + rand() + get_config(lg, "dropout"))
# Log metrics from your script to W&B
@info "metrics" accuracy=acc loss=loss
end
# Finish the run
close(lg)
wandb 라이브러리에는 XGBoost를 사용한 트레이닝에서 메트릭, 설정 및 저장된 부스터를 로깅하기 위한 WandbCallback 콜백이 있습니다. 여기에서 XGBoost WandbCallback의 출력이 포함된 **라이브 Weights & Biases 대시보드**를 볼 수 있습니다.
Weights & Biases에 XGBoost 메트릭, 설정 및 부스터 모델을 로깅하는 것은 WandbCallback을 XGBoost에 전달하는 것만큼 쉽습니다.
from wandb.integration.xgboost import WandbCallback
import xgboost as XGBClassifier
...
# wandb run 시작
run = wandb.init()
# WandbCallback을 모델에 전달
bst = XGBClassifier()
bst.fit(X_train, y_train, callbacks=[WandbCallback(log_model=True)])
# wandb run 종료
run.finish()
XGBoost 및 Weights & Biases를 사용한 로깅에 대한 포괄적인 내용은 **이 노트북**을 열어 확인하십시오.
WandbCallback 참조WandbCallback을 XGBoost 모델에 전달하면 다음과 같은 작업이 수행됩니다.
log_model = True인 경우).log_feature_importance=True (기본값)일 때 특징 중요도 플롯을 로깅합니다.define_metric=True (기본값)일 때 wandb.summary에서 최상의 평가 메트릭을 캡처합니다.log_model: (boolean) True인 경우 모델을 저장하고 Weights & Biases Artifacts에 업로드합니다.
log_feature_importance: (boolean) True인 경우 특징 중요도 막대 플롯을 로깅합니다.
importance_type: (str) 트리 모델의 경우 {weight, gain, cover, total_gain, total_cover} 중 하나입니다. 선형 모델의 경우 weight입니다.
define_metric: (boolean) True (기본값)인 경우 트레이닝의 마지막 단계 대신 최상의 단계에서 모델 성능을 wandb.summary에 캡처합니다.
WandbCallback 소스 코드를 검토할 수 있습니다.
추가 예제는 GitHub의 예제 저장소를 참조하십시오.
모델에서 최대 성능을 얻으려면 트리 깊이 및 학습률과 같은 하이퍼파라미터를 튜닝해야 합니다. Weights & Biases에는 대규모 하이퍼파라미터 테스팅 Experiments를 구성, 오케스트레이션 및 분석하기 위한 강력한 툴킷인 Sweeps가 포함되어 있습니다.
이 XGBoost & Sweeps Python 스크립트를 사용해 볼 수도 있습니다.
Ultralytics’ YOLOv5 (“You Only Look Once”) 모델 제품군은 고통스러운 과정 없이 컨볼루션 신경망을 통해 실시간 오브젝트 검출을 가능하게 합니다.
Weights & Biases는 YOLOv5에 직접 통합되어 실험 메트릭 추적, 모델 및 데이터셋 버전 관리, 풍부한 모델 예측 시각화 등을 제공합니다. YOLO 실험을 실행하기 전에 간단히 pip install 한 번만 실행하면 됩니다.
wandb를 설치하는 것만으로도 W&B 기본 제공 로깅 기능을 활성화할 수 있습니다. 시스템 메트릭, 모델 메트릭 및 대화형 대시보드에 기록된 미디어를 확인할 수 있습니다.
pip install wandb
git clone https://github.com/ultralytics/yolov5.git
python yolov5/train.py # 작은 데이터셋에서 작은 네트워크를 트레이닝합니다.
wandb에서 표준 출력으로 출력된 링크를 따라가기만 하면 됩니다.
YOLO에 몇 가지 간단한 커맨드라인 인수를 전달하여 더 많은 W&B 기능을 활용할 수 있습니다.
--save_period에 숫자를 전달하면 W&B는 모든 save_period 에포크가 끝날 때마다 모델 버전을 저장합니다. 모델 버전에는 모델 가중치가 포함되어 있으며 검증 세트에서 가장 성능이 좋은 모델에 태그를 지정합니다.--upload_dataset 플래그를 켜면 데이터 버전 관리를 위해 데이터셋도 업로드됩니다.--bbox_interval에 숫자를 전달하면 데이터 시각화이 켜집니다. 모든 bbox_interval 에포크가 끝나면 검증 세트에서 모델의 출력이 W&B에 업로드됩니다.python yolov5/train.py --epochs 20 --save_period 1
python yolov5/train.py --epochs 20 --save_period 1 \
--upload_dataset --bbox_interval 1
다음은 그 모습입니다.
Ultralytics는 이미지 분류, 오브젝트 검출, 이미지 세분화 및 포즈 추정과 같은 작업을 위한 최첨단 컴퓨터 비전 모델의 본거지입니다. 실시간 오브젝트 검출 모델인 YOLO 시리즈의 최신 반복인 YOLOv8뿐만 아니라 SAM (Segment Anything Model), RT-DETR, YOLO-NAS 등과 같은 다른 강력한 컴퓨터 비전 모델도 호스팅합니다. Ultralytics는 이러한 모델의 구현을 제공하는 것 외에도 사용하기 쉬운 API를 사용하여 이러한 모델을 트레이닝, 파인튜닝 및 적용할 수 있는 즉시 사용 가능한 워크플로우를 제공합니다.
ultralytics 와 wandb를 설치합니다.
```shell
pip install --upgrade ultralytics==8.0.238 wandb
# or
# conda install ultralytics
```
```bash
!pip install --upgrade ultralytics==8.0.238 wandb
```
개발팀은 ultralyticsv8.0.238 이하 버전과의 통합을 테스트했습니다. 통합에 대한 문제가 있으면 yolov8 태그를 사용하여 GitHub issue를 생성하세요.
이 섹션에서는 트레이닝, 파인튜닝 및 검증을 위해 Ultralytics 모델을 사용하고, W&B를 사용하여 experiment 추적, 모델-체크포인트, 모델 성능 시각화를 수행하는 일반적인 워크플로우를 보여줍니다.
다음 리포트에서 통합에 대해 확인할 수도 있습니다: W&B로 Ultralytics 강화
Ultralytics와 W&B 통합을 사용하려면 wandb.integration.ultralytics.add_wandb_callback 함수를 가져옵니다.
import wandb
from wandb.integration.ultralytics import add_wandb_callback
from ultralytics import YOLO
선택한 YOLO 모델을 초기화하고 모델로 추론을 수행하기 전에 add_wandb_callback 함수를 호출합니다. 이렇게 하면 트레이닝, 파인튜닝, 검증 또는 추론을 수행할 때 experiment 로그와 이미지가 자동으로 저장되고, 컴퓨터 비전 작업을 위한 대화형 오버레이를 사용하여 각각의 예측 결과와 함께 W&B의 wandb.Table에 추가 인사이트와 함께 오버레이됩니다.
# YOLO 모델 초기화
model = YOLO("yolov8n.pt")
# Ultralytics에 W&B 콜백 추가
add_wandb_callback(model, enable_model_checkpointing=True)
# 모델 트레이닝/파인튜닝
# 각 에포크가 끝나면 검증 배치에 대한 예측이 기록됩니다.
# 컴퓨터 비전 작업을 위한 통찰력 있고 상호 작용적인 오버레이가 있는 W&B 테이블에
model.train(project="ultralytics", data="coco128.yaml", epochs=5, imgsz=640)
# W&B run 종료
wandb.finish()
다음은 Ultralytics 트레이닝 또는 파인튜닝 워크플로우에 대해 W&B를 사용하여 추적된 Experiments의 모습입니다.
YOLO Fine-tuning Experiments
다음은 W&B Table을 사용하여 에포크별 검증 결과를 시각화하는 방법입니다.
WandB Validation Visualization Table
이 섹션에서는 추론을 위해 Ultralytics 모델을 사용하고 W&B를 사용하여 결과를 시각화하는 일반적인 워크플로우를 보여줍니다.
Google Colab에서 코드를 사용해 볼 수 있습니다: Colab에서 열기.
다음 리포트에서 통합에 대해 확인할 수도 있습니다: W&B로 Ultralytics 강화
Ultralytics와 W&B 통합을 사용하려면 wandb.integration.ultralytics.add_wandb_callback 함수를 가져와야 합니다.
import wandb
from wandb.integration.ultralytics import add_wandb_callback
from ultralytics.engine.model import YOLO
통합을 테스트할 이미지를 몇 개 다운로드합니다. 스틸 이미지, 비디오 또는 카메라 소스를 사용할 수 있습니다. 추론 소스에 대한 자세한 내용은 Ultralytics 문서를 확인하세요.
!wget https://raw.githubusercontent.com/wandb/examples/ultralytics/colabs/ultralytics/assets/img1.png
!wget https://raw.githubusercontent.com/wandb/examples/ultralytics/colabs/ultralytics/assets/img2.png
!wget https://raw.githubusercontent.com/wandb/examples/ultralytics/colabs/ultralytics/assets/img4.png
!wget https://raw.githubusercontent.com/wandb/examples/ultralytics/colabs/ultralytics/assets/img5.png
다음으로 wandb.init을 사용하여 W&B run을 초기화합니다.
# W&B run 초기화
wandb.init(project="ultralytics", job_type="inference")
다음으로 원하는 YOLO 모델을 초기화하고 모델로 추론을 수행하기 전에 add_wandb_callback 함수를 호출합니다. 이렇게 하면 추론을 수행할 때 컴퓨터 비전 작업을 위한 대화형 오버레이와 함께 wandb.Table에 추가 인사이트와 함께 이미지가 자동으로 기록됩니다.
# YOLO 모델 초기화
model = YOLO("yolov8n.pt")
# Ultralytics에 W&B 콜백 추가
add_wandb_callback(model, enable_model_checkpointing=True)
# W&B 테이블에 자동으로 기록되는 예측 수행
# 경계 상자, 세분화 마스크에 대한 대화형 오버레이 포함
model(
[
"./assets/img1.jpeg",
"./assets/img3.png",
"./assets/img4.jpeg",
"./assets/img5.jpeg",
]
)
# W&B run 종료
wandb.finish()
트레이닝 또는 파인튜닝 워크플로우의 경우 wandb.init()을 사용하여 명시적으로 run을 초기화할 필요가 없습니다. 그러나 코드에 예측만 포함된 경우 run을 명시적으로 생성해야 합니다.
다음은 대화형 bbox 오버레이의 모습입니다.
WandB Image Overlay
W&B 이미지 오버레이에 대한 자세한 내용은 여기에서 확인할 수 있습니다.
YOLOX 는 오브젝트 검출을 위한 강력한 성능을 가진 앵커 프리 버전의 YOLO입니다. YOLOX W&B 인테그레이션을 사용하면 트레이닝, 검증, 시스템 관련 메트릭의 로깅을 켤 수 있으며, 단일 커맨드라인 인수로 예측값을 대화형으로 검증할 수 있습니다.
API 키는 사용자의 머신을 W&B에 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
wandb 라이브러리 설치 및 로그인wandb 라이브러리를 로컬에 설치하고 로그인하려면 다음을 수행합니다.
WANDB_API_KEY 환경 변수 를 API 키로 설정합니다.
export WANDB_API_KEY=<your_api_key>
wandb 라이브러리를 설치하고 로그인합니다.
pip install wandb
wandb login
pip install wandb
import wandb
wandb.login()
!pip install wandb
import wandb
wandb.login()
--logger wandb 커맨드 라인 인수를 사용하여 wandb로 로깅을 켭니다. 선택적으로 wandb.init 가 예상하는 모든 인수를 전달할 수도 있습니다. 각 인수 앞에 wandb- 를 붙입니다.
num_eval_imges 는 모델 평가를 위해 W&B 테이블에 기록되는 검증 세트 이미지 및 예측값의 수를 제어합니다.
# wandb에 로그인
wandb login
# `wandb` 로거 인수로 yolox 트레이닝 스크립트를 호출합니다.
python tools/train.py .... --logger wandb \
wandb-project <project-name> \
wandb-entity <entity>
wandb-name <run-name> \
wandb-id <run-id> \
wandb-save_dir <save-dir> \
wandb-num_eval_imges <num-images> \
wandb-log_checkpoints <bool>
YOLOX 트레이닝 및 검증 메트릭이 포함된 예시 대시보드 ->
이 W&B 인테그레이션에 대한 질문이나 문제가 있으십니까? YOLOX repository 에 이슈를 여세요.