Chuyển tới nội dung chính

{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Trọng lượng và thành kiến

W&B: ghi nhật ký các thử nghiệm ML, quét, đăng ký mô hình, bảng điều khiển.

Siêu dữ liệu kỹ năng​

NguồnĐi kèm (được cài đặt theo mặc định)
Đường dẫn

skills/mlops/evaluation/weights-and-biases ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

wandb ` | | Nền tảng | Linux, macOS, Windows | | Thẻ |

MLOps

, `Weights And Biases

, `WandB

, `Experiment Tracking

, `Hyperparameter Tuning

, `Model Registry

, `Collaboration

, `Real-Time Visualization

, `PyTorch

, `TensorFlow

, HuggingFace |

Tham khảo: đầy đủ SKILL.md​

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

Trọng số & Xu hướng: Theo dõi thử nghiệm ML & MLOps

Khi nào nên sử dụng kỹ năng này​

Sử dụng Trọng số & Xu hướng (W&B) khi bạn cần:

  • Theo dõi thử nghiệm ML bằng tính năng ghi số liệu tự động
  • Trực quan hóa chương trình đào tạo trong bảng điều khiển thời gian thực
  • So sánh các lần chạy giữa các siêu tham số và cấu hình
  • Tối ưu hóa siêu tham số bằng tính năng quét tự động
  • Quản lý sổ đăng ký mô hình với phiên bản và dòng dõi
  • Cộng tác trong các dự án ML với không gian làm việc của nhóm
  • Theo dõi các tạo phẩm (bộ dữ liệu, mô hình, mã) theo dòng dõi`Người dùng: Hơn 200.000 người thực hành ML | Sao GitHub: 10,5k+ | Tích hợp: 100+

Cài đặt​


# Install W&B
pip install wandb

# Login (creates API key)
wandb login

# Or set API key programmatically
 export WANDB_API_KEY=your_API_key_here

`

## Bắt đầu nhanh

### Theo dõi thử nghiệm cơ bản

``` python
 import wandb

# Initialize a run
run = wandb.init(
    project="my-project",
    config={
        "learning_rate": 0.001,
        "epochs": 10,
        "batch_size": 32,
        "architecture": "ResNet50"
    }
)

# Training loop
for epoch in range(run.config.epochs):

    # Your training code
    train_loss = train_epoch()
    val_loss = validate()

# Log metrics
    wandb.log({
        "epoch": epoch,
        "train/loss": train_loss,
        "val/loss": val_loss,
        "train/accuracy": train_acc,
        "val/accuracy": val_acc
    })

# Finish the run
wandb.finish()

`

### Với PyTorch

``` python
 import torch
 import wandb

# Initialize
wandb.init(project="pytorch-demo", config={
    "lr": 0.001,
    "epochs": 10
})

# Access config
config = wandb.config

# Training loop
for epoch in range(config.epochs):
    for batch_idx, (data, target) in enumerate(train_loader):

        # Forward pass
        output = model(data)
        loss = criterion(output, target)

# Backward pass
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

# Log every 100 batches
        if batch_idx % 100 == 0:
            wandb.log({
                "loss": loss.item(),
                "epoch": epoch,
                "batch": batch_idx
            })

# Save model
torch.save(model.state_dict(), "model.pth")
wandb.save("model.pth")  # Upload to W&B`wandb.finish()

`

## Khái niệm cốt lõi

### 1. Dự án và hoạt động`**Dự án**: Tuyển tập các thí nghiệm liên quan
**Chạy**: Thực thi một tập lệnh đào tạo của bạn

``` python

# Create/use project
run = wandb.init(
    project="image-classification",
    name="resnet50-experiment-1",  # Optional run name
    tags=["baseline", "resnet"],    # Organize with tags
    notes="First baseline run"      # Add notes
)

# Each run has unique ID
print(f"Run ID: \{run.id}")
print(f"Run URL: \{run.url}")

`

### 2. Theo dõi cấu hình

Theo dõi siêu tham số tự động:

``` python
config = {

    # Model architecture
    "model": "ResNet50",
    "pretrained": True,

# Training params
    "learning_rate": 0.001,
    "batch_size": 32,
    "epochs": 50,
    "optimizer": "Adam",

# Data params
    "dataset": "ImageNet",
    "augmentation": "standard"
}`wandb.init(project="my-project", config=config)

# Access config during training
lr = wandb.config.learning_rate
batch_size = wandb.config.batch_size

`

### 3. Ghi nhật ký số liệu

``` python

# Log scalars
wandb.log(\{"loss": 0.5, "accuracy": 0.92})

# Log multiple metrics
wandb.log({
    "train/loss": train_loss,
    "train/accuracy": train_acc,
    "val/loss": val_loss,
    "val/accuracy": val_acc,
    "learning_rate": current_lr,
    "epoch": epoch
})

# Log with custom x-axis
wandb.log(\{"loss": loss}, step=global_step)

# Log media (images, audio, video)
wandb.log(\{"examples": [wandb.Image(img) for img in images]})

# Log histograms
wandb.log(\{"gradients": wandb.Histogram(gradients)})

# Log tables
table = wandb.Table(columns=["id", "prediction", "ground_truth"])
wandb.log(\{"predictions": table})

`

### 4. Kiểm tra mô hình

``` python
 import torch
 import wandb

# Save model checkpoint
checkpoint = {
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}`torch.save(checkpoint, 'checkpoint.pth')

# Upload to W&B
wandb.save('checkpoint.pth')

# Or use Artifacts (recommended)
artifact = wandb.Artifact('model', type='model')
artifact.add_file('checkpoint.pth')
wandb.log_artifact(artifact)

`

## Quét siêu tham số

Tự động tìm kiếm các siêu tham số tối ưu.

### Xác định cấu hình quét

`Python
sweep_config = {
    'method': 'bayes',  # or 'grid', 'random'
    'metric': {
        'name': 'val/accuracy',
        'goal': 'maximize'
    },
    'parameters': {
        'learning_rate': {
            'distribution': 'log_uniform',
            'min': 1e-5,
            'max': 1e-1
        },
        'batch_size': {
            'values': [16, 32, 64, 128]
        },
        'optimizer': {
            'values': ['adam', 'sgd', 'rmsprop']
        },
        'dropout': {
            'distribution': 'uniform',
            'min': 0.1,
            'max': 0.5
        }
    }
}

# Initialize sweep
sweep_id = wandb.sweep(sweep_config, project="my-project")

`

### Xác định hàm đào tạo

`Python
def train():

    # Initialize run
    run = wandb.init()

# Access sweep parameters
    lr = wandb.config.learning_rate
    batch_size = wandb.config.batch_size
    optimizer_name = wandb.config.optimizer

# Build model with sweep config
    model = build_model(wandb.config)
    optimizer = get_optimizer(optimizer_name, lr)

# Training loop
    for epoch in range(NUM_EPOCHS):
        train_loss = train_epoch(model, optimizer, batch_size)
        val_acc = validate(model)

# Log metrics
        wandb.log({
            "train/loss": train_loss,
            "val/accuracy": val_acc
        })

# Run sweep
wandb.agent(sweep_id, function=train, count=50)  # Run 50 trials

`

### Chiến lược quét

``` python

# Grid search - exhaustive
sweep_config = {
    'method': 'grid',
    'parameters': {
        'lr': \{'values': [0.001, 0.01, 0.1]},
        'batch_size': \{'values': [16, 32, 64]}
    }
}

# Random search
sweep_config = {
    'method': 'random',
    'parameters': {
        'lr': \{'distribution': 'uniform', 'min': 0.0001, 'max': 0.1},
        'dropout': \{'distribution': 'uniform', 'min': 0.1, 'max': 0.5}
    }
}

# Bayesian optimization (recommended)
sweep_config = {
    'method': 'bayes',
    'metric': \{'name': 'val/loss', 'goal': 'minimize'},
    'parameters': {
        'lr': \{'distribution': 'log_uniform', 'min': 1e-5, 'max': 1e-1}
    }
}

`

## Hiện vật

Theo dõi tập dữ liệu, mô hình và các tệp khác theo dòng dõi.

### Đăng nhập các tạo phẩm

``` python

# Create artifact
artifact = wandb.Artifact(
    name='training-dataset',
    type='dataset',
    description='ImageNet training split',
    metadata=\{'size': '1.2M images', 'split': 'train'}
)

# Add files
artifact.add_file('data/train.csv')
artifact.add_dir('data/images/')

# Log artifact
wandb.log_artifact(artifact)

`

### Sử dụng hiện vật

``` python

# Download and use artifact
run = wandb.init(project="my-project")

# Download artifact
artifact = run.use_artifact('training-dataset:latest')
artifact_dir = artifact.download()

# Use the data
data = load_data(f"\{artifact_dir}/train.csv")

`

### Sổ đăng ký mẫu

``` python

# Log model as artifact
model_artifact = wandb.Artifact(
    name='resnet50-model',
    type='model',
    metadata=\{'architecture': 'ResNet50', 'accuracy': 0.95}
)

model_artifact.add_file('model.pth')
wandb.log_artifact(model_artifact, aliases=['best', 'production'])

# Link to model registry
run.link_artifact(model_artifact, 'model-registry/production-models')

`

## Ví dụ về tích hợp

### Ôm Mặt Transformers

``` python
from transformers import Trainer, TrainingArguments
 import wandb

# Initialize W&B
wandb.init(project="hf-transformers")

# Training arguments with W&B
training_args = TrainingArguments(
    output_dir="./results",
    report_to="wandb",  # Enable W&B logging
    run_name="bert-finetuning",
    logging_steps=100,
    save_steps=500
)

# Trainer automatically logs to W&B
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)

trainer.train()

`

### PyTorch Lightning

`Python
from pytorch_lightning import Trainer
from pytorch_lightning.loggers import WandbLogger
 import wandb

# Create W&B logger
wandb_logger = WandbLogger(
    project="lightning-demo",
    log_model=True  # Log model checkpoints
)

# Use with Trainer
trainer = Trainer(
    logger=wandb_logger,
    max_epochs=10
)

trainer.fit(model, datamodule=dm)

`

### Keras/TensorFlow

`Python
 import wandb
from wandb.keras import WandbCallback

# Initialize
wandb.init(project="keras-demo")

# Add callback
model.fit(
    x_train, y_train,
    validation_data=(x_val, y_val),
    epochs=10,
    callbacks=[WandbCallback()]  # Auto-logs metrics
)

`

## Trực quan hóa & Phân tích

### Biểu đồ tùy chỉnh

`Python

# Log custom visualizations
 import matplotlib.pyplot as plt`fig, ax = plt.subplots()
ax.plot(x, y)
wandb.log(\{"custom_plot": wandb.Image(fig)})

# Log confusion Matrix
wandb.log(\{"conf_mat": wandb.plot.confusion_Matrix(
    probs=None,
    y_true=ground_truth,
    preds=predictions,
    class_names=class_names
)})

`

### Báo cáo

Tạo báo cáo có thể chia sẻ trong giao diện người dùng W&B:
- Kết hợp các lần chạy, biểu đồ và văn bản
- Hỗ trợ giảm giá
- Trực quan có thể nhúng
- Hợp tác nhóm

## Các phương pháp hay nhất

### 1. Sắp xếp bằng Thẻ và Nhóm

``` python
wandb.init(
    project="my-project",
    tags=["baseline", "resnet50", "imagenet"],
    group="resnet-experiments",  # Group related runs
    job_type="train"             # Type of job
)

`

### 2. Ghi lại mọi thứ liên quan

`Python

# Log system metrics
wandb.log({
    "gpu/util": gpu_utilization,
    "gpu/memory": gpu_memory_used,
    "cpu/util": cpu_utilization
})

# Log code version
wandb.log(\{"git_commit": git_commit_hash})

# Log data splits
wandb.log({
    "data/train_size": len(train_dataset),
    "data/val_size": len(val_dataset)
})

`

### 3. Sử dụng tên mô tả

``` python

# ✅ Good: Descriptive run names
wandb.init(
    project="nlp-classification",
    name="bert-base-lr0.001-bs32-epoch10"
)

# ❌ Bad: Generic names
wandb.init(project="nlp", name="run1")

`

### 4. Lưu các hiện vật quan trọng

``` python

# Save final model
artifact = wandb.Artifact('final-model', type='model')
artifact.add_file('model.pth')
wandb.log_artifact(artifact)

# Save predictions for analysis
predictions_table = wandb.Table(
    columns=["id", "input", "prediction", "ground_truth"],
    data=predictions_data
)
wandb.log(\{"predictions": predictions_table})

`

### 5. Sử dụng Chế độ ngoại tuyến cho kết nối không ổn định

``` python
 import os

# Enable offline mode
os.environ["WANDB_MODE"] = "offline"`wandb.init(project="my-project")

# ... your code ...

# Sync later
# wandb sync <run_directory

`

## Hợp tác nhóm

### Chia sẻ lượt chạy

``` python

# Runs are automatically shareable via URL
run = wandb.init(project="team-project")
print(f"Share this URL: \{run.url}")

`

### Dự án nhóm
- Tạo tài khoản nhóm tại Wanb.ai
- Thêm thành viên trong nhóm
- Đặt mức độ hiển thị của dự án (riêng tư/công khai)
- Sử dụng các tạo phẩm cấp độ nhóm và đăng ký mô hình

## Định giá
- **Miễn phí**: Dự án công cộng không giới hạn, dung lượng lưu trữ 100GB
- **Học thuật**: Miễn phí cho sinh viên/nhà nghiên cứu
- **Nhóm**: $50/chỗ/tháng, dự án riêng, dung lượng lưu trữ không giới hạn
- **Doanh nghiệp**: Giá tùy chỉnh, tùy chọn tại chỗ

## Tài nguyên
- **Tài liệu**: https://docs.wandb.ai
- **GitHub**: https://GitHub.com/wandb/wandb (10,5k+ sao)
- **Ví dụ**: https://GitHub.com/wandb/examples
- **Cộng đồng**: https://wandb.ai/community
- **Discord**: https://wandb.me/Discord

## Xem thêm
- 
`references/sweeps.md

 - Hướng dẫn tối ưu hóa siêu tham số toàn diện
- 
`references/artifacts.md

 - Mẫu phiên bản dữ liệu và mô hình
- 
`references/integrations.md

 - Ví dụ về khung cụ thể