들어가며

최근 업무를 보면서 학습 데이터가 지속적으로 증가하는 경우가 발생하다보니 Incremental Leanring에 대해서 공부를 하는 경우가 생겼다. 그렇다보니 자연스럽게 2D object detection이외에 다른 분야에도 있을까 생각하고 찾아보다 보니 해당논문을 찾게 되어졌다. 

이 논문의 경우 AAAI 2022년 Oral paper로 되어진 논문으로 3D 분야에서 처음으로 적용한 부분이다 보니 더욱 주목 받는 방법이 아닐까 생각이든다. 

아래의 그림처럼 Incremental Learning의 기조를 따라가다 보니 Novel Class에 대해서 객체를 찾게 되어지고 기본 Base Classes에서도 여전히 찾게 되어지는것을 볼 수 있다.

그렇다면 이 논문의 핵심 아이디어의 핵심은 새로운 Task에 적용한것 말고 어떤것이 있을까? 

저자는 새로운 아디이어로 Pesudo Labeling을 방식을 제안했다. 일반적인 방식이 있을수도 있지만 이전의 Task에서 만들어진 모델을 바탕으로 새로운 Novel에 기존의 Base의 class에 Pesudo labeling을 같이 넣어서 학습을 시키는것이다. 

그렇게 되면 Pesudo labeling의 중요성이 높아지는데 이를 해결하기 위해서 Techer Student Model을 들고왔고, Static & Dynamic 이라는 두개의 Teacher를 들고오면서 해당 문제를 해결했다고 한다. 

그러면 자세하게 이 논문이 어떤 방식으로 문제를 풀었는지 살펴보자. 

방법

Baseline Model

3D에 접근하기 위해서는 저자는 Point Clould Object Detection의 기본이 되어지는 모델일 VoteNet을 수정해서 개선이 되었다고 한다. 

VoteNet의 경우 아래의 그림과 같이 있는데 $X$라는 XYZ를 가지는 좌표값을 넣어 Featuer를 추가한 $S$라는 seeds를 뽑아낸다. 이 과정까지는 일반적인 방법이지만 Voting Module이라는 방식을 통해서 Point들을 대표할수 있는 지점을 뽑고 그 주위의 Point들을 구성해서 새롭게 만들어낸다. 이를 통해서 $V$라는 point들이 최정적으로 나오게 되어진다. 

이 point들을 바탕으로 Detection이 수행이 되어진다.

SDCOT 모델방식

Pesudo Label Generation 

이전에 말했던것처럼 이 논문의 경우 Peusdo label을 만드는것에 아디어를 더했다고 한다. 

Novel Class를 학습할때 Base Class로 학습 했던 모델을 Novel Class에 Peusdo labeling을 만들어서 적용했다고 한다. 

이 Peusdo labeling을 만드는건 생각보다 너무 쉬운데 Low-confidence box 부분을 지웠고 그리고 Classification 의 확률값과 바탕으로 낮은 Prob을 가진 Class도 Pesudo labeing이 넣지 않는 방식을 선택했다. 

그럼에도 불구하고 부정확한 결과가 나온다는데 이를 해결하기 위해서 아래의 새로운 방법을 사용한다. 

Static-Dynamic Co-Teaching

저자는 부정확한 결과를 개선하기 위해서 Static Teacher과 Dynamic Teacher를 2개를 만들어서 작업을 하는데 각각의 Teacher의 하는 역할은 다음과 같이 나뉘어진다. 

Static Teacher의 경우는 Base Class로 학습한후 Freeze되어진 모델이며 이 Teacher의 역할은 Peusdo labeling을 만들어 내는 역할을 하며 Distillation을 Student에 하는 역할로 보면되어진다. 

Dynmaic Teacher의 경우는 기존의 Student에 대해서 EMA가 진행이 되어짐과 동시게 Input에 대해서 Consistency를 유지하기 위한 역할을 수행한다. 

전체적인 흐름은 아래의 그림과 같이 되어진다. 

그러면 각각의 Loss는 아래와 같이 되어진다. 

Distillation Loss의 경우는 Student와 Static Teacher의 SoftMax이전의 Logit의 값의 차이를 최소화하는 작업을 말한다. 그럴경우 이전의 Knwoledge를 Distiliation하는 효과가 있다. 

Supervised Loss의 경우는 기존의 CE로 적용이 되어지면 Novel Class를 추가해서 BaseL Class와 함께 재 학습을 하는데 이때 Base Class의 경우는 Static Teacher에서 나온 Pesudo label로 적용이 되어서 학습이 되어진다. 

Consistency Loss의 경우에서는 SimCLR와 같은 Loss를 사용한다고 보면된다.

방법은 너무 단순하지만 효과적으로 나오며 기존에 접근하지 않았던 새로운 방법이라 확실히 성능적인 면은 효과가 있다. 

2 0 0 0 1 1 0
0 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 0 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

2 1 0 0 1 1 0
1 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 1 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

2 1 0 0 1 1 2
1 0 1 0 1 2 2
0 1 1 0 1 2 2
0 1 0 0 0 1 2
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

7 7
2 0 0 0 1 1 0
0 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 0 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

27

4 6
0 0 0 0 0 0
1 0 0 0 0 2
1 1 1 0 0 2
0 0 0 0 0 2

9

Solution

1. 이 문제의 경우에서는 완전탐색으로 풀어야 된다. 그렇다면 BFS/DFS둘중에 하나이다. 

2. 바이러스의 대한 정보를 저장해놓는것이 중요함.

3. 4방향으로 바이러스는 퍼짐

4. 백트레킹으로 시간단축을 해야됨 

5. 하지만 combination으로 변경해서 풀면 시간 내에 풀림 

import sys
import copy
from collections import deque
from itertools import combinations
input = sys.stdin.readline
N,M = list(map(int,input().split()))

# 바이러스 위치 추출
maps = []
birus_list = []
y_x_list = []
for yidx in range(N): 
    row = list(map(int,input().split()))
    maps.append(row)
    for xidx, j in enumerate(row): 
        if j == 2 : 
            birus_list.append([yidx, xidx])
        if j == 0 : 
            y_x_list.append([yidx,xidx])

moves = [[-1,0],[1,0],[0,-1],[0,1]] # moving
answer = 0 
def move_avaiable(y,x,tmp_maps): 
    return 0<=y<N and 0<=x<M and tmp_maps[y][x] == 0

