📍 PyTorch Tutorials

---

TORCHVISION OBJECT DETECTION FINETUNING TUTORIAL

Task : Penn-Fudan Database for Pedestrian Detection and Segmentation 데이터셋으로 미리 학습된 Mask R-CNN 모델을 Fine-Tuning 해보기
⇒ 사람 여부를 파악하는 Instance Segmentation 모델 학습

Mask R-CNN
Faster R-CNN의 RPN에서 얻은 RoI(Region of Interest)에 대하여 객체의 클래스를 예측하는 classification branch + bbox regression을 수행하는 bbox regression branch + 평행으로 segmentation mask를 예측하는 mask branch
⇒ 물체가 있을지도 모르는 위치의 후보 영역을 제안하는 부분(RoI) : selective search, RPN(Region Proposal Network) 등을 이용해 특징을 추출함 → 주어진 RoI들에 대해 클래스를 분류하고 bbox를 회귀함

• mask branch : 각각의 RoI에 작은 크기의 FC Network가 추가된 형태
• mask : 클래스에 따라 분할된 이미지 조각

Data

• Instance Segmentation을 위해서는 target에 "boxes", "labels", "masks"가 꼭 필요함

import numpy as np
import torch
import torch.utils.data
from PIL import Image


class PennFudanDataset(torch.utils.data.Dataset):
    def __init__(self, root, transforms=None):
        self.root = root
        self.transforms = transforms
        # load all image files, sorting them to
        # ensure that they are aligned
        self.imgs = list(sorted(os.listdir(os.path.join(root, "PNGImages"))))
        self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))

    def __getitem__(self, idx):
        # load images ad masks
        img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
        mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
        img = Image.open(img_path).convert("RGB")
        # note that we haven't converted the mask to RGB,
        # because each color corresponds to a different instance
        # with 0 being background
        mask = Image.open(mask_path)

        mask = np.array(mask)
        obj_ids = np.unique(mask) # 각각 다른 색으로 인코딩된 인스턴스들
        # first id is the background, so remove it
        obj_ids = obj_ids[1:]

        # split the color-encoded mask into a set
        # of binary masks
        masks = mask == obj_ids[:, None, None]

        # get bounding box coordinates for each mask
        num_objs = len(obj_ids)
        boxes = []
        for i in range(num_objs):
            pos = np.where(masks[i])
            xmin = np.min(pos[1])
            xmax = np.max(pos[1])
            ymin = np.min(pos[0])
            ymax = np.max(pos[0])
            boxes.append([xmin, ymin, xmax, ymax])

        boxes = torch.as_tensor(boxes, dtype=torch.float32)
        # only one class(=label) : 사람을 찾아내는 것이 목표라서
        labels = torch.ones((num_objs,), dtype=torch.int64) # shape : (num_objs, )
        masks = torch.as_tensor(masks, dtype=torch.uint8)

        image_id = torch.tensor([idx])
        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])
        # suppose all instances are not crowd
        iscrowd = torch.zeros((num_objs,), dtype=torch.int64)

        target = {}
        target["boxes"] = boxes
        target["labels"] = labels
        target["masks"] = masks
        target["image_id"] = image_id
        target["area"] = area
        target["iscrowd"] = iscrowd # 물체가 너무 작은데 많아서 하나의 군집으로 박스를 처리하여 레이블링했는지에 관한 여부

        if self.transforms is not None:
            img, target = self.transforms(img, target)

        return img, target

    def __len__(self):
        return len(self.imgs)

• __init__ 메소드 : 이미지들의 경로를 받아와 정렬한 후 imgs, masks로 사용
• __getitem() 메소드 : 경로들을 idx로 접근하여 이미지를 open()하고 mask가 아닌 img에 대해서만 RGB로 변환 (mask의 각 색깔은 다른 인스턴스를 의미하기 때문에 임의로 RGB로 변환하면 안됨) & target 딕셔너리에 bbox, labels, masks, img_id, area, iscrowd 정보 담아 반환

Model

