Autograd & Backward

모델이 학습을 하기 위해서는 일련의 과정이 필요하다.

optimzer.zero_grad(이전의 그라디언트 초기화)
loss = criterion(outputs, targets)
loss.backward() -> backpropagation 계산
optimizer.step() -> 업데이트

과정을 자세히 살펴보면 backward에서는 미분을 계산하고

backward

def backward(self, x, yhat, y):
        ## compute backward
	self.grads["dw"] = (1/x.shape[1]) * torch.mm(x, (yhat - y).T)
	self.grads["db"] = (1/x.shape[1]) * torch.sum(yhat - y)

optimize에서는 계산한 grad를 가지고 업데이트가 이루진다.

optimize

def optimize(self):
	## optimization step
	self.w = self.w - self.lr * self.grads["dw"]
	self.b = self.b - self.lr * self.grads["db"]

DataLoader & Dataset

Dataset

class CustomDataset(Dataset):
    def __init__(self,):
        pass

    def __len__(self):
        pass

    def __getitem__(self, idx):
        pass

• 일반적으로 dataset은 이런 식으로 구성이 되어있다. init은 선언 시 위치나 target, label 등 설정을 하거나 transform이 필요할 경우 설정을 하기도 한다.
• len은 간단히 데이터셋의 개수를 리턴하도록
• getitem은 index가 들어오면 그에 따라 어떻게 반환할지 설정을 한다.

DataLoader

dataloader는 generater로 iter로 바꾼 후 next를 눌러야 값을 받을 수 있다. 이 때 batch size를 지정해주면 batch 수 만큼 데이터가 리턴된다.

sampler

sampler는 getitem 시 index를 통해서 값을 리턴하는데 이 index를 원하는 방식으로 설정을 하게 도와준다.

• SequentialSampler : 항상 같은 순서
• RandomSampler : 랜덤, replacemetn 여부 선택 가능, 개수 선택 가능
• SubsetRandomSampler : 랜덤 리스트, 위와 두 조건 불가능
• WeigthRandomSampler : 가중치에 따른 확률
• BatchSampler : batch단위로 sampling 가능
• DistributedSampler : 분산처리 (torch.nn.parallel.DistributedDataParallel과 함께 사용)

num worker

sub process의 개수를 설정하는 옵션, 큰 데이터일 때 유용. 하지만 너무 많이 하면 CPU와 GPU 사이에 병목이 일어날 수 있음

collate_fn

데이터 사이즈를 맞추기 위해 사용하는 방식. collate를 하면 feature끼리 label끼리 합쳐진다.

def my_collate_fn(samples):
    collate_X = []
    collate_y = []
    max_len = 0
    for dic in samples:
      collate_y.append(dic['y'])
      max_len = max(max_len, len(dic['X']))
    for dic in samples:
      if len(dic['X']) != max_len:
        l = max_len - len(dic['X'])
        dic['X'] = torch.cat((dic['X'], torch.zeros(l)), 0)
      collate_X.append(dic['X'])
    ######################################TODO######################################
    pass
    ################################################################################
    return {'X': torch.stack(collate_X),
             'y': torch.stack(collate_y)}

dataloader_example = torch.utils.data.DataLoader(dataset_example, 
                                                 batch_size=2,
                                                 collate_fn=my_collate_fn)

이렇게 하면 데이터를 불러올 때, collate_fn이 실행이 되고 input으로는 리스트 안에 batch size 만큼 {'X': [], 'y':[]} , ...이 들어온다. 그렇게 받은 인풋으로 내가 설정을 한 값으로 리턴을 하는 식

transform

이미지 데이터를 다룬다면 아마 많이 사용될 함수. Augmentation을 위해서 많이 사용한다.

resize

torchvision.transforms.Resize(size, 
                              interpolation=<InterpolationMode.BILINEAR: 'bilinear'>, 
                              max_size=None, 
                              antialias=None)
transforms.Resize(size = (200,200))(im)

RandomCrop

torchvision.transforms.RandomCrop(size, 
                                  padding=None,
                                  pad_if_needed=False,
                                  fill=0, 
                                  padding_mode='constant')
transforms.RandomCrop(size = (100,100))(im)

RandomRotation

torchvision.transforms.RandomRotation(degrees,
                                      interpolation=<InterpolationMode.NEAREST: 'nearest'>, 
                                      expand=False,
                                      center=None,
                                      fill=0, 
                                      resample=None)
transforms.RandomRotation(30)(im)

한 번에 묶어서 쓰기

transforms.Compose([transforms.Resize((224,224)),
                    transforms.RandomVerticalFlip(0.5),
                    transforms.CenterCrop(150)])(im)

imgaug