def cal_area(tmp_maps): 
    return sum([row.count(0) for row in tmp_maps])

def bfs(): 
    global answer
    q = deque(birus_list)
    tmp_maps = copy.deepcopy(maps)

    while q: 
        y, x = q.popleft()
        for dy, dx in moves: 
            ny, nx = dy + y, dx + x
            if move_avaiable(ny, nx, tmp_maps): #이동가능하면 퍼진다.
                tmp_maps[ny][nx] = 2 # 새롭게
                q.append([ny,nx])
    count = cal_area(tmp_maps)
    answer = max(answer, count)
    return 
# map의 기준으로 벽생성
# def make_wall(cnt): 
#     if cnt == 3: 
#         bfs()
#         return 
#     for j in range(N): 
#         for i in range(M): 
#             if maps[j][i] == 0 : 
#                 maps[j][i] = 1
#                 make_wall(cnt+1)
#                 maps[j][i] = 0 # backtrking

def make_wall(cnt): 
    for c in combinations(y_x_list,3): 
        for cy, cx in c:  maps[cy][cx] = 1
        bfs()
        for cy, cx in c:  maps[cy][cx] = 0

make_wall(0)
print(answer)

https://www.acmicpc.net/problem/14500

문제

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다.

• 정사각형은 서로 겹치면 안 된다.
• 도형은 모두 연결되어 있어야 한다.
• 정사각형의 변끼리 연결되어 있어야 한다. 즉, 꼭짓점과 꼭짓점만 맞닿아 있으면 안 된다.

정사각형 4개를 이어 붙인 폴리오미노는 테트로미노라고 하며, 다음과 같은 5가지가 있다.

아름이는 크기가 N×M인 종이 위에 테트로미노 하나를 놓으려고 한다. 종이는 1×1 크기의 칸으로 나누어져 있으며, 각각의 칸에는 정수가 하나 쓰여 있다.

테트로미노 하나를 적절히 놓아서 테트로미노가 놓인 칸에 쓰여 있는 수들의 합을 최대로 하는 프로그램을 작성하시오.

테트로미노는 반드시 한 정사각형이 정확히 하나의 칸을 포함하도록 놓아야 하며, 회전이나 대칭을 시켜도 된다.

5 5
1 2 3 4 5
5 4 3 2 1
2 3 4 5 6
6 5 4 3 2
1 2 1 2 1

19

4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

20

4 10
1 2 1 2 1 2 1 2 1 2
2 1 2 1 2 1 2 1 2 1
1 2 1 2 1 2 1 2 1 2
2 1 2 1 2 1 2 1 2 1

7

https://www.acmicpc.net/problem/3190

6
3
3 4
2 5
5 3
3
3 D
15 L
17 D

9

10
4
1 2
1 3
1 4
1 5
4
8 D
10 D
11 D
13 L

21

10
5
1 5
1 3
1 2
1 6
1 7
4
8 D
10 D
11 D
13 L

13

문제방법

1. 문제대로 차근차근이 읽으면서 경우의 수를 생각해서 예외처리해주면됨 

2. 큐의 형태로 생각하면서 문제를 풀자.

from collections import deque
import sys
inputs = sys.stdin.readline
N = int(inputs())
maps = [[0]*N for _ in range(N)]

K = int(inputs())
apple_index = [list(map(int,inputs().split())) for _ in range(K)]
for y,x in apple_index:
    maps[y-1][x-1] = -1 # 사과 있음 

D = int(inputs())
directions = {}
for i in range(D):
    x, c = input().split()
    directions[int(x)] = c

move = [[0,1],[1,0],[0,-1],[-1,0]] #오하왼상 
## 몇초안에 끝나는지.. 계속 길이가 길어지고 있음 & 큐로 푸는것임.. 구현문제도 맞는듯.. 

def rotate_direction(curr_dir, move_idx): 
    if curr_dir == 'L': 
        move_idx -= 1
    elif curr_dir == 'D': 
        move_idx += 1
    return move_idx%4

# 너무 어렵게 생각하지말자.뱀의 길이가 이전의 길이에 따라오면 되는 것이 핵심 아이디어도 
y, x, curr_dir = 0,0,0
start_time = 0 

q = deque()
q.append((y,x))
while True : 
    start_time += 1 
    dy, dx = move[curr_dir] # 초기 방향설정
    ny, nx = y + dy, x + dx # 다음길이로 이동
    if ny < 0 or ny >= N or nx < 0 or nx >= N or (ny,nx) in q:  # 벽에 부딧치거나 꼬리에 부딧치면 게임 끝
        break
    # 사과를 먹지 못한다면 꼬리가 따라다님
    if maps[ny][nx] != -1:
        ty,tx = q.popleft()
        maps[ty][tx]=0
    
    # 지나갈때마다 경로를 체크
    y, x = ny, nx
    maps[ny][nx] = 1
    q.append((ny, nx))
	
    # 시간에 해당하는 방향전환 정보가 있을 경우
    if start_time in directions.keys():
        curr_dir = rotate_direction(directions[start_time], curr_dir)
print(start_time)

https://www.acmicpc.net/problem/14499

  2
4 1 3
  5
  6

4 2 0 0 8
0 2
3 4
5 6
7 8
4 4 4 1 3 3 3 2

0
0
3
0
0
8
6
3

3 3 1 1 9
1 2 3
4 0 5
6 7 8
1 3 2 2 4 4 1 1 3

0
0
0
3
0
1
0
6
0

문제풀이 

1. 구현문제이기때문에 3차원에서 주사위가 굴러갈때 변경되는 값을 저장해놓으면 쉽다.

2. 그외에 시작점이나 변수선언에 유의해서 작성하자 

import sys
inputs = sys.stdin.readline
N,M,y,x,K = list(map(int, inputs().split()))
maps = [list(map(int, inputs().split())) for i in range(N)]
direction = list(map(int, inputs().split()))

dice = [0,0,0,0,0,0]
move = [[0,1],[0,-1],[-1,0],[1,0]] #동서북남
sy,sx = y,x

def flip(dice, direct): 
    a,b,c,d,e,f = dice
    if direct == 1: #동    
        dice = d,b,a,f,e,c
    elif direct == 2: #서 
        dice = c,b,f,a,e,d
    elif direct == 3 : #북 
        dice = e,a,c,d,f,b
    elif direct == 4: #남
        dice = b,f,c,d,a,e
    return list(dice)

