Hướng dẫn thực tế về học tập tương phản | của Mengliu Zhao | Tháng 7, 2024

Bây giờ là lúc cho một số học tập tương phản. Để giảm thiểu vấn đề về nhãn chú thích không đủ và tận dụng tối đa lượng lớn dữ liệu không có nhãn, có thể sử dụng phương pháp học tương phản để giúp xương sống học hiệu quả các biểu diễn dữ liệu mà không cần tác vụ cụ thể. Xương sống có thể bị đóng băng cho một tác vụ hạ lưu nhất định và chỉ đào tạo một mạng nông trên một tập dữ liệu có chú thích hạn chế để đạt được kết quả khả quan.

Các phương pháp học tập tương phản được sử dụng phổ biến nhất bao gồm SimCLR, SimSiam và MOCO (xem của tôi bài viết trước về MOCO). Ở đây, chúng tôi so sánh SimCLR và SimSiam.

SimCLR tính toán trên các cặp dương và âm trong lô dữ liệu, đòi hỏi khai thác âm cứng, mất mát NT-Xent (mở rộng mất mát tương tự cosin trên một lô) và kích thước lô lớn. SimCLR cũng yêu cầu trình tối ưu hóa LARS để chứa kích thước lô lớn.

SimSiam, tuy nhiên, sử dụng kiến ​​trúc Siamese, tránh sử dụng cặp âm và tránh nhu cầu về kích thước lô lớn. Sự khác biệt giữa SimSiam và SimCLR được đưa ra trong bảng dưới đây.

Chúng ta có thể thấy từ hình trên rằng kiến ​​trúc SimSiam chỉ chứa hai phần: bộ mã hóa/xương sống và bộ dự đoán. Trong thời gian đào tạo, quá trình truyền gradient của phần Siamese bị dừng lại và độ tương tự cosin được tính toán giữa đầu ra của bộ dự đoán và xương sống.

Vậy, làm thế nào chúng ta triển khai kiến ​​trúc này trong thực tế? Tiếp tục thiết kế phân loại có giám sát, chúng tôi giữ nguyên xương sống và chỉ sửa đổi lớp MLP. Trong kiến ​​trúc học có giám sát, MLP đưa ra một vectơ 10 phần tử biểu thị xác suất của 10 lớp. Nhưng đối với SimSiam, mục đích không phải là thực hiện “phân loại” mà là học “biểu diễn”, do đó chúng ta cần đầu ra có cùng kích thước với đầu ra xương sống để tính toán mất mát. Và negative_cosine_similarity được đưa ra dưới đây:

import torch.nn as nn
import matplotlib.pyplot as plt
class SimSiam(nn.Module):
def __init__(self):
tremendous(SimSiam, self).__init__()
self.spine = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.BatchNorm2d(32),
nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.BatchNorm2d(64),
nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
nn.ReLU(),
nn.BatchNorm2d(128),
)
self.prediction_mlp = nn.Sequential(nn.Linear(128*4*4, 64),
nn.BatchNorm1d(64),
nn.ReLU(),
nn.Linear(64, 128*4*4),
)
def ahead(self, x):
x = self.spine(x)
x = x.view(-1, 128 * 4 * 4)
pred_output = self.prediction_mlp(x)
return x, pred_output
cos = nn.CosineSimilarity(dim=1, eps=1e-6)
def negative_cosine_similarity_stopgradient(pred, proj):
return -cos(pred, proj.detach()).imply()

Mã giả để đào tạo SimSiam được đưa ra trong bài báo gốc bên dưới:

Và chúng tôi chuyển đổi nó thành mã đào tạo thực tế:

import tqdm
import torch
import torch.optim as optim
from torch.utils.knowledge import DataLoader
from torchvision.transforms import RandAugment
import wandb
wandb_config = {
"learning_rate": 0.0001,
"structure": "simsiam",
"dataset": "FashionMNIST",
"epochs": 100,
"batch_size": 256,
}
wandb.init(
# set the wandb venture the place this run shall be logged
venture="simsiam",
# monitor hyperparameters and run metadata
config=wandb_config,
)
# Initialize mannequin and optimizer
system = torch.system('cuda' if torch.cuda.is_available() else 'cpu')
simsiam = SimSiam()
random_augmenter = RandAugment(num_ops=5)
optimizer = optim.SGD(simsiam.parameters(), 
lr=wandb_config("learning_rate"), 
momentum=0.9, 
weight_decay=1e-5,
)
train_dataloader = DataLoader(train_dataset, batch_size=wandb_config("batch_size"), shuffle=True)
# Coaching loop
for epoch in vary(wandb_config("epochs")):
simsiam.prepare()
print(f"Epoch {epoch}")
train_loss = 0
for batch_idx, (picture, _) in enumerate(tqdm.tqdm(train_dataloader, complete=len(train_dataloader))):
optimizer.zero_grad()
aug1, aug2 = random_augmenter((picture*255).to(dtype=torch.uint8)).to(dtype=torch.float32) / 255.0, 
random_augmenter((picture*255).to(dtype=torch.uint8)).to(dtype=torch.float32) / 255.0
proj1, pred1 = simsiam(aug1)
proj2, pred2 = simsiam(aug2)
loss = negative_cosine_similarity_stopgradient(pred1, proj2) / 2 + negative_cosine_similarity_stopgradient(pred2, proj1) / 2
loss.backward()
optimizer.step()
wandb.log({"coaching loss": loss})
if (epoch+1) % 10 == 0:
torch.save(simsiam.state_dict(), f"weights/simsiam_epoch{epoch+1}.pt")

Chúng tôi đã đào tạo trong 100 kỷ nguyên như một sự so sánh công bằng với đào tạo có giám sát hạn chế; tổn thất đào tạo được hiển thị bên dưới. Lưu ý: Do thiết kế theo kiểu Siamese, SimSiam có thể rất nhạy cảm với các siêu tham số như tốc độ học và các lớp ẩn MLP. Bài báo gốc của SimSiam cung cấp cấu hình chi tiết cho xương sống ResNet50. Đối với xương sống dựa trên ViT, chúng tôi khuyên bạn nên đọc Giấy MOCO v3áp dụng mô hình SimSiam trong sơ đồ cập nhật động lượng.

Sau đó, chúng tôi chạy SimSiam đã được đào tạo trên bộ thử nghiệm và trực quan hóa các biểu diễn bằng cách sử dụng phép giảm UMAP:

import tqdm
import numpy as np
import torch
system = torch.system('cuda' if torch.cuda.is_available() else 'cpu')
simsiam = SimSiam()                      
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=False)
simsiam.load_state_dict(torch.load("weights/simsiam_epoch100.pt"))
simsiam.eval()
simsiam.to(system)
options = ()
labels = ()
for batch_idx, (picture, goal) in enumerate(tqdm.tqdm(test_dataloader, complete=len(test_dataloader))):
with torch.no_grad():
proj, pred = simsiam(picture.to(system))
options.lengthen(np.squeeze(pred.detach().cpu().numpy()).tolist())
labels.lengthen(goal.detach().cpu().numpy().tolist())
import plotly.categorical as px
import umap.umap_ as umap
reducer = umap.UMAP(n_components=3, n_neighbors=10, metric="cosine")
projections = reducer.fit_transform(np.array(options))
px.scatter(projections, x=0, y=1,
shade=labels, labels={'shade': 'Trend MNIST Labels'}
)

Thật thú vị khi thấy có hai hòn đảo nhỏ trong bản đồ thu nhỏ ở trên: lớp 5, 7, 8 và một số lớp 9. Nếu chúng ta lấy danh sách lớp FashionMNIST ra, chúng ta biết rằng các lớp này tương ứng với các loại giày dép như “Sandal”, “Sneaker”, “Bag” và “Ankle boots”. Cụm màu tím lớn tương ứng với các lớp quần áo như “T-shirt/high”, “Trousers”, “Pullover”, “Gown”, “Coat” và “Shirt”. SimSiam chứng minh việc học là một biểu diễn có ý nghĩa trong phạm vi thị giác.