sudo  dpkg -i filename.deb

2. scp 명령어 사용
- 로컬에서 원격으로 (Local→Remote)
````bash
scp [전송할 파일 경로] [유저명]@[IP주소]:[받을 경로]
scp [옵션] [파일명1] [파일명2] [유저명]@[IP주소]:[받을 경로]

• 원격에서 로컬로 (Remote→Local)

  scp [유저명]@[IP주소]:[전송할 파일 경로] [받을 경로]
  scp [옵션] [유저명]@[IP주소]:"[파일명1] [파일명2]" [받을 경로]

• 원격에서 원격으로 (Remote→Remote)

  scp [유저명]@[IP주소]:[전송할 파일 경로] [유저명]@[IP주소]:[받을 경로]
  scp [옵션] [유저명]@[IP주소]:"[파일명1] [파일명2]" [유저명]@[IP주소]:[받을 경로]

3. ssh 접속

   ssh [사용자 계정]@[원격지 ip]

4. tar.gz or tar 파일 압축, 해제

• tar로 압축

  tar -cvf [파일명.tar] [폴더명]

• tar 압축 풀기

  tar -xvf [파일명.tar]

• tar.gz로 압축

  tar -zcvf [파일명.tar.gz] [폴더명]

• tar.gz 압축 풀기

  tar -zxvf [파일명.tar.gz]

YOLOv8을 사용한 Detection 합쳐 결과 확인하기

확인해야 할 것

1. 차선인식시 해당 차선의 x, y 좌표 값이 나오는지 => 나온다
2. YOLO에서 Detection한 x, y 좌표 값이 나오는지 => Bbox 값이 나온다

의문제기

=> Bbox가 원래 물체보다 큰 경우들이 있는데 이 Bbox가 차선에 침범한 경우도 경고를 울리게 하는 것이 과연 실용적일까?

9월 22일

1. Image에 ROI영역을 정한다.
2. ROI를 기준으로 Bird's eye view(BEV)로 변환한다.
3. BEV에서 차선 검출을 시행한다

• Canny edge
• Hough 변환
• Ransac

4. 차선 정보(좌표값)를 기준으로 원본이미지로 Backward 시킨다.

9월 26일

Twinlitenet으로 차선을 도출한 뒤 Roi설정과 opencv 연산으로 본인 차선에 대한 정보를 가져온다.

=> 도로 색이 변하거나 밤인 경우에도 Roi설정만 잘되어 있으면 본인차선 인식 가능.

9월 11일