#주사위 문제로써 구현문제라고 볼 수 있다.
answer = []
for direct in direction: 
    dy,dx = move[direct-1]
    ny, nx = sy+dy, sx+dx
    if 0<=ny<N and 0<=nx<M: #범위안에서만 동작한다. 주사위가 돌아갔으며 위치도 위치도 이동함
        sy, sx = ny, nx
        
        dice = flip(dice, direct)
        
        if maps[ny][nx] == 0 : # 바닥면이 0이면 주사위의 값이 복사가 되어진다. 
            maps[ny][nx] = dice[-1]

        else: # 아닐경우 바닥면에 주사위의 밑으로 복사가 되어짐
            dice[-1] = maps[ny][nx] 
            maps[ny][nx] = 0 # 바닥은 0으로 변경됨 
        print(dice[0])

5 5
#####
#..B#
#.#.#
#RO.#
#####

1

7 7
#######
#...RB#
#.#####
#.....#
#####.#
#O....#
#######

5

문제 해결 

1. 구조를 하나씩 나눠서 생각하자. (공은 함께 움직임으로 같이 묶어서 생각, 공이 벽에 부딧칠경우, 공이 만날경우 등등..) 

2. (), []는 아예 구조가 다름으로 visited할때 유의 하자. 

import time
from collections import deque
import sys

inputs = sys.stdin.readline
N,M = list(map(int,inputs().split()))

maps = []
for i in range(N): 
    row = list(inputs().strip())
    maps.append(row)
    if 'R' in row: 
        ry, rx = [i, row.index('R')]

    if 'B' in row: 
        by, bx = [i, row.index('B')]

move = [[-1,0],[1,0],[0,-1],[0,1]]
q = deque()
q.append([ry, rx, by, bx])
visited = [] # 방문여부를 판단하기 위한 리스트
visited.append((ry, rx, by, bx))
s = time.time()
# find start point 
def bfs(q, maps):     
    
    cnt = 0 
    while q: 
        for _ in range(len(q)): 
            ry, rx, by, bx = q.popleft()
            # print(ry,rx,by,bx)
            if cnt > 10: # 조건에서는 10번 이하로 움직이라고 하였음.
                print(-1)
                return 
            if maps[ry][rx] == 'O': 
                print(cnt)
                return 
            
            for dy, dx in move : 
                nry, nrx = ry, rx # 빨간색 공 
                nby, nbx = by, bx # 파란색 공 

                while True : # 계속 해당 방향으로 쭉 가기  
                    nry += dy 
                    nrx += dx
                    if maps[nry][nrx] == '#': #벽에 부딧치면 나오기 
                        nry -= dy 
                        nrx -= dx
                        break
                    if maps[nry][nrx] == 'O': # 빨간공이 들어가버린다면
                        break
                
                while True : # 계속 해당 방향으로 쭉 가기  
                    nby += dy
                    nbx += dx
                    if maps[nby][nbx] == '#': #벽에 부딧치면 나오기 
                        nby -= dy
                        nbx -= dx
                        break
                    if maps[nby][nbx] == 'O': # 만약에 파란공이 들어가버린다면? 
                        break 

                if maps[nby][nbx] == 'O': 
                    continue 
            
                if nry == nby and nrx == nbx: #만약에 가다가 만났다면!!
                    if abs(nrx - rx) + abs(nry - ry) > abs(nbx - bx) + abs(nby - by): 
                        nry -= dy
                        nrx -= dx
                    else:
                        nby -= dy
                        nbx -= dx

                if (nry, nrx, nby, nbx) not in visited: # 방문해본적이 없는 위치라면 새로 큐에 추가 후 방문 처리
                    q.append((nry, nrx, nby, nbx))
                    visited.append((nry, nrx, nby, nbx))
                    # print(time.time()-s)
                
        cnt += 1 # 다음큐가 벽에 부딧쳤을떄 시작한다. 
    print(-1)
    
bfs(q, maps)

1
1
1 1

1

3
3 4 5
2 2

7

문제 해결 

1. 단순하게 계산문제임으로 문제를 이해를 하고 계산하면된다. 

import sys
import math
inputs = sys.stdin.readline

N = int(inputs())
A_list = list(map(int, inputs().split()))
B, C = list(map(int,inputs().split()))
count = 0
for student in A_list: 
    count += 1
    remain_student = student - B
    if remain_student > 0: 
        count += math.ceil(remain_student / C)
    else: 
        pass

print(count)

Introduction 

최근 알고리즘 테스트를 하면서 느낀점은 시뮬레이션, DFS/BFS는 그래도 손에 익기 시작했는데 아직까지 Stack과 큐의 문제만 나오는 경우에서는 잘 못 푸는 나의 모습을 발견하였다.. 

이번에 공부를 하면서 스택/큐의 개념에 대해서 다시 공부를 하였으며 어떠한 방법들이 있는지 다시 되돌아볼수 있었다. 

많은 블로그를 참고를 하였지만 결국 개념은 스택의 경우는 FILO(First in Last out) 큐의 경우는 FIFO(First in First out)이라는 것을 명심해두자. 

Solution

아직 많이 부족한 나지만 문제를 풀다보면 스택과 큐를 풀수 있는 실마리를 찾는게 매우 중요하다.

또한 스택/큐 로 풀면 되겠다고 생각하더라도 문제 해결과정을 머리에서 빨리 돌아가야지 풀수있다. 

그렇기에 내가 빨리 풀수 있다고 느낀점은 다음과 같았다. 

1. 효율성을 생각해보기 

2. 그림으로 그려보기

첫번쨰 효율성의 경우에서는 보통 샘플이 10,000 이하로 주는 경우가 많다. 이경우에서는 단순하게 $O(N^2)$로 생각해보면 time complexity가 높겠네 생각이 들기 마련이다. 

그렇게 되면 스택, 큐, 해시로 풀수 있겠네라고 생각해볼수 있따. 

두번째는 확실하게 느낀점이지만 그림으로 그리면 쉽게 생각이 되어진다. 스택과 큐의 그림은 쉽게 그릴수 있지만 직접그려본 사람이 없지 않는가라고 생각이 든다. 

그렇기 떄문에 고수가 아닌이상 그리면서 문제를 풀어보자. !!