• maskrcnn_resnet50_fpn : backbone = resnet50 & head = fpn

  FPN (Feature Pyramid Network)
  Top-down 방식으로 특징을 추출하며, 각 추출된 결과들인 low-resolution 및 high-resolution들을 묶는 방식
  각 레벨에서 독립적으로 특징을 추출하여 객체를 탐지하는데 상위 레벨의 이미 계산된 특징을 재사용하므로 멀티 스케일 특징들을 효율적으로 사용할 수 있음

  • forward에서 추출된 의미 정보들을 top-down 과정에서 upsampling하여 해상도를 올림
  • forward에서 손실된 정보들을 skip connection으로 보충함
    
    

  1. Bottom-up pathway
     : Backbone ConvNet의 Feedforward 계산 → 매 층마다 의미 정보를 응축하는 역할
     각 단계(레이어들)의 마지막 레이어의 출력 = feature map의 Reference Set
     
     
  2. Top-down pathway and lateral connection
     : feature map을 upsampling하여 더 높은 해상도의 이미지를 만드는 역할
     skip-connection을 통해 같은 사이즈의 bottom-up 레이어와 합쳐서 손실된 지역적 정보를 보충함

FINETUNING 활용하는 방법

• 미리 학습된 모델로부터 fine-tuning
• 다른 backbone을 추가하도록 모델 수정하기
  - backbone
  : 개체를 검출하든 영역들을 나누든 여러가지 task가 몸의 각 부분이라고 생각하면 ResNet과 같은 classification 모델이 입력을 받아서 다양한 feature를 추출해 각 task에 맞는 모듈로 전달해주는 역할을 함

Train

• lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,step_size=3,gamma=0.1)
  : 3 에폭마다 학습률이 10배 줄어들도록 학습률 스케쥴러 설정

처음부터 끝까지 같은 learning rate를 사용하는 것보다 처음에는 큰 보폭으로 빠르게 최적화하고 최적값에 가까워질ㄹ수록 보폭을 줄여 미세조정하는 것이 학습이 더 잘된다고 알려져 있음

<Learnging rate scheduler>
step 1. optimizer와 scheduler 정의하기
step 2. 학습 시 batch마다 optimizer.step(), epoch마다 scheduler.step()

for epoch in range(epochs):
    for i, (data) in enumerate(data_loader):
        x_data, y_data = data
        optimizer.zero_grad()    
        estimated_y = model(x_data)
        loss = loss(y_data, estimated_y)
        loss.backward()
        optimizer.step()
    scheduler.step()

step size마다 gamma 비율로 lr을 감소시키는 StepLR() 외에도
- LambdaLR() : 초기 lr에 lambda함수에서 나온 값을 곱해서 lr을 조절함
- MultiplicativeLR() : 초기 lr에 lambda함수에서 나온 값을 누적곱해서 lr을 조절함
- MultiStepLR() : lr을 감소시킬 epoch을 직접 지정해줌
등 PyTorch가 제공하는 다양한 Learning rate scheduler가 있음

---

TRANSFER LEARNING FOR COMPUTER VISION TUTORIAL

Task : ImageNet처럼 매우 큰 데이터셋을 통해 사전학습된 합성공 신경망에서 마지막 FC layer만 새로운 랜덤 가중치로 대체시켜 이 층만 학습시키기

Data

• ImageFolder : PyTorch에서 제공하는 모듈로, 계층적인 폴더 구조를 가지고 있는 데이터셋을 불러올 때 사용 가능함

image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'val']}

⇒ 각 이미지들이 자신의 클래스 이름으로 된 폴더 안에 들어가 있는 구조라면, ImageFolder 라이브러리를 이용하여 객체로 만들 수 있음

• next(), iter()