• 데이터 셋 다운 및 requirement.txt를 실행

  • cuda 버전과 torch 버전이 안맞아 오류 발생

  • 수정과정에서 현재 pycharm 먹통 됨. ``` ps -ef | grep pycharm kill -9 프로세스번호

  • utils.py의 train 함수 일부 수정

    def train(args, train_loader, model, criterion, optimizer, epoch, max_epoch):
        model.train()
    
      total_batches = len(train_loader)
        pbar = enumerate(train_loader)
        LOGGER.info(('\n' + '%13s' * 4) % ('Epoch','TverskyLoss','FocalLoss' ,'TotalLoss'))
        pbar = tqdm(pbar, total=total_batches, bar_format='{l_bar}{bar:10}{r_bar}')
        for i, (_,input, target) in pbar:
            if args.onGPU == True:
                input = input.cuda().float() / 255.0        
            output = model(input)
    
            # target=target.cuda()
            optimizer.zero_grad()
    
            focal_loss,tversky_loss,loss = criterion(output,target)
          optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            pbar.set_description(('%13s' * 1 + '%13.4g' * 3) %
          (f'{epoch}/{max_epoch - 1}', tversky_loss, focal_loss, loss.item()))
    
    
    

• epoch 2 로 train.py 학습완료

    python3 train.py

• model_1.pth 파일 불러와 테스트 코드 실행

    python3 val.py

  • 테스트 코드 일부 수정
    • torch.jit.trace() 부분에서 에러 발생
• 결과 이미지

BDD100k Dataset이 아닌 도로 주행 영상으로 돌려본 결과 정확하게 분리를 해줌.

AI공동경진대회 준비 및 VIS(Video Instance Segmentation) 관련 논문을 읽어보자.

사용 언어

Python

일정

4회차: 8/12 13:00 ~ 16:00

6회차 목표 : 졸업프로젝트 관련 데이터 분석

• Bdd100k image, detection 파일 다운
  • image : 1280, 720 / 정상 주행 데이터 셋
    • json : label(x1, x2, y1, y2, category)

• yolov8 코드 실행
  • 사람의 경우 완벽하게 탐지하지 못함.
  • 정상 주행 데이터셋으로 추가 학습을 진행해 사람에 대한 인식율을 높여볼 필요성 있음.
• HEVI dataset 분석
  • image : 1920, 1200 / 정상 주행 데이터 셋
  • pickle : bbox, flow, frame_id, ego_motion을 가지고 있다.

김현수 : 모각코 6회차

박광욱 : 모각코 6회차

박종경 : 모각코 6회차

정주헌 : 모각코 6회차

최원준 : 모각코 6회차

김현수 : 모각코 5회차

박광욱 : 모각코 5회차

박종경 : 모각코 5회차

정주헌 : 모각코 5회차

최원준 : 모각코 5회차

AI공동경진대회 준비 및 VIS(Video Instance Segmentation) 관련 논문을 읽어보자.

사용 언어

Python

일정

4회차: 8/5 13:00 ~ 16:00

4회차 목표 : IDOL 논문 리뷰

*등장 배경 *

• Online VIS 모델의 단점인 matching association 문제를 해결하여 더 높은 성능을 갖추기 위해 등장.

** 핵심 기술 **

• Contrastive learning
  • 다른 frame 간의 동일한 instance의 유사성과 다른 Instance와의 차이를 학습
    • Optimal transport method
    • 모델이 예측한 class, bounding box와 ground truth에서 주어진 class, bounding box를 조합하여 cost 식 이용.
  • cost 가 낮은 m1 개와 cost가 높은 m2 개를 각각 positive, negative로 설정하여 계산.

** 모델 구조 **

• Key Frame과 Reference Frame은 Backbone을 거친 후에 multi-scale feature maps을 생성하고 이를 Deformable Transformer의 input으로 이용.
• • 결과 **

AI공동경진대회 준비 및 VIS(Video Instance Segmentation) 관련 논문을 읽어보자.

사용 언어

Python

일정

4회차: 7/29 13:00 ~ 16:00

4회차 목표 : VITA 논문 리뷰

• 등장 배경 앞선 선행 연구들은 Online, Offline 다양한 방식으로 VIS Task를 수행해왔다.

• Online* : Offline 모델에 비해 성능이 떨어짐, frame 혹은 clip 간 matching association method가 필요

• Offline* : 모델에 적용할 수 있는 Video 크기가 제한적임. 따라서 본 논문에서는 일반적인 환경에서 Video input의 크기 제한을 덜 받는 모델을 제안한다.

• 핵심 기술

  • dense feature map 대신 Object token(query) 사용
  • frame level detector인 mask2former 사용
  • Similarity loss 사용

• 모델 구조

• 결과

  • Datasets : YouTube-VIS 2019, 2021 OVIS![]

• 한계점

  • 무한한 수의 frame 처리가 안된다.

  • 객체 토큰은 시간정보를 명시적으로 활용하지 못한다. 따라서 매우 긴 sequence에서 어려운 케이스의 경우 이를 처리하기 어렵다.

  ---

김현수 : 모각코 4회차

박광욱 : 모각코 4회차

박종경 : 모각코 4회차

정주헌 : 모각코 4회차

최원준 : 모각코 4회차

김현수 : 모각코 3회차

박광욱 : 모각코 3회차

박종경 : 모각코 3회차

정주헌 : 모각코 3회차

최원준 : 모각코 3회차

AI공동경진대회 준비 및 VIS(Video Instance Segmentation) 관련 논문을 읽어보자.

사용 언어

Python

일정

3회차: 7/22 13:00 ~ 16:00

3회차 목표 : GenVIS 논문 리뷰

• 등장 배경 앞선 선행 연구들은 Online, Offline 다양한 방식으로 VIS Task를 수행해왔다.

• Online* : Offline 모델에 비해 성능이 떨어짐, frame 혹은 clip 간 matching association method가 필요

• Offline* : 모델에 적용할 수 있는 Video 크기가 제한적임. 따라서 본 논문에서는 일반적인 환경에서 Video input의 크기 제한을 덜 받는 모델을 제안한다.

• 핵심 기술

  • clip과 clip 사이의 관계 학습
  • new learning criterion 및 Unified Video Label Assignment(UVLA) 제안
  • memory mechanism 적용

• 모델 구조

• 결과

  • Datasets : YouTube-VIS 2019, 2021, 2022, OVIS

• 한계점

  • Window size를 조정할 수 없다.
  • 고유 ID를 할당하므로 한 Frame에 매우 많은 object가 있을 경우는 처리 할 수 없다.

  ---

김현수 : 모각코 2회차

박광욱 : 모각코 2회차

박종경 : 모각코 2회차

정주헌 : 모각코 2회차

최원준 : 모각코 2회차

사용 언어 Python

일정 2회차: 7/15 13:00 ~ 16:00

목표 : DeeplabV3+ 논문 리뷰 및 코드 구현

모델 구조

모델 특징

• Astrous convolution을 사용하여 receptive field를 효과적으로 키울 수 있었다. 여기서 Astrous convolution은 아래에 있는 그림처럼 특징 길이만큼 띄워서 convolution 연산을 수행하는 것이다.
• Astrous separable depthwise convolution을 통해 기존의 연산량을 줄일 수 있었다.

해당 논문에서는 모델 구현을 위한 Backbone으로 Xception과 Resnet-101을 사용하였으며 코드 구조는 아래 그림과 같다.

그 결과 기존의 존재하는 모델의 성능을 뛰어넘은 SOTA(state-of-the-art)를 달성하였다.

코드구현

import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.model_zoo as model_zoo

class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, rate=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                               dilation=rate, padding=rate, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * 4)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride
        self.rate = rate

    def forward(self, x):
        residual = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        if self.downsample is not None:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)

        return out

class ResNet(nn.Module):

    def __init__(self, nInputChannels, block, layers, os=16, pretrained=False):
        self.inplanes = 64
        super(ResNet, self).__init__()
        if os == 16:
            strides = [1, 2, 2, 1]
            rates = [1, 1, 1, 2]
            blocks = [1, 2, 4]
        elif os == 8:
            strides = [1, 2, 1, 1]
            rates = [1, 1, 2, 2]
            blocks = [1, 2, 1]
        else:
            raise NotImplementedError

        # Modules
        self.conv1 = nn.Conv2d(nInputChannels, 64, kernel_size=7, stride=2, padding=3,
                                bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.layer1 = self._make_layer(block, 64, layers[0], stride=strides[0], rate=rates[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=strides[1], rate=rates[1])
        self.layer3 = self._make_layer(block, 256, layers[2], stride=strides[2], rate=rates[2])
        self.layer4 = self._make_MG_unit(block, 512, blocks=blocks, stride=strides[3], rate=rates[3])

        self._init_weight()

        if pretrained:
            self._load_pretrained_model()

    def _make_layer(self, block, planes, blocks, stride=1, rate=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, rate, downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def _make_MG_unit(self, block, planes, blocks=[1,2,4], stride=1, rate=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, rate=blocks[0]*rate, downsample=downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, len(blocks)):
            layers.append(block(self.inplanes, planes, stride=1, rate=blocks[i]*rate))

        return nn.Sequential(*layers)

    def forward(self, input):
        x = self.conv1(input)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        low_level_feat = x
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        return x, low_level_feat

    def _init_weight(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                # m.weight.data.normal_(0, math.sqrt(2. / n))
                torch.nn.init.kaiming_normal_(m.weight)
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()

    def _load_pretrained_model(self):
        pretrain_dict = model_zoo.load_url('https://download.pytorch.org/models/resnet101-5d3b4d8f.pth')
        model_dict = {}
        state_dict = self.state_dict()
        for k, v in pretrain_dict.items():
            if k in state_dict:
                model_dict[k] = v
        state_dict.update(model_dict)
        self.load_state_dict(state_dict)

def ResNet101(nInputChannels=3, os=16, pretrained=False):
    model = ResNet(nInputChannels, Bottleneck, [3, 4, 23, 3], os, pretrained=pretrained)
    return model


class ASPP_module(nn.Module):
    def __init__(self, inplanes, planes, rate):
        super(ASPP_module, self).__init__()
        if rate == 1:
            kernel_size = 1
            padding = 0
        else:
            kernel_size = 3
            padding = rate
        self.atrous_convolution = nn.Conv2d(inplanes, planes, kernel_size=kernel_size,
                                            stride=1, padding=padding, dilation=rate, bias=False)
        self.bn = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(p=0.3)
        self._init_weight()

    def forward(self, x):
        x = self.atrous_convolution(x)
        x = self.bn(x)
        x = self.relu(x)
        # x = self.dropout(x)
        return x

    def _init_weight(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                # m.weight.data.normal_(0, math.sqrt(2. / n))
                torch.nn.init.kaiming_normal_(m.weight)
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()


class DeepLabv3_plus(nn.Module):
    def __init__(self, nInputChannels=3, n_classes=2, os=16, pretrained=False, _print=True):
        if _print:
            print("Constructing DeepLabv3+ model...")
            print("Number of classes: {}".format(n_classes))
            print("Output stride: {}".format(os))
            print("Number of Input Channels: {}".format(nInputChannels))
        super(DeepLabv3_plus, self).__init__()

        # Atrous Conv
        self.resnet_features = ResNet101(nInputChannels, os, pretrained=pretrained)

        # ASPP
        if os == 16:
            rates = [1, 6, 12, 18]
        elif os == 8:
            rates = [1, 12, 24, 36]
        else:
            raise NotImplementedError

        self.aspp1 = ASPP_module(2048, 256, rate=rates[0])
        self.aspp2 = ASPP_module(2048, 256, rate=rates[1])
        self.aspp3 = ASPP_module(2048, 256, rate=rates[2])
        self.aspp4 = ASPP_module(2048, 256, rate=rates[3])

        self.relu = nn.ReLU()

        self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
                                             nn.Conv2d(2048, 256, 1, stride=1, bias=False),
                                             nn.BatchNorm2d(256),
                                             nn.ReLU())


        self.dropout = nn.Dropout(p=0.3)            # define dropout layer
        self.conv1 = nn.Conv2d(1280, 256, 1, bias=False)
        self.bn1 = nn.BatchNorm2d(256)

        # adopt [1x1, 48] for channel reduction.
        self.conv2 = nn.Conv2d(256, 48, 1, bias=False)
        self.bn2 = nn.BatchNorm2d(48)

        self.last_conv = nn.Sequential(nn.Conv2d(304, 256, kernel_size=3, stride=1, padding=1, bias=False),
                                       nn.BatchNorm2d(256),
                                       nn.ReLU(),
                                       nn.Dropout(p=0.3),
                                       nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
                                       nn.BatchNorm2d(256),
                                       nn.ReLU(),
                                       nn.Dropout(p=0.3),
                                       nn.Conv2d(256, n_classes, kernel_size=1, stride=1))

    def forward(self, input):
        x, low_level_features = self.resnet_features(input)
        x1 = self.aspp1(x)
        x2 = self.aspp2(x)
        x3 = self.aspp3(x)
        x4 = self.aspp4(x)
        x5 = self.global_avg_pool(x)

        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)

        x = torch.cat((x1, x2, x3, x4, x5), dim=1)

        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.dropout(x)                                         # add dropout layer
        x = F.upsample(x, size=(int(math.ceil(input.size()[-2]/4)),
                                int(math.ceil(input.size()[-1]/4))), mode='bilinear', align_corners=True)

        low_level_features = self.conv2(low_level_features)
        low_level_features = self.bn2(low_level_features)
        low_level_features = self.relu(low_level_features)
        low_level_features = self.dropout(low_level_features)       # add dropout layer

        x = torch.cat((x, low_level_features), dim=1)
        x = self.last_conv(x)
        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)

        return x

    def freeze_bn(self):
        for m in self.modules():
            if isinstance(m, nn.BatchNorm2d):
                m.eval()

    def __init_weight(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                # m.weight.data.normal_(0, math.sqrt(2. / n))
                torch.nn.init.kaiming_normal_(m.weight)
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()

def get_1x_lr_params(model):
    """
    This generator returns all the parameters of the net except for
    the last classification layer. Note that for each batchnorm layer,
    requires_grad is set to False in deeplab_resnet.py, therefore this function does not return
    any batchnorm parameter
    """
    b = [model.resnet_features]
    for i in range(len(b)):
        for k in b[i].parameters():
            if k.requires_grad:
                yield k


def get_10x_lr_params(model):
    """
    This generator returns all the parameters for the last layer of the net,
    which does the classification of pixel into classes
    """
    b = [model.aspp1, model.aspp2, model.aspp3, model.aspp4, model.conv1, model.conv2, model.last_conv]
    for j in range(len(b)):
        for k in b[j].parameters():
            if k.requires_grad:
                yield k


if __name__ == "__main__":
    model = DeepLabv3_plus(nInputChannels=3, n_classes=1, os=16, pretrained=True, _print=True)
    model.eval()
    image = torch.randn(1, 3, 512, 512)
    with torch.no_grad():
        output = model.forward(image)
    print(output.size())

김현수 : 모각코 1회차

박광욱 : 모각코 1회차

박종경 : 모각코 1회차

정주헌 : 모각코 1회차

최원준 : 모각코 1회차

사용 언어 Python

일정 1회차: 7/7 20:00 ~ 23:00 목표 : AI공동경진대회 baseline 코드 실행 및 데이터셋 분석

baseline 코드의 경우 UNet을 기반으로 하였고 코드는 아래와 같았다.

import os
import cv2
import pandas as pd
import numpy as np

import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms

from tqdm import tqdm
import albumentations as A
from albumentations.pytorch import ToTensorV2

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# RLE 디코딩 함수
def rle_decode(mask_rle, shape):
    s = mask_rle.split()
    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]
    starts -= 1
    ends = starts + lengths
    img = np.zeros(shape[0]*shape[1], dtype=np.uint8)
    for lo, hi in zip(starts, ends):
        img[lo:hi] = 1
    return img.reshape(shape)

# RLE 인코딩 함수
def rle_encode(mask):
    pixels = mask.flatten()
    pixels = np.concatenate([[0], pixels, [0]])
    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
    runs[1::2] -= runs[::2]
    return ' '.join(str(x) for x in runs)

class SatelliteDataset(Dataset):
    def __init__(self, csv_file, transform=None, infer=False):
        self.data = pd.read_csv(csv_file)
        self.transform = transform
        self.infer = infer

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

    def __getitem__(self, idx):
        img_path = self.data.iloc[idx, 1]
        image = cv2.imread(img_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        if self.infer:
            if self.transform:
                image = self.transform(image=image)['image']
            return image

        mask_rle = self.data.iloc[idx, 2]
        mask = rle_decode(mask_rle, (image.shape[0], image.shape[1]))

        if self.transform:
            augmented = self.transform(image=image, mask=mask)
            image = augmented['image']
            mask = augmented['mask']

        return image, mask

 transform = A.Compose(
    [   
        A.Resize(224, 224),
        A.Normalize(),
        ToTensorV2()
    ]
)

dataset = SatelliteDataset(csv_file='./train.csv', transform=transform)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True, num_workers=4)

# U-Net의 기본 구성 요소인 Double Convolution Block을 정의합니다.
def double_conv(in_channels, out_channels):
    return nn.Sequential(
        nn.Conv2d(in_channels, out_channels, 3, padding=1),
        nn.ReLU(inplace=True),
        nn.Conv2d(out_channels, out_channels, 3, padding=1),
        nn.ReLU(inplace=True)
    )

# 간단한 U-Net 모델 정의
class UNet(nn.Module):
    def __init__(self):
        super(UNet, self).__init__()
        self.dconv_down1 = double_conv(3, 64)
        self.dconv_down2 = double_conv(64, 128)
        self.dconv_down3 = double_conv(128, 256)
        self.dconv_down4 = double_conv(256, 512)

        self.maxpool = nn.MaxPool2d(2)
        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)        

        self.dconv_up3 = double_conv(256 + 512, 256)
        self.dconv_up2 = double_conv(128 + 256, 128)
        self.dconv_up1 = double_conv(128 + 64, 64)

        self.conv_last = nn.Conv2d(64, 1, 1)

    def forward(self, x):
        conv1 = self.dconv_down1(x)
        x = self.maxpool(conv1)

        conv2 = self.dconv_down2(x)
        x = self.maxpool(conv2)

        conv3 = self.dconv_down3(x)
        x = self.maxpool(conv3)   

        x = self.dconv_down4(x)

        x = self.upsample(x)        
        x = torch.cat([x, conv3], dim=1)

        x = self.dconv_up3(x)
        x = self.upsample(x)        
        x = torch.cat([x, conv2], dim=1)       

        x = self.dconv_up2(x)
        x = self.upsample(x)        
        x = torch.cat([x, conv1], dim=1)   

        x = self.dconv_up1(x)

        out = self.conv_last(x)

        return out

# model 초기화
model = UNet().to(device)

# loss function과 optimizer 정의
criterion = torch.nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# training loop
for epoch in range(10):  # 10 에폭 동안 학습합니다.
    model.train()
    epoch_loss = 0
    for images, masks in tqdm(dataloader):
        images = images.float().to(device)
        masks = masks.float().to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, masks.unsqueeze(1))
        loss.backward()
        optimizer.step()

        epoch_loss += loss.item()

    print(f'Epoch {epoch+1}, Loss: {epoch_loss/len(dataloader)}')

test_dataset = SatelliteDataset(csv_file='./test.csv', transform=transform, infer=True)
test_dataloader = DataLoader(test_dataset, batch_size=16, shuffle=False, num_workers=4)

with torch.no_grad():
    model.eval()
    result = []
    for images in tqdm(test_dataloader):
        images = images.float().to(device)

        outputs = model(images)
        masks = torch.sigmoid(outputs).cpu().numpy()
        masks = np.squeeze(masks, axis=1)
        masks = (masks > 0.35).astype(np.uint8) # Threshold = 0.35

        for i in range(len(images)):
            mask_rle = rle_encode(masks[i])
            if mask_rle == '': # 예측된 건물 픽셀이 아예 없는 경우 -1
                result.append(-1)
            else:
                result.append(mask_rle)

submit = pd.read_csv('./sample_submission.csv')
submit['mask_rle'] = result
submit.to_csv('./submit.csv', index=False)

** Baseline 분석** Baseline의 성능은 0.2204로 측정되었다. 모델이 매우 단순하므로 UNet의 encoder부분을 Resnet 50 layer로 바꾸어 finetuning하는 방식으로 바꾸거나 더 나은 모델로 교체해야한다고 판단하였다.

Dataset 분석 Train image 크기 : 1024 * 1024

Train image 용량 : 13.0GB, 7140 장

Test image 크기 : 224 * 224

Test image 용량 : 5.4GB, 60640 장

Train image 개수가 Test image에 비해 매우 적어 Data Augmentation이 필요하다고 판단하였고, Train과 Test image 픽셀 값이 다르므로 Test image를 기준으로 맞추어야한다고 생각하였다.

목표 AI공동경진대회 준비 및 VIS(Video Instance Segmentation) 관련 논문을 읽어보자.

사용 언어 Python

일정 1회차: 7/7 20:00 ~ 23:00 목표 : AI공동경진대회 baseline 코드 실행 및 데이터셋 분석

2회차: 7/15 13:00 ~ 16:00 목표 : DeeplabV3+ 논문 리뷰 및 코드 구현

3회차: 7/22 13:00 ~ 16:00 목표 : VIS 관련 논문 리뷰 1

4회차 : 7/29 13:00 ~ 16:00 목표 : VIS 관련 논문 리뷰 2

5회차 : 8/5 13:00 ~ 16:00 목표 : VIS 관련 논문 리뷰 3

6회차 : 8/12 13:00 ~ 16:00 목표 : VIS 관련 논문 리뷰 4

해당 논문은 인공위성 이미지를 가지고 Semantic Segmentation을 하는 과정에 대해 서술하였다.

이들은 IGN Open data를 활용하였고 모델은 Swin Transformer를 사용하였다.

이 때 Swin Transformer의 경우 mmsegmentation을 기반으로 만들었다.

Dataset

• BD Ortho for the satelite images
• BD Foret v2 for vegetation data
• BD Topo for buildings and roads

클래스를 6개(Sparse forest, Dense forest, Moor, Herbaceous formation, Building, Road)로 축소하였다.

학습 시 ImageNet-22K로 사전학습된 모델을 가져와 사용하였고 Class Imbalnaced 문제 때문에 각 클래스별로 추가적인 weight를 더하였다. '

결과는 위의 그림과 같았고 총 3가지 한계점이 존재했다.

1. 위성 사진과 original segmentation은 같은 시간에 만들어진 것이 아니기 때문에 항상 정확하지는 않다.
2. 데이터셋에 정보가 없는 구간이 존재한다. 따라서 일정 비율 이상 정보가 없을 경우 제거해야한다.
3. 도로 segmentation은 다른 image에 가려져 안보이는 경우가 있어 정확하지 않다.

팀장 : 정주헌 팀원 : 김현수, 박광욱, 박종경, 최원준