Problem

내가 스택을 이용해서 푼 문제들은 프로그래머스의 고득점 Kit에서 참고하여 풀었다 .

Level2이상은 대부분 코테에서 통과할만한 수준이라고 하여서 해당방법 위주로 정리하였다.

문제1 : https://school.programmers.co.kr/learn/courses/30/lessons/42586 기능개발 

해당문제의 경우에서는 

작업 개수에 걸린 시간과 그에 따른 시간을 측정해서 최종 시간을 return하는 문제이다. 

내가 푼 방법은 Stack으로 풀었기 떄문에  그방법을 공유해본다

import math
def solution(progresses, speeds):
    ## 일단 progress당 걸리는 시간을 미리 계산해보자. 
    work_days = [math.ceil((100 - progress)/work_time) \
        for progress, work_time in zip(progresses, speeds)] # 소요시간 미리 계싼
    
    if len(work_days) == 1: # 만약에 하나라면 지금 걸리는 시간 출력
        return [work_days[0]]
    
    front = 0 
    answer = []
    for idx, _ in enumerate(work_days): 
        if work_days[idx] > work_days[front]: # 앞으로 온다음에 CUT!!!
            answer.append(idx-front)
            front = idx
    answer.append(len(work_days) -  front)
    return answer

그림으로 그리면 Stack의 형태로 그려진다. 

만약 `Work_days` 라는 변수가 [7,3,9]라고 나온다고 하면 최종 return 은 [2,1]로 나온다. 

7,4,9를 stack으로 만들어서 넣으면 되다

https://school.programmers.co.kr/learn/courses/30/lessons/42583

문제 설명

트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다. 단, 다리에 완전히 오르지 않은 트럭의 무게는 무시합니다.

예를 들어, 트럭 2대가 올라갈 수 있고 무게를 10kg까지 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

경과 시간다리를 지난 트럭다리를 건너는 트럭대기 트럭

따라서, 모든 트럭이 다리를 지나려면 최소 8초가 걸립니다.

solution 함수의 매개변수로 다리에 올라갈 수 있는 트럭 수 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭 별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.

제한 조건

• bridge_length는 1 이상 10,000 이하입니다.
• weight는 1 이상 10,000 이하입니다.
• truck_weights의 길이는 1 이상 10,000 이하입니다.
• 모든 트럭의 무게는 1 이상 weight 이하입니다.

입출력 예

 

문제풀이 

중요한건 다리를 큐로 생각하고 진행한다는점 

 

from collections import deque
def solution(bridge_length, weight, truck_weights):
    
    # 2개의 큐 구조를 사용해서 문제를 풀어보자. 
    q = deque(truck_weights)
    weight_q = deque([0] * bridge_length) # 다리를 큐 모양으로 만들자. 
    curr_weigth = 0 
    answer = 0 
    
    while q : # bright 작동
        answer += 1

        curr_weigth -= weight_q.popleft()
        if curr_weigth + q[0] <= weight:
            curr_weigth += q[0]
            weight_q.append(q.popleft())
        else: 
            weight_q.append(0)
            
    answer += bridge_length
    return answer

 

스터디 참여 동기 & 나의 모습

항상 해외 주식에 관심이 많아서 ETF나 개별주식(Nvidia, Apple etc)등 다양하게 투자를 하였습니다. 

하지만 주변 사람들이 주식시장이 안 좋다고 하면 저도 모르게 불안해지고 내가 팔면 다시 주식이 올라가서 손해를 보는 상황도 많이 발생을 하였습니다. ㅠㅠ

이를 해결하고자 여러 시도를 하였는데  책을 읽자니 지루하고 유튜브를 보자니.. 재미가 없고 공부를 하고 싶고.. 이러한 고민중에 여자친구를 통해 추천을 받은 강의가 있었으니.. 그건 바로!! 따블대디 스터디였습니다. 

찾아보니 커리큘럼이 초급부터 중급까지 푸짐하게 있는 것을 보고 강의 열리자마자 바로 연락을 드렸습니다.

특히, 제가 필요한 모든 니즈들을 충족시키기 위해 너무 좋은 조건들이었습니다. 

인스타 그램보고 바로 연락을 드렸는데 .. 다행히도 합격이었습니다. 

총 5주간이 시작이 되었으며 저는 아쉽게도 마지막까지 완주를 못해서 너무나도 후회되지만!!!.. 

제가 배웠던 스터디와 장점에 대해서 리뷰를 남겨볼려고 합니다. 

1. 매일매일 루틴과제 

과제는 매일매일 독서와 주식의 체크리스트, 그리고 뉴스인증합니다. 

저는 뉴스를 잘 안보는데 이 스터디를 통해서 매일매일 확인하고 퇴근후에는 주식을 체크할 수 있어서 너무나도 좋았습니다. 

습관처럼 매일 하게 되니 트렌드도 알고 너무 재미있더라고요 

2. 톡강의

강의 같은 경우는 톡강의를 통해서 진행이 되어지다보니 언제 어디서나 들을 수 있어서 너무 편리했습니다. (내용이 궁금하신 분들은 꼭 신청해서 강의를 해보시길) 

3.  데일리 과제 

이렇게 끝난 강의는 네이버나 개인 블로그에 올려서 과제를 업로드 함으로써 복습 + 실력향상도 보장이 됩니다. 

제가 적극 추천하는 건 과제인데요 시간은 소비가 되지만 배우고 나면 재미있고 차트 보는 것과 주식을 보는 시야가 확 바뀌게 되더라고요. (과제 진짜 실력향상 제대로 됩니다) 

늦게라도 복습을 하면서 계속해서 달려보려고 합니다. 

5주간 스터디를 통해 변화한 나의 모습 (장점)

이렇게 꽉 찬 강의와 커리큘럼을 통해서 제가 변화된 저의 모습에 대해서 말해보겠습니다. 

1.  회사에 대한 가치 판단이 달라짐

이전에서는 친구를 통해서 유튜브를 통해서 이 주식이 뜬다!! 하면 넣었지만 지금은 이 회사의 수익은 주력이 무엇인지, 매출은 어떻게 나오는지 그리고 경쟁사는 무엇이든지 등등 생각을 하면서 투자의 결정을 내릴 수 있게 되었다.