inputs, classes = next(iter(dataloaders['train']) # 데이터셋에서 하나의 배치 받아오기

Train

미리 학습한 모델을 불러온 후 마지막 계층을 제외한 모든 부분을 고정시키고 마지막 FC layer만 finetuning함

model_conv = torchvision.models.resnet18(weights='IMAGENET1K_V1')
for param in model_conv.parameters():
    param.requires_grad = False # 모델의 모든 layer 고정시키기
    
# 새로 생성된 layer(= nn.Linear())의 매개변수는 기본값이 ``requires_grad = True``임 
num_ftrs = model_ft.fc.in_features # fc layer의 입력 채널 수 얻기
model_ft.fc = nn.Linear(num_ftrs, 2) # fc layer의 출력을 우리의 task(개미/벌 분류)에 맞게 수정하기

model_ft = model_ft.to(device)

---

ADVERSARIAL EXAMPLE GENERATION

• Adversarial Attack(적대적 공격)
  : 딥러닝 모델의 내부적 취약점을 이용하여 만든 특정 노이즈(= perturbation)값을 이용해 의도적으로 오분류를 이끌어재는 입력값을 만들어 내는 것
  ⇒ 적대적 예제를 생성하여 여러 ML 기반 시스템의 성능을 의도적으로 떨어뜨려 보안 문제를 일으킴
  
  - Adversarial Example(적대적 예제)
  : ML 모델의 착시를 유도하는 입력
  ⇒ 목표 : Decision boundary를 넘을 수 있는 최소한의 노이즈 분포 찾기
  ⇒ 이미지 상 가장 오른쪽 = Adversarial Example
  +) 노이즈가 포함된 사진도 사람이 보기에는 원래 사진과 구분되지 않아야 함
  

FGSM & PGD
: 적대적 공격의 예

• FGSM(Fast Gradient Sign Method)
  

$w^T\tilde{x} = w^Tx + w^T\eta\\ \tilde{x} = x + \eta\\ \eta = \epsilon * sign(w)\\ w\eta = \epsilon * w * sign(w) = \epsilon||w||$

일 때, $\eta$(= perturbation)가 충분히 작을 경우 분류기는 $x$와 $\tilde{x}$를 같은 클래스로 분류함
→ $w\eta$는 차원 $n$에 비례하게 증가할 수 있으며, 높은 차원의 문제에서 input에 작은 noise가 ouput에 큰 차이를 만들 수 있음

일반적으로 모델을 학습시킬 때는 손실이 가장 낮아지는 지점을 찾음
FGSM : 이미 모델은 학습이 끝난 상태이므로 파라미터가 고정되고 데이터에 조작을 가함
⇒ 손실이 가장 높아지는 방향(= 모델이 최대한 오답을 내도록)으로 이미지를 변형함

def fgsm_attack(image, epsilon, data_grad):
    sign_data_grad = data_grad.sign() # data_grad 의 요소별 부호 값
    perturbed_image = image + epsilon*sign_data_grad # 입력 이미지의 각 픽셀에 sign_data_grad 를 적용해 작은 변화가 적용된 이미지를 생성
    perturbed_image = torch.clamp(perturbed_image, 0, 1) # clipping값 범위를 [0,1]로 유지
    return perturbed_image

• PGD
  : FGSM 방법을 응용한 것으로, $n$번의 step만큼 공격을 반복하는데, 각 step마다 $\epsilon$이 아닌 learning rate만큼 데이터 $x$의 변형이 일어나도록 함

Testing

1. 테스트 데이터셋의 원래 입력 데이터로 분류 결과 예측
   2-1. 예측이 틀리면 다음 데이터로 넘어감
   2-2. 예측이 맞으면 손실, 변화도 계산
   → perturbed_data = fgsm_attack(data, epsilon, data_grad) : 변화도 값을 이용해 노이즈 추가된 이미지 생성
   → output = model(perturbed_data) : 노이즈 추가된(= 공격 받은) 이미지로 재분류
   → 재분류 정확도 계산

⇒ 정확도와 $\epsilon$의 관계 : trade-off
= $\epsilon$이 증가함(= 노이즈가 더 커짐)에 따라 테스트 정확도가 감소함

---

DCGAN TUTORIAL

Generative Adversarial Networks

[케라스 창시자에게 배우는 딥러닝] 코드에는
real image = 0 / generator로부터 생성된 fake image = 1로 라벨링되어 있어
필기 내용이 PyTorch 튜토리얼과 반대임

Discriminator

