Pytorch-7 Monitoring

Monitoring tools for pytorch

긴 학습 시간 -> 기다림의 기록이 필요

대표적으로 1)tensorboard, 2)weight&biases 두가지를 잘 사용한다.

이제 이걸로 쓰고 print문 이제 그만 쓰자! (그래도 쓰긴 하잖아;)

tensorboard

tensorflow의 프로젝트로 만들어진 시각화 도구 학습 그래프, metric, 학습 결과의 시각화 지원 pytorch도 연결 가능 -> DL 시각화 핵심 도구

저장되는 값

• scalar : metric등 상수 값의 epoch 을 표시
• graph : 모델의 computational graph
• histogram : weight 같은 값들의 분포를 표현
• image : 예측과 실제 값 비교 표시
• mesh : 3d 형태 표현

실습코드)

기록 위한 directory 생성

import os
logs_base_dir = "logs"
os.makedirs(logs_base_dir, exist_ok=True)

기록 생성 객체 summarywriter 생성

from torch.utils.tensorboard import SummaryWriter
import numpy as np

exp  = f"{logs_base_dir}/ex3"
#summary writer 에 위치 넣어주고
writer = SummaryWriter(exp)
for n_iter in range(100):
	#add_scalar(위치, 값, n_iter) : scalar 값 기록
	#Loss/train : loss category 에 train 값
	#n_iter : x축의 값
    writer.add_scalar('Loss/train', np.random.random(), n_iter)
    writer.add_scalar('Loss/test', np.random.random(), n_iter)
    writer.add_scalar('Accuracy/train', np.random.random(), n_iter)
    writer.add_scalar('Accuracy/test', np.random.random(), n_iter)
writer.flush()
#마지막에는 close나 flush로 값을 기록(disk에 쓰기)

#주피터 내에서 텐서보드 실행
%load_ext tensorboard
#파일위치 지정, 같은 명령어를 콘솔에서도 사용가능
%tensorboard --logdir {logs_base_dir} 

디렉토리 내에 실험이 다수 포함되면 텐서보드에서 알아서 비교도 해준다.

이외에도

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter(logs_base_dir)
r = 5

for i in range(100):
writer.add_scalars('run_14h', {'xsinx':i*np.sin(i/r),
								'xcosx':i*np.cos(i/r),
								'tanx': np.tan(i/r)}, i)
writer.close()

그냥 바로 run_14h 밑에 값 3개 바로 집어넣는 방법도 있고

add_함수

add_histogram 으로 분포를 나타내는 코드

from torch.utils.tensorboard import SummaryWriter
import numpy as np
writer = SummaryWriter(logs_base_dir)
for i in range(10):
	x = np.random.random(1000)
	writer.add_histogram('distribution centers', x + i, i)
writer.close()

add_images: 이미지 값 넣기

from torch.utils.tensorboard import SummaryWriter
import numpy as np

img_batch = np.zeros((16, 3, 100, 100))
for i in range(16):
	img_batch[i, 0] = np.arange(0, 10000).reshape(100, 100) / 10000 / 16 * i
	img_batch[i, 1] = (1 - np.arange(0, 10000).reshape(100, 100) / 10000) / 16 * i

  

writer = SummaryWriter(logs_base_dir)
writer.add_images('my_image_batch', img_batch, 0)
writer.close()

add_mesh : 3d 정보 넣기

import torch
from torch.utils.tensorboard import SummaryWriter
vertices_tensor = torch.as_tensor([
    [1, 1, 1],
    [-1, -1, 1],
    [1, -1, -1],
    [-1, 1, -1],
], dtype=torch.float).unsqueeze(0)
colors_tensor = torch.as_tensor([
    [255, 0, 0],
    [0, 255, 0],
    [0, 0, 255],
    [255, 0, 255],
], dtype=torch.int).unsqueeze(0)
faces_tensor = torch.as_tensor([
    [0, 2, 3],
    [0, 3, 1],
    [0, 1, 2],
    [1, 3, 2],
], dtype=torch.int).unsqueeze(0)

writer = SummaryWriter(logs_base_dir)
writer.add_mesh('my_mesh', vertices=vertices_tensor, colors=colors_tensor, faces=faces_tensor)

writer.close()

hparms : hyperparameter값을 동시에 기록