특히 강의에서 제공해 주신 표를 통해서 가치 판단을 할 수 있으니 더 선택에 대해서 더욱 신뢰를 할수 있다!!

할수 있었음

2. 차트를 보았을 때 피해야 될 지점에 대해서 판단 가능

이전에서는 투자의 그래프는 보지도 않았고 그냥 5년 치 그래프를 보면서 떨어지니까 사야지 하고 추가매수를 했던 경험들이 있다. 

하지만 강의를 하고 난 후에 반등점인지 크로스하여서 오히려 내려가는 지점인지 판단할 수 있는 시야를 판단할수 있었다. 

(노란색처럼 올라가는지 내려가는지 대략적인 판단이 가능!!) 

3. ETF / 배당주  투자에 대해서 배울 수 있다.

ETF에 대해서 종류도 알 수 있으며 배당주는 어떤 것이 있는지 전체적으로 많은 것을 배울 수 있었습니다. 

저는 확실히 성격상 ETF에 더 많이 투자하게 되더라고요 ㅎㅎ 

나에게 주는 칭찬 + 앞으로 나의 계획

저는 사실은 칭찬을 받기에는 많이 부족했습니다. 

5주 차까지 다 못 달렸거든요..  하지만 3주 동안 열심히 달렸는데 너무나도 많은 것을 배우고 시야가 바뀌는 시간을 가졌습니다. 

심지어 다시 2기를 들을까 생각도 많이 듭니다!! 너무 값진 강의와 내용들과 자료를 제공해 주어서 가성비가 너무 좋은 강의였습니다. 

한 가지의 칭찬을 스스로에게 한다면 그래도 매일매일 루틴이 잡혀서 주기적인 주식과 해외 증시와 뉴스를 보는 게 습관화과 된 것이 아니지 않을까 싶습니다. 

앞으로의 계획은 다음과 같습니다!!

1. 아직 다 못 끝낸 강의를 개인적으로라도 다 끝내기

2. 본격적인 ETF/ 배당주에 주식을 투자하고 합니다. 

3. 매월 최소 100만 원이라도 꼭꼭 벌자!!

4. 매일 루틴(뉴스, 증시)은 항상 확인하고 다니자 

강의를 들으실까 고민하시는 분들은 꼭 신청하고 실력 향상과 투자의 즐거움을 배우길 바랍니다. 

이번 기회에 Binay search Tree에 대해서 공부를 해보고자 한다. 

Leet code에 있는 내용을 참고하여 만든것이니 언제든지 모르는건 리뷰를 남기면 좋겠다.

BST에서는 탐색하는 여러 방법이 있으며 그중에서 3개의 방법에 대해서 알아보도록 하겠다. 

첫번째 방법은 다음과 같다. 

pre-order traversal (레벨 순회)

root의 첫번째 부터 list에 들어가는 형태를 말한다. 그리고 가장 우축에 있는 subtree에 순회를 하면서 같을 채워넣는 것이다. 

즉 node가 보일때마다 넣는다고 보면됨 

In-order traversal (중위 순회)

가장 왼쪽의 node부터 list에 들어가는 형태로 진행이 되어진다. 

이는 가장 child tree에 갔다가 다시 parent tree로 돌아갈때 node를 더한다고 이해하면 쉽다. 

post-order traversal (후위 순위) 

뒤에서부터 채워지는 형태로 보는 바와 같이 가장 뒤에 있는 node들로 채워진다. 

이는 수식으로 많이 사용이 되어진다. 

그리고 이 방법을 알고 있느면 stack의 효과에 용이하다. 

위의 방법들은 graph에서 다음과 같은 방법으로 사용이 되어진다. 

마지막으로 level-order traversal 방법이 있다. 

이 방법은 Breadth-First Search로써 level별로 값이 더하여 지는 방법을 의미한다. 

이 방법의 경우에서는 queue의 형태를 많이 따르고 있으니 참고해보길 바란다. 

Introudction 

이전에서는 Unsupervised Domain Adaptation(UDA)의 방법이 많이 제안이 되었습니다. UDA의 3개의 paradigms으로 접근을 하는데 첫번째의 경우에서는 statistical moments를 다른 feature distribution을 가깝게 하는 방법과, 두번째의 경우에서는 adversarial training을 통해서 추가적인 discriminator를 만드는 방법 그리고 마지막으로는 다양한 regularization을 target network에 넣어 self-training또는 entropy를 조절 하는 방법이 있습니다.

위의 방법을 motivation으로 이번 paper에서는 Source free domain Adaptation(SFDA)에 적용을 하였습니다. 이전의 SFDA의 일반적인 방법으로는 pseudo label을 만들어서 feature strcuture이나 모델의 예측을 내어서 target domain에 대해서 나타내었지만 이는 decision bounday에 noisy가 많이 있는 단점이 있습니다. 

이를 통해 저자는 training에 label refinery할수 있는 Proxy based mixup(ProxyMixup)을 제안하였습니다. 이 방법의 경우 간단하게 source domain 과 traget domain에서 보지 못하였던 (unseen)데이터의 gap을 줄여주기 위해서 첫번째로 target domain에서 source image와 유사한 이미지를 뽑아내서어 proxy source domain에 만들어냅니다. 구체적으로 source classifier에 weight로 프로타입을 구하며 이를 중심으로 가까운 거리에 있는 image를 proxy source domain으로 구성하게 되어지게 되어집니다. 

Pseudo label의 신뢰도를 올리기 위해서 frequency-weighted aggregation pseudo-labeling strategy(FA)를 제안을 하였으며 이는 sharpening, re-weighted, aggreation을 사용하여 Pseudo label을 만든 방법이며 ambiguous한 것에 대해서는 sharen하고 reweight를 하는 방식으로 변경하고 aggregation를 적용하여 unlabel에 대해서 label을 적용하게 되어진다 

Method

Proxy Source Domain Construction by Prototypes

핵심 방법의 경우 SHOT의 paper와 모델과 유사하게 되어지며 source domain의 image는 접근 할 수 없음으로 source model의 weight를 바탕으로 prototype들을 뽑아내어지며 이를 바탕으로 proxy-domain을 만들어낸다. prototype과 마찬가지로 source classifier를 바탕으로 나온 target domain의 sample들도 함께 새로운 proxy-domain에 포함이 되어진다.