⇒ "변화도(gradient)를 상승(ascending)시키며 훈련”
= $log(D(x)) + log(1-D(G(z)))$ 최대화시키기
= $D(x) = 1$, $D(G(z)) = 0$으로 잘 판별하도록 학습시키기

Generator

= $log(1 - D(G(z)))$ 최소화시키기
= $D(G(z)) = 1$이 나오도록 학습시키기 (생성자가 만든 가짜 이미지를 판별자가 실제 이미지(1)라고 예측하도록)

→ $log(D(G(z))$ 최대화시키기 (위 방식이 학습이 잘 안돼서)

generator로 생성한 이미지를 real image라고 속여서 라벨링한 후 이미 학습 완료된 Discriminator에게 전달
→ Discriminator는 입력 데이터를 fake image라 판별
→ 입력 label(= 생성된 이미지를 real이라 가짜로 라벨링)과 판별값 간 loss를 줄이도록 Generator 학습

+) Discriminator를 학습시킬 때는 real image와 Generator로부터 생성된 fake image를 둘 다 사용하지만,
Generator를 학습시킬 때는 real image를 사용할 수 없고 Discriminaotr로부터 얻어지는 정보를 통해 real image를 보지 않고도 최대한 비슷하게 가짜 이미지를 생성하도록 훈련함

DCGAN (Deep Convolutional Generatice Adversarial Network)

구분자에서는 Conv2d()로 층을 쌓는 반면, 생성자에서는 ConvTranspose2d()로 층을 쌓음

• Convoluation Layer
  : down-sampling의 효과가 있음 (input 차원 > output 차원)

• Transposed Convolutional Layer
  : 원본 층과 같은 공간 차원으로 up-sampling (input 차원 < output 차원)
  
  원본 size = 5 x 6이고 입력 size = 2 x 3일 때, kernel size = 4 x 4로 ConvTranspose2d()하게 되면 5x6크기의 $2*3$개의 tensor가 구해지고이를 더해 최종 출력을 만들 수 있음

---

SPATIAL TRANSFORMER NETWORKS TUTORIAL

📍 참고자료

• PyTorch Tutorial
• Spatial Transformation Network란 무엇인가?

이미지 분류 문제에서는 이미지가 변환되더라도 그 이미지로 인식하는 것(spatial invariance)가 중요한데
이를 위해 CNN에서는 max pooling layer가 필요한 반면,
Spatial Transformation은 affine transformation(이미지의 특정 부분을 자르고 변환해서 그 부분만 떼어서 훈련시킴)을 이용함

⇒ spatial transform 모듈을 통해 찌그러짐이나 회전 등의 노이즈가 첨가된 이미지를 추론하여 적절한 아웃풋을 도출할 수 있음

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)

        # Spatial transformer localization-network
        self.localization = nn.Sequential(
            nn.Conv2d(1, 8, kernel_size=7),
            nn.MaxPool2d(2, stride=2),
            nn.ReLU(True),
            nn.Conv2d(8, 10, kernel_size=5),
            nn.MaxPool2d(2, stride=2),
            nn.ReLU(True)
        )

        # Regressor for the 3 * 2 affine matrix
        self.fc_loc = nn.Sequential(
            nn.Linear(10 * 3 * 3, 32),
            nn.ReLU(True),
            nn.Linear(32, 3 * 2)
        )

        # Initialize the weights/bias with identity transformation
        self.fc_loc[2].weight.data.zero_()
        self.fc_loc[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))

    # Spatial transformer network forward function
    def stn(self, x):
        xs = self.localization(x)
        xs = xs.view(-1, 10 * 3 * 3)
        theta = self.fc_loc(xs)
        theta = theta.view(-1, 2, 3)

        grid = F.affine_grid(theta, x.size())
        x = F.grid_sample(x, grid)

        return x

    def forward(self, x):
        # transform the input
        x = self.stn(x)

        # Perform the usual forward pass
        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)


model = Net().to(device)

CNN 모델 코드 상에 STN이 추가되는 것을 확인할 수 있음

---

OPTIMIZING VISION TRANSFORMER MODEL FOR DEPLOYMENT