from torch.utils.tensorboard import SummaryWriter
with SummaryWriter(logs_base_dir) as w:
    for i in range(5):
        w.add_hparams({'lr': 0.1*i, 'bsize': i},
                      {'hparam/accuracy': 10*i, 'hparam/loss': 10*i})

add_embedding : 학습이 끝나고 데이터를 압축시켜주는

# helper function
def select_n_random(data, labels, n=100):
    '''
    Selects n random datapoints and their corresponding labels from a dataset
    '''
    assert len(data) == len(labels)

    perm = torch.randperm(len(data))
    return data[perm][:n], labels[perm][:n]

# select random images and their target indices
images, labels = select_n_random(trainset.data, trainset.targets)

# get the class labels for each image
class_labels = [classes[lab] for lab in labels]

# log embeddings
features = images.view(-1, 28 * 28)
writer.add_embedding(features,
                    metadata=class_labels,
                    label_img=images.unsqueeze(1))
writer.close()

add_pr_curve_tensorboard() : label별로 recall, precision등등 값들 보임

# 1. gets the probability predictions in a test_size x num_classes Tensor
# 2. gets the preds in a test_size Tensor
# takes ~10 seconds to run
class_probs = []
class_label = []
with torch.no_grad():
    for data in testloader:
        images, labels = data
        output = net(images)
        class_probs_batch = [F.softmax(el, dim=0) for el in output]

        class_probs.append(class_probs_batch)
        class_label.append(labels)

test_probs = torch.cat([torch.stack(batch) for batch in class_probs])
test_label = torch.cat(class_label)

# helper function
def add_pr_curve_tensorboard(class_index, test_probs, test_label, global_step=0):
    '''
    Takes in a "class_index" from 0 to 9 and plots the corresponding
    precision-recall curve
    '''
    tensorboard_truth = test_label == class_index
    tensorboard_probs = test_probs[:, class_index]

    writer.add_pr_curve(classes[class_index],
                        tensorboard_truth,
                        tensorboard_probs,
                        global_step=global_step)
    writer.close()

# plot all the pr curves
for i in range(len(classes)):
    add_pr_curve_tensorboard(i, test_probs, test_label)

weight & bias

머신러닝 실험 지원위한 사용도구(무료로 쓰는 기능 몇개 해보겟음) 협업, code versioning, 실험결과 기록 등 제공 MLOps 대표적인 툴로 저변 확대 중

wandb 홈페이지 가서 회원가입, 로그인 profile 들어가서 create new project setting가서 api keys 복사해서 사용

실습코드

!pip install wandb -q : 설치

!pip install wandb -q

config 설정

EPOCHS = 100
BATCH_SIZE = 32
LEARNING_RATE = 0.001

config={"epochs": EPOCHS, "batch_size": BATCH_SIZE, "learning_rate" : LEARNING_RATE}

wandb.init(project="my-test-project", config=config)
# wandb.config.batch_size = BATCH_SIZE
# wandb.config.learning_rate = LEARNING_RATE
# config={"epochs": EPOCHS, "batch_size": BATCH_SIZE, "learning_rate" : LEARNING_RATE}

wandb.log~ : add_함수와 동일

wandb.init(project="my-test-project", config=config)
# wandb.config.batch_size = BATCH_SIZE
# wandb.config.learning_rate = LEARNING_RATE
# config={"epochs": EPOCHS, "batch_size": BATCH_SIZE, "learning_rate" : LEARNING_RATE}

for e in range(1, EPOCHS+1):
    epoch_loss = 0
    epoch_acc = 0
    for X_batch, y_batch in train_dataset:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device).type(torch.cuda.FloatTensor)
        optimizer.zero_grad()        
        y_pred = model(X_batch)
               
        loss = criterion(y_pred, y_batch.unsqueeze(1))
        acc = binary_acc(y_pred, y_batch.unsqueeze(1))
        
        loss.backward()
        optimizer.step()
        
        epoch_loss += loss.item()
        epoch_acc += acc.item()
        
        
    train_loss = epoch_loss/len(train_dataset)
    train_acc = epoch_acc/len(train_dataset)
    print(f'Epoch {e+0:03}: | Loss: {train_loss:.5f} | Acc: {train_acc:.3f}')
    wandb.log({'accuracy': train_acc, 'loss': train_loss})

이거는 홈페이지에서 프로젝트마다 볼 수 있음 parameter다르게 주면 줄때마다 알아서 따로 저장되고 관리됨.

거의 비슷한 것들을 제공해 준다.