이떄 다른 점은 각 prototype과 가장 distance가 가까운 N개의 sample을 뽑아내고 class마다 똑같은 수의 sample를 찾아낸다. 그리고 같은 수의 sample맏 CE를 적용한다. 

Proxy Source Domain Construction by Prototypes (FA)

Pseudo labeling를 적용했을 경우에서는 noisy가 많으며 특히나 unsupervised에서는 domain에 대한 dsitribution을 모르기 때문에 class가 imbalance하게 다른 class로 예측이 되어지는 경우도 많다. 이를 완화하기 위해서 저자는 새로운 pesudo label refinery strategy를 제안하였다.

이 전략중 하나는 soft Pesudo label를 사용하여서 접근을 하였으며 각 sample주위의 예측값의 평균을 하여 label를 refine을 한다. 이렇게 뽑은 데이터를 바탕으로 sharping을 하여 probability의 비중을 키우게 되어집니다.  

Domain Alignment by Mixup Training

위의 proxy domain과 target domain에서 나온 sample들을 domain을 mixup을 하게 되어진다. 

이때 proxy domain과 target domain을 과 mixup을 하였을때 inter domain이라고 부르며 target domain과 target domain간의 mixup을 하는 건 intra domain이라고 부른다. 

Expermient

Office-home에 대한 결과는 다음과 같다. 

office-31의 경우도 다음과 같다. 

또한 기존의 pesudo label과의 차이를 비교를 하였으며 aggreation을 사용하고 난 전후의 성능 변화도 비교하였다.

Conclusion

이전의 방법과 비교하여 단순한 방법으로 적용을 하였으며 다른 domain으로 하여 mixup을 하였다는 novelty가 있음.

Introduction 

Transformer의 발전으로 인해서 NLP에서는 foundation modal 이 많아지고 있다. 

특히나 최근 Large Language Model(LLM)처럼 좋은 성능을 도출하는 모델이 많다. 

이렇게 고도화되어진 모델들을 downstream task로 하여 문제를 풀어내는데 특히나 vision에서도 많이 사용된다. 

대표적으로 downstream을 하기 위해서는 fine tuning을 사용하게 되어지는데 이때 문제가 발생이 되어진다. 

transformer를 사용하여 만든 VIT의 경우 Huge모델은 632만개의 파라미터가 사용하여 full fine tuning할때에서는 cost가 크게 발생한다는 것이다. 

저자는 이러한 문제를 위해서 효율적이고 효과적으로 downstream task를 trasnformer에 fine tunig 하는 방법에 대해서 방법을 제안한다. 

Related work

이전에 제안되었던 fine tuning의 방법에 대해서는 어떠한 방법들이 있는가 살펴보도록 하겠다. 

첨부되었던 위의 그림에서 보는것과 같이 (a)에 존재하는 이전의 tuning의 방법의 경우에서는 classifier head나 bias term에 subset만 학습하는 방법이 많이 사용되었다. 또는 adapter라는 영역 또는 추가적인 head를 넣어서 tuning을 하였는데 이러한 벙법은 under-perform 즉 성능이 기존의 방법보다 좋게 되어지진 않았다. 

이에 저자는 그림(b)에 보이는 방법처럼 transformer에 input부분을 수정하여 새로운 접근법을 제안을 하였다. 이 제안한 방법의 이름은 Visual Prompt Tuning(VPT)라고 불린다. 이 방법은 그림에서 적은 양의 learnable parameter만 사용하여 학습을 하고 transformer backbone의 경우에서는 학습할때 freeze를 하게 되어진다. 그리고 마지막 head에 부분에서는 learnable하게 사용하게 되어진다. 

이렇게 단순하게 접근을 하였을때 결과는 어떻게 되어질까? 저자는 24번의 recognition(classificaiton) task를 다른 도메인에서 실험을 하였으며 full tuning의 경우 20case에서 적용하여 비교분석을 하였다. 저자가 제안한 방법의 경우에서는 단 1%의 parameter만 학습이 되어졌으며 기존의 fine tuning의 방법에 비해 parmeter은 적고 성능의 차이는 적게 나타나는 것을 볼 수 있다.

그림(a)에서 보면 Related work로써 NLP에서 transfer learning을 하기 위해서 대푭적인 2가지의 방법이 기존에 존재하였다.

하나는 Adapters라는 방법이고 하나는 BitFit이라는 방법이다. 

Adaptaters라는 방법은 transformer layer안에 가벼운 modules들을 넣어서 학습하는 방식으로 module안에서는 nonlinear activation function과 linear up projection이 함께 들어있어 tuning을 하게 되어진다. 

Bitfit의 경우에서는 LLM tuning의 효과적인 technique들이 정리되어있다. 

계속해서 realted work를 보면 제목도 그렇고 prompting 이라는 표현이 자주 나온다. 이 표현은 한국말로 지시라는 단어표현인데 이 방법을 LLM에 적용하면 pretrained된 LLM에 task에 이해할수 있도록 Input text를 잘 넣어주는 역할이라고 보면 된다. 이에 최근에는 LLM에서 GPT-3같이 generalization이 잘된 model을 downstream-task에 few-shot, zero-shot transfer learning을 하는 방법이 있다. 최근에는 Prompting text를 잘 만들어주는 방법으로 task-specific하게 contious vector를 넣어주며 fine-tuing을 하는 방법이 있으며 이를 Prompt Tuning이라고 한다. 

이렇듯 prompt tuning의 장점은 적은 paramter로 optimize를 시키는 방법인데 vision-language model에서도 적용하고 있지만 vision과 language의 domain의 차이가 있어 연구가 많이 되어지고 있으며 이번 논문에서는 vision encoder에 prompt tuning을 적용하여 recognition task를 해결을 제안하는 방법이다. 

Method

Vision Transformer(ViT)

본격적으로 Visual-Prompt Tuning(VPT)에 기존이 되어지는 vision transformer(ViT) 방법에 대해서 보도록 하겠다.

기존의 ViT의 모델의 경우 image를 잘라서 embedding에 넣어서 recognition을 적용하여 진행을 하게 되어지며 

저자가 사용하였던 방법은 deep, shallow한 tuning의 방법을 제안하였다. 

VIT의 경우 N개의 layer로 되어있으며 patch로 잘라진 이미지($I$)와 positional encdoing이 들어가기 때문에 아래의 식과 같이 나온다 . $$e_o^j = Embed(I_j)$$

이렇게 patch embedding을 모으면 $E_i = \{ e_i^j \in \mathbb{R}^d | j \in \mathbb{N}, 1 \le j \le m\} $로 되어지게 되어지며  이때 i의 의미는 ViT의 i 번째 layer가 되어진다. 최종적으로 ViT의 모델을 수식화를 하게 되어지면 아래의 수식과 같이 되어진다. $$[x_i, E_i ] = L_i ([X_{i-1}, E_{i-1} ]), y = Head(x_N)$$

이러한 ViT의 구조는 Multihead Self-Attention (MSA)와 LayerNorm과 함꼐 Feed-Forward Network(FFN)로 구성이 되어있다. 

Visal-Prompt Tuning(VPT)

VPT-Shallow의 방법을 먼저 살펴보자. 이 방법의 경우 첫번째 Transformer layer($L_1$)에 Prompt($p$)를 함께 넣어서 학습을 진행하게 되어지는데 이수식은 아래와 같다. 

$$[x_1,Z_1 E_1] = L_1 ([X_{0},P, E_{0} ]), y=Head(X_N)$$

위의 수식과 유사한데 prompt만 넣어주게 되어지며 그로인해서 Z라는 embedding vector도 함께 나온다. 최종적으로 나온 feature를 head의 영역만 학습을 시키게 되어진다. 

VPT-Deep의 경우는 shallow랑 비슷하지만 중간에 Z의 embedding의 vector은 함께 학습이 되어지는 형태로 아래와 같은 수식으로 되어진다. 

$$[x_i,_, E_i] = L_i ([X_{i-1},P_{i-1}, E_{i-1} ]), y=Head(X_N)$$

Experiments

VPT의 경우 Transformer bacbone으로 되어있어서 downstream task로 사용이 될수 있다. 실험에서는 이러한 backbone의 부분을 변경을 하면서 실험을 하게 되어진다. 

총 4가지의 경우로 진행을 하였으면 다음과 같다. 

1. FULL : 모든 backbone과 classificaiton head의 파라미터를 업데이트함. 

2. Classification head : Classification에서 Linear layer혹은 k-layer의 paramter의 부분만 Update를 진행, Mlp-k를 추가함.

3. Backbone :'Side' network의 부분만 train을 시킴, Bias term만 시킴(distribution의 부분만 shift개념), Adapter처럼 Residual connection이 되어있는 부분만 update 

이러한 down stream task는 FGVC의 dataset에 넣어서 평가를 진행하였음.

적은 수의 파라미터만 가지고도 충분히 높은 성능이 나옴..

이를 통해서 결과는 다음과 같다. 

1. VPT-Deep의 경우는 Full fine-tuning보다 성능적인 면이나 파라미터의 수적인 부분에서도 향상이 있음. 

2. VPT-Deep의 파라미터들이 tuning에 대해서 모든 task에서 눈에 띄는 향상이 있음. 

3. VPT-shallow, VPT-Deep과의 차이에서 shallow의 경우 multi-task, fine-tuning에 좀더 paramter가 save가 많이 되어진다. 

이외에도 확실하게 많은 ablation을 평가를 하였는데 다음과 같다. 

tuning을 하였을때 Paramter를 prepend할껀지 concat할껀지 pixel로 만들껀지 많은 실험을 하였지만 

기존의 prepend형식으로 하는것이 좋았다. 

pixel로 prompt를 넣는 형식도 마찬가지로 prepend가 더 좋았으며 concat의 경우는 성능이 떨어짐을 볼 수 있다. 

이외에도 head의 부분에 대한 실험도 진행하였으며 head의 위치에 따른 성능의 차이가 나는것을 볼 수 있으며 제일 좋은 방법의 경우 Classification head에 넣는경우 눈에 띄는 성능이 나왔다. 

이외에도 다른 SEgmentation task에 대해서 prompt 를하여 fine tuning을 한결과 기존의 방법보다 잘나왔다. 

마찬가지로 Self-supervised learning도 마찬지로 학습되어지는 파라미터에 비해서 높은성능이 나옴을 볼 수 있다. 

Conclustion 

이 논문에 대한 더욱 자세한 설명은 링크에서 보는 것과 같이 읽어보면된다. 

최근의 놀라운 사실은 대부분의 vision이 이제는 prompt나 fine-tuning으로 가고 있다는 것이다. 결국 engineering처럼 모델을 fine-tuning을 하는것이 주된 업무가 되어지지 않을까싶다. 

Introduction 

저의 경우에서는 DDP를 구성하고 코드 작업을 하는 경우가 많다. 그렇다 보면 torch에서 DDP로 구성하는것이 귀찮기도 하고 생각보다 시간이 걸리는데 

이러한 노고의 시간을 줄여주기 위한 유용한 library가 있어서 공유하고자 한다. 

https://huggingface.co/docs/accelerate/index

홈페이지에 들어가보면 보는 것과 같이 Pytorch code의 distributed configuration을 4개의 라인으로 줄여서 효과적으로 사용하게 되는 방법을 제공해준다고 한다. 

홈페이지에서 제공해주는 코드지만 아래의 코드에 보는바와 같이 4줄이면 DDP setting이 끝나는 것을 볼 수 있다.

+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for batch in training_dataloader:
      optimizer.zero_grad()
      inputs, targets = batch
      inputs = inputs.to(device)
      targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
+     accelerator.backward(loss)
      optimizer.step()
      scheduler.step()

위와 같이 코드를 넣어지게 되어지만 torch_xla, torch.distributed가 build가 되어진다. 

tmi) 최근에서는 fully sharded data parallelism도 되어지니 유용하게 사용하고 있다. 

코드 실행은 아래와 같이 python파일에 accelerate launch만 넣어주면 된다. 

accelerate launch {my_script.py}

그러면 아주 설치과정부터 기본 실행까지 보자.

 Installation 

설치는 Python3.8이상부터는 되어지는 환경이고 pip 으로 설치할 경우 아래와 같이 되어진다. 

pip install accelerate

conda의 경우도 아래와 코드와 같이 되어지며 source github에서 설치할려면 다음과 같다. 

conda install -c conda-forge accelerate
pip install git+https://github.com/huggingface/accelerate

그리고 acclerate에 기본 default로 설정되어지는 값들이 있는데 이 값들의 수정함으로써 DDP나 process의 설정이나 config에 대해서 설정할수 있다. 

accelerate env

- `Accelerate` version: 0.11.0.dev0
- Platform: Linux-5.10.0-15-cloud-amd64-x86_64-with-debian-11.3
- Python version: 3.7.12
- Numpy version: 1.19.5
- PyTorch version (GPU?): 1.12.0+cu102 (True)
- `Accelerate` default config:
        - compute_environment: LOCAL_MACHINE
        - distributed_type: MULTI_GPU
        - mixed_precision: no
        - use_cpu: False
        - num_processes: 2
        - machine_rank: 0
        - num_machines: 1
        - main_process_ip: None
        - main_process_port: None
        - main_training_function: main
        - deepspeed_config: {}
        - fsdp_config: {}

Start

설치가 끝났다면 어떻게 사용하는지 다시 한번 살쳐보자. 

1. 첫번째로는 아래와 같이 accelerate를 불러온다. 

이때 Accelerator의 내부에서는 많은 변수들을 받을수 있는데 scipts안에서 setting이 가능하기때문에 이 내용에 대해서는 추구에 살펴보기도 하자.

참고로 GPU의 갯수에 따라서 multi GPU인지 single GPU인지 인식이 되어저 사동으로 환경을 setting해주는 많이 건들어질것 없을것이다. 

from accelerate import Accelerator 
accelerator = Accelerator()

2. 두번째로 중요한건 우리가 tensor에 선언헀던 to(device), cuda()부분은 지워야 한다. 

왜냐하면 accelerator로 선언되어진 객체로 multi gpu에 따라서 device를 자동으로 할당되어주기 때문에 to(accelerator.device)로 변경해줘야 한다. 

3. training에 사용되어지는 객체들을 prepare() 라는 곳에 넣어준다. (아래코드와 같다. )

아래 코드오 Parellel하게 사용되어지는 경우가 필요하면 prepare에 넣으면 되며 

model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
    model, optimizer, train_dataloader, lr_scheduler
)

4. loss.backward()의 경우도 DDP로 되어지는 경우도 있음으로 accelerator.backward(loss)로 되어져야 한다. 

Config 

accelerate를 사용하게 되어질때 이전의 multi GPU나 mixed precision이나 선택해야될때가 있는데  

이것에 따른 config를 설정해주기 위해서 accelerate config라는 명령어가 있다. 

아래와 같이 입력하면 각종 setting들을 쉽게 만들어준다. 

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------In which compute environment are you running?
This machine                                                                                                                                                                                                                
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Which type of machine are you using?                                                                                                                                                                                        
multi-GPU                                                                                                                                                                                                                   
How many different machines will you use (use more than 1 for multi-node training)? [1]: 2                                                                                                                                  
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------What is the rank of this machine?                                                                                                                                                                                           
0                                                                                                                                                                                                                           
What is the IP address of the machine that will host the main process? ---                                                                                                                                                
What is the port you will use to communicate with the main process? ---                                                                                                                                                   
Are all the machines on the same local network? Answer `no` if nodes are on the cloud and/or on different network hosts [YES/no]: ㅜno
What rendezvous backend will you use? ('static', 'c10d', ...): static
Do you wish to optimize your script with torch dynamo?[yes/NO]:no
Do you want to use DeepSpeed? [yes/NO]: no
Do you want to use FullyShardedDataParallel? [yes/NO]: no
Do you want to use Megatron-LM ? [yes/NO]: no
How many GPU(s) should be used for distributed training? [1]:2
What GPU(s) (by id) should be used for training on this machine as a comma-seperated list? [all]:1,2
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Do you wish to use FP16 or BF16 (mixed precision)?
fp16                                                                                                                                                                                                                        
accelerate configuration saved at ~/.cache/huggingface/accelerate/default_config.yaml

위의 같은 명령어로 만들어주면 yaml파일이 만들어지며 

이렇게 설정된 config는 ~/.cache/huggingface/accelerate/default_config.yaml 에 있음으로 확인설정을 할수 있다. 

compute_environment: LOCAL_MACHINE
deepspeed_config: {}
distributed_type: MULTI_GPU
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
gpu_ids: 1,2
machine_rank: 0
main_process_ip: 
main_process_port: 
main_training_function: main
megatron_lm_config: {}
mixed_precision: fp16
num_machines: 2
num_processes: 2
rdzv_backend: static
same_network: false
use_cpu: false

이러한 yaml을 변경해서 사용해도 되며 아래와 같이 config를 test하여 정상적으로 돌아가는지 확인 할 수도 있다.

accelerate test --config_file path_to_config.yaml

최종적인 코드 실행은 아래와 같이 실행이 되어지면 multi-gpu에 대해서 자동으로 할당되어서 parellel하게 실행이 되어진다. 

accelerate launch path_to_script.py --args_for_the_script

이렇게 실행된 코드 안에서 유용한 methode들도 많은데 이것에 대해서 간략하게 정리를 해보면 다음과 같다. 

• if accelerator.is_local_main_process : 서버당 하나의 GPU만 동작 (서버 : GPU장비가 모인 곳)
• if accelerator.is_main_process : 머신당 하나의 GPU에서만 동작 (머신 : GPU들)
• accelerator.wait_for_everyone() : Multi GPU에 있는 모든 값을 모으기 위해서 다른 GPU에 있는 동작을 기다리는 명령어. 
• accelerator.save_model(model, save_directory) : 기다린 GPU들을 model을 저장함(단 저장하기 전에 모델의 크기로 인해서 unwrap을 해야됨)
• unwrapped_model = accelerator.unwrap_model(model) : 각 GPU에 있는 큰 모델들을 하나의 모델로 변경 (torch 저장을 추천하는 방법으로 unwarp을 해주어서 model을 뱉어낸후에 torch.save로 해서 저장함)

ETC

우리가 흔히 deep learning을 사용하다보면 kaggle이나, notebook에서 사용하는 경우가 많은데 

이와 같은 경우에서는 학습하는 function을 notebook_launcher에 넣고 실행하면된다. 

코드는 아래와 같다. 

from accelerate import notebook_launcher

notebook_launcher(training_function)

마치며

이번시간에서는 이렇게 accelerator에 유용한 기능들과 실행 방법에 대해서 알아보았다. 

다음번에는 좀더 다양한 기능들에 대해서 알아보겠다.