beomseok_Oh

Vmware fusion for mac 다운로드 하는 법

beomseok99 — Fri, 30 Jan 2026 15:41:14 +0900

※※※※※※ vmware fusion for mac 다운로드 할 때, 회원 가입 후 portal에서

이 괴랄한 눌리지도 않는 체크 박스때문에 미칠 뻔 했습니다.. 이거 못누르면 다운로드도 안되더군요...

해결법 바로 들어갑니다

1. Terms and Conditions 링크 클릭

2. 현재 탭에서 이동된다면 뒤로가기 또는 새 탭에서 열린다면 원래 다운로드 페이지로 (체크박스가 있는 위 사진에 보이는 페이지)로 돌아오기

이렇게 하면 체크박스가 갑자기 클릭이 되고 설치가 가능해집니다...

체크하는 동시에 '동의'가 되는게 아니라 저 링크를 꼭 눌러야지만 '동의'라고 확인해주는 알고리즘인가봅니다

[백준/파이썬] 16234번 인구 이동

beomseok99 — Tue, 20 Jan 2026 22:47:39 +0900

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

bfs를 여러번 돌려서 구역을 찾는 문제다

이렇게 반복을 많이 해도 되나..? 싶은 문제들은 보통 입력의 크기가 20,50,100 이정도 수준이므로 걱정하지 않아도 된다.

다만 좀 까다로운 점은 구역을 나중에 계산해줄 때이다

그냥 배열 하나 더 만들어서 연합(구역)별 값을 따로 저장해주고, country 리스트를 한번 더 돌면서 값을 일일이 넣어주었다.

더 좋은 방법 있으면 댓글로 공유 부탁드려요!

from collections import deque

N, L, R = map(int, input().split())
country = []
for _ in range(N):
    arr = list(map(int,input().split()))
    country.append(arr)

dx = [1,0,-1,0]
dy = [0,1,0,-1]

def bfs(block,x,y):
    corp,cnt = 0,0
    dq = deque()
    dq.append((x,y))
    cnt += 1
    corp += country[x][y]
    
    while dq:
        sx, sy = dq.popleft()
        visited[sx][sy]=block

        for d in range(4):
            nx = sx + dx[d]
            ny = sy + dy[d]

            if nx >= 0 and ny >=0 and nx < N and ny < N and visited[nx][ny]==0:
                if L <= abs(country[nx][ny] - country[sx][sy]) <= R:
                    visited[nx][ny]=block
                    dq.append((nx,ny))
                    cnt += 1
                    corp += country[nx][ny]
    #print(corp,cnt)
    return corp//cnt
day = 0
while True:
    block = 1
    arr = [0]
    visited =[[0]*N for _ in range(N)]
    
    for i in range(N):
        for j in range(N):
            if visited[i][j]==0:
                new_value = bfs(block,i,j)
                arr.append(new_value)
                block+=1
    #print(country)
    if block == (N*N)+1 : break
    day+=1
    for i in range(N):
        for j in range(N):
            num = visited[i][j]
            country[i][j] = arr[num]
print(day)

[백준/파이썬] 13549번 도시 분할 계획

beomseok99 — Tue, 20 Jan 2026 21:08:25 +0900

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

최소 신장 트리를 구할 때 유니온-파인드(=크루스칼 알고리즘 구현) 방법을 이용해 구하는 문제이다.
언듯보면 까다롭지만, MST를 구한 후 "값이 가장 큰 간선을 하나 제거"하면 "최소 스패닝 트리 2개"가 생긴다는 발상이 키포인트이다

또한, 가장 가중치가 가장 작은 간선부터 보면서 트리를 구성하기 때문에 자연스레 MST가 생성된다 (=크루스칼,Kruskal)

N,M = map(int,input().split())
graph = []

for _ in range(M):
    A,B,C = map(int, input().split())
    graph.append([A,B,C])
graph.sort(key = lambda x:x[2])
#print(graph)
parent = [0] * (N+1)
for i in range(1, N + 1):
    parent[i] = i

def find_parent(x):
    if parent[x] != x:
        parent[x] = find_parent(parent[x])
    return parent[x]
        
def union(a, b):
    a = find_parent(a)
    b = find_parent(b)
    if a < b:
        parent[b] = a
    else:
        parent[a] = b
result, max_cost = 0,0
for edge in graph:
    start, end, cost = edge
    if find_parent(start) != find_parent(end): # 다른 그룹이면
        union(start, end)
        result += cost
        max_cost = max(cost, max_cost)

print(result - max_cost)

[독서] 괴테는 모든 것을 말했다

beomseok99 — Thu, 8 Jan 2026 01:51:27 +0900

https://product.kyobobook.co.kr/detail/S000218438100?utm_source=google&utm_medium=cpc&utm_campaign=googleSearch&gt_network=g&gt_keyword=&gt_target_id=dsa-661398393740&gt_campaign_id=9979905549&gt_adgroup_id=132556570510&gad_source=1

괴테는 모든 것을 말했다 | 스즈키 유이 - 교보문고

괴테는 모든 것을 말했다 | 차세대 일본 문학을 가장 먼저 마주할 기회 21세기 새로운 고전이 탄생하다저명한 괴테 연구가 도이치는 홍차 티백에서 출처 불명의 괴테 명언을 발견한다. 사랑은 모

product.kyobobook.co.kr

오랜만에,

대학원 졸업 겸 새해를 맞아 독서를 시작했다.

마음 내키는 대로 손을 뻗은 나머지, 무려 5권이나 한 번에 사버렸다.(나에겐 '무려'다)

그 중 가장 신선하고 화두인 이 책에 먼저 눈길이 가게 되어 읽어버렸고, 짧은 글을 쓰고자 한다.

(*아래에서부터는 스포가 있을 수 있습니다)

줄거리는 스포일러가 될 수 있기 때문에 정말 짧은 한 문장으로 얘기하자면 다음과 같다.

괴테에 대해 저명한 교수가 티백이 달린 차를 마시던 중, 자신도 모를 괴테의 명언을 발견하게 되고 이를 찾아가는 과정에서 메세지를 전달하는 내용이다.

사실 굉장히 어렵다. 고전 문학과 각종 명언, 그리고 관련 분야 유명인까지, 책이 끝날 때 까지 줄줄이 나온다.

각주가 없었더라면 절반도 이해하지 못했을 것이다. 그렇지만 지레 겁먹고 주저할 필요는 없을 것 같다.

문학 또는 철학을 전공한 이들이 아니라면, 어떤 이가 와도 마찬가지일 것이다.

이 책이 주는 메세지를 최대한 '나'의 입장에서 받아들이기 위해 노력했다.

모든 말은 이 세상 어딘가에 존재한다. 그렇지만 그것은 내가 아닌, 어쩌면 나와 비슷할 수 있지만, 다른 누군가에 의해 내뱉어지거나 글로써 적혀진 말들이다. 세상 많은 이들이 명언을 보고 느끼고 갈망하는 것은 사실 인간의 삶이 고대에서부터 크게 다르지 않기 때문이다. 태어나고, 성장하고, 괴로워하고, 사랑하고, 눈을 감기까지의 경험은 다르지만 생각과 느낌이 비슷할 것이고

그래서 예전에 이 지구에 살았던 누군가가 했던 말들이 끊임없이 기록되고 전수되며 오늘날까지도 잘 이용당하고 있다고 생각한다.

하지만, 그렇다고 해서 그게 '나'가 될 수 없다.

사랑에 대한 괴테의 명언을 찾는 주인공, 작품 초반 주인공의 가정에 대한 묘사가 나온다. 각자 다른 생활과 취미, 묘하게 깔려있는 칙칙함과 지루함.

그러나 주인공에겐 그런 것들은 당연하고 그저 주어진 일과 찾지못한, 괴테를 누구보다 잘 알면서 생전 처음 들어보는 괴테의 말에 대해 찾기 위해 노력할 뿐이다. (물론 중간중간 대담한 실수를 저지르기도 하지만)

그것을 찾기 위한 과정은 사랑의 회복 과정처럼 보여진다. 동료의 제자와의 대화, 인연들에게 보내는 메일, 처가댁 방문, 딸과의 대화(알고보니 딸의 남자친구가 동료의 제자였다던가), 오래전 친구에게 받은 메일 답장, 해당 문구가 적힌 편지의 발견, 그 속에서 되찾은 애틋함 등 떠오르는 것만 정리하면 다음과 같다.

결국 그 명언이 실제 괴테가 한 말인지는 중요하지 않게 된다. 위에서 줄줄이 나열한 사랑의 회복 과정이 결국 알 수 없는 괴테의 명언 그 자체였기 때문이다. 그 '말'이 '힘'을 가지게 된 것이다.

세상에는 많은 말이 존재한다. 어쩌면 모든 말이 존재할 수도 있다.

나에게 그 말들은 진짜인가? 무슨 의미를 가질까?

그들이 내 것, 내 경험, 내 삶, 내 언어가 될 때 의미를 가진 진짜가 되며, 내 생활 속으로 들어오고, 힘을 가지게 된다.

[독서] 카이스트 명상수업을 읽고

beomseok99 — Thu, 8 Jan 2026 01:12:39 +0900

"어찌 진짜로 태어나 가짜로 살며 가짜로 죽으리라"

에드워드 영의 문구를 인용하여 이 글이 시사하는 바를 적어보았다.
정확한 문구는 글 맨 밑에 작성해놓겠다.

http://www.yes24.com/Product/Goods/106495038

카이스트 명상 수업 | 이덕주 | 위즈덤하우스 - 예스24

카이스트 학생들에게 인생의 터닝 포인트가 된 명상 수업대한민국 최고의 과학 인재들이 모여 있는 곳, 카이스트 학생들에게도 정신적 위기가 있었다. 2011년 과도한 경쟁에 내몰린 스트레스로

www.yes24.com

올해 생일을 맞아 아버지에게 책을 한권 선물 받았다

사실 양력생일은 아니지만, 우리집은 예로부터 음력생일을 챙겨왔기 때문에.. 아무튼

요즘 대학원을 이곳저곳 찾아보고 있는데, 카이스트를 꼭 가라는 무언의 압박이 아닐까 싶으면서도 마음가짐을 견고히 하라는 뜻에서 주신 듯 하여 3일만에 다 읽어버렸다!

군대에서는 삼국지 전권에 다른 책들도 10권 넘게 읽은 것 같은데.. 전역하고 나서는 바쁘다는 핑계로 거의 읽지 못하였다. 오랜만에 읽는 책인만큼 기록을 남겨두고 싶어 글을 적는다.

이 책은 카이스트의 교수님께서 쓰신 책이다.

공학 박사의 철학 서적이라니, 놀라울 따름이다.

교수님께서도 책을 쓸까 말까 고민을 많이 하셨다고 한다. 책을 쓸 당시 교수님의 마음을 떠올려보며 책을 읽는다면 한층 그의 독자들을 위하는 마음이 더욱 잘 느껴질 테다.

2011년 카이스트 학생의 안타까운 소식이 기점이 되어 학생들의 마음을 되돌아보고 일상을 재건하도록 하는 명상 수업이 이 책의 시발점이 된다.

학생들을 진심으로 아끼시는 교수님의 태도와 명상의 효과를 입증할 수많은 실험과 뇌과학 그리고 당신의 낯부끄러운 기억들까지... 이 책 한권에 모두 들어있다.

눈은 뇌와 긴밀하게 연결되어 있다고 한다. 어찌 보면 맨 앞부분이라고 할 수 있는 눈은 이미지를 받아들인다. 그 이미지는 뇌를 타고 들어가 맨 마지막 후두엽에서 처리된다.

즉, 우리가 보는 모든 것은 뇌의 맨 앞부터 맨 뒤까지 지나가며 인식된다는 것이다.

우리는 삶을 살아가며 기억을 가지고 살아간다. 그 기억은 일종의 사진이다. 사진들이 수십수만 장이 우리의 뇌 속에 저장되어 있다. 우리는 그 사진들을 바탕으로 세상을 바라본다. 우리가 보는 모든 것들은 뇌를 쭉 지나가며 인식,처리 되기 때문이다.

그렇기 때문에 우리가 보는 세상은 진짜 세상이 아니라 '가짜' 세상이다. 가지고 있는 '사진'을 기반으로 한...

그러므로 우리는 그러한 가짜들을 버리고 진짜를 내다볼 줄 알아야 한다.

그 방법이 바로, '마음빼기 명상'이다. 우리는 마음빼기 명상을 통해 진짜 세상을 바라보고, 진짜로서 살아가게 되는 것이다. 동양 철학 사상과 매우 유사한 부분이 많다.

공수래공수거, 빈손으로 왔다가 빈손으로 간다. 물론 다른 의미로 쓰인 말이지만, 이 책이 시사하는 바와 일맥상통하지 않은가?

각종 압박, 스트레스, 불안, 우울, 비교, 걱정, 고민, 근심이 우리의 마음을 갉아먹고, 우리를 가짜로 만들고 있다. '진짜'로 살아가기 위한 마음 빼기 명상이 궁금한 사람들은 꼭 한 번쯤 이 책을 읽어보길 바란다.

born originals how comes it to pass that we die copies!

원본으로 태어나 왜 복제품으로 죽느냐!

[코드트리] 삼성 2025 하반기 오전 기출 1번 택배하차

beomseok99 — Fri, 5 Dec 2025 01:59:20 +0900

https://www.codetree.ai/ko/frequent-problems/samsung-sw/problems/delivery-service/description

코딩테스트 기출 문제 설명: 택배 하차 | 코드트리

코딩테스트 기출 문제 택배 하차의 상세 설명입니다. 문제 요구사항을 정확히 파악하고 효율적인 알고리즘을 설계해보세요.

www.codetree.ai

이런 극한 시뮬레이션 문제들은 항상 한 번에 안 풀리고, 두세번 검토를 해야지 풀리네요ㅜ

이 문제에서는 크게 2가지가 어려웠습니다.

1. 박스 정보를 어떻게 저장할 것인가

2. 왼쪽, 오른쪽 빼줄 때

오히려 박스 개체를 중력 적용하는건 그리 어렵지 않았습니다..

1. 박스 정보 저장하는 법.

다른 풀이에서는 클래스나 구조체를 만들어 풀었는데, 저는 그냥 리스트에 냅다 다 때려박았습니다.

position이라는 리스트에

[a. 박스의 좌상단 b. 박스의 좌하단 c. 순위 d. 번호]

이런 식으로요 ㅋㅋ

여기서 c. 순위 때문에 고생 좀 했습니다. 리스트나 자료구조를 더 쓰지 않고 풀고싶었습니다..

박스를 뺀 후에 다시 중력을 적용할 때 바닥에 가까운 박스부터 차례로 적용해야 하기 때문에

'순위' 개념을 도입했습니다. 바닥과 가까울 수록 높은 순위를 주었습니다.

처음에는 좀 무식한 방법이라 생각했는데.. 여전히 좀 무식한 것 같습니다ㅜ

1번이 해결되면 자연스레 2번도 가능합니다.

2. 왼쪽, 오른쪽 빼주기

이건 모든 박스에 대해, 좌 또는 우 방향에 걸리는 박스가 있는지 검사해준다음 k값(번호)이 가장 작은 것 골라주면 됩니다.

박스의 좌상단, 좌하단을 구해서 저장해두었더니 여러모로 요긴하게 써먹었습니다.

다만 아쉬운건, 하차한 박스 개체는 아예 삭제하는게 나았을 듯 합니다. O(N)정도면....
그리고 코드 정리가 필요해보이네요

N,M = map(int, input().split())

# 택배번호k, 세로h, 가로w, 좌측좌표c
delivery = []
for _ in range(M):
    k,h,w,c = map(int, input().split())
    c -= 1
    delivery.append([k,h,w,c])

arr = [[0]*N for _ in range(N)]
position = [] 

def gravity(position):
    #print(position)

    order = sorted(position,key=lambda x : -x[2])
    for i in range(M):
        topleft,bottomright,s,k = order[i]
        if k != -1:
            #print(pos)
            stop = False

            new_pos = N
            for j in range(bottomright[0]+1,N): # 행을 증가 시킴
                for l in range(topleft[1], bottomright[1]+1): # 너비를 검사하면서 닿는게 있으면 stop
                    if arr[j][l] != 0:
                        new_pos = j
                        stop = True
                        break
                if stop:
                    break
            # 원래 값 삭제
            w = bottomright[1] - topleft[1] + 1
            h = bottomright[0]-topleft[0]+1
            c = topleft[1]

            for r in range(topleft[0],bottomright[0]+1): # 1,3
                arr[r][c:c+w] = [0]*w

            # 위치 기록
            for r in range(new_pos-h,new_pos): # 4-2, 4
                arr[r][c:c+w] = [k]*w

            order[i] = [(new_pos-h,c),(new_pos-1,c+w-1),s,k]
    return order

# 택배 투입
for i in range(M):
    k,h,w,c = delivery[i] # 8 2 4 1->0
    for r in range(0,h):
        arr[r][c:c+w] = [k]*w
    # 중력
    stop = False
    pos = N
    for j in range(h,N): # 행을 증가 시킴
        for l in range(c, c+w): # 너비를 검사하면서 닿는게 있으면 stop
            if arr[j][l] != 0:
                pos = j
                stop = True
                break
        if stop:
            break

    for r in range(0,h):
        arr[r][c:c+w] = [0]*w

    # 위치 기록
    for r in range(pos-h,pos):
        arr[r][c:c+w] = [k]*w

    for s in range(N):
        if pos-1 == s:
            position.append([(pos-h,c),(pos-1,c+w-1),s, k]) # s==5 바닥, s==0 꼭대기

answer = []
while True:
    clear = False
    # 택배 하차 (좌측))
    candidate = 1e+9
    for i in range(len(position)):
        topleft, bottomright, s,k = position[i]
        if k!=-1:
            ok = True
            # 이 택배가 차지하는 각 행 r에 대해,
            for r in range(topleft[0], bottomright[0]+1):
                # 왼쪽에 다른 택배가 있는지 확인
                for c in range(0, topleft[1]):
                    if arr[r][c] != 0:   # 다른 택배/장애물이 있음
                        ok = False
                        break
                if not ok:
                    break
            if ok:
                if candidate > k:
                    candidate = k
                    del_idx = i

    if candidate != 1e+9:
        answer.append(candidate)

        for i in range(N):
            for j in range(N):
                if arr[i][j] == candidate:
                    arr[i][j] = 0
        position[del_idx] = [(-1,-1),(-1,-1),-1,-1]
    else:
        clear = True   # 더 이상 뺄 수 있는 택배 없음

    # 중력 다시
    position = gravity(position)

    # 택배 하차 우측
    candidate = 1e+9

    for i in range(len(position)):
        topleft, bottomright, s,k = position[i]
        if k!=-1:
            ok = True
            # 이 택배가 차지하는 각 행 r에 대해,
            for r in range(topleft[0], bottomright[0]+1):
                # 오른쪽에 다른 택배가 있는지 확인
                for c in range(bottomright[1]+1,N):
                    if arr[r][c] != 0:   # 다른 택배/장애물이 있음
                        ok = False
                        break
                if not ok:
                    break
            if ok:
                if candidate > k:
                    candidate = k
                    del_idx = i

    if candidate != 1e+9:
        answer.append(candidate)

        for i in range(N):
            for j in range(N):
                if arr[i][j] == candidate:
                    arr[i][j] = 0
        position[del_idx] = [(-1,-1),(-1,-1),-1,-1]
    else:
        clear = True   # 더 이상 뺄 수 있는 택배 없음
    
    # 중력 다시
    position = gravity(position)

    # 종료 조건
    if clear:
        break
for ans in answer:
    print(ans)

[코드트리] 삼성 2025 하반기 오후 기출 1번 AI 로봇청소기

beomseok99 — Fri, 5 Dec 2025 01:40:49 +0900

https://www.codetree.ai/ko/frequent-problems/samsung-sw/problems/ai-robot/description

코딩테스트 기출 문제 설명: AI 로봇청소기 | 코드트리

코딩테스트 기출 문제 AI 로봇청소기의 상세 설명입니다. 문제 요구사항을 정확히 파악하고 효율적인 알고리즘을 설계해보세요.

www.codetree.ai

사실 그렇게 깔끔한 코드는 아니지만,, 기록해둘겸 작성해봅니다..

패턴이 주어지고, 이를 방향에 따라 다르게 적용하는 코드는 백준의 마법사 상어와 토네이도 문제에서 영감을 받았습니다.

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

이 문제는 'bfs', 'tie break', 'origin' 이 3가지가 키워드였다고 생각합니다.

비교할 때 tie break를 적절히 잘 활용하면 코드 몇 줄 줄일 수 있더라구요,, 근데 뭔가 썩 좋은 코드는 아닌 듯한 느낌입니다.

또한 청소할 수 있는 용량이 정해져 있고, 먼지 확산이라는 개념이 있습니다. 이것만 조심하시면 될 듯 합니다.

1. 청소 후에도 원점에 청소할 것이 남아있는 경우

2. 청소기가 있는 칸에도 (먼지가 없다면) 그곳으로 확산합니다 ㄷㄷ

from collections import deque
N,K,L = map(int, input().split())

arr = [list(map(int,input().split())) for _ in range(N)]
loc_robots = [[False] *N for _ in range(N)]
robots=deque()
for _ in range(K):
    x,y = map(int, input().split())
    robots.append([x-1,y-1])
    loc_robots[x-1][y-1] = True


# 로봇의 진행 방향 : 하우좌상
dx = [1, 0, 0, -1]
dy = [0, 1, -1, 0]

# 반시계 방향 회전
def rotate_dir(dx,dy,d):
    for _ in range(d):
        dx,dy = -dy, dx
    return dx,dy

# 위쪽 방향 기준, 청소 패턴
patterns = [
    (-1,0),
    (0,-1),
    (0,0),
    (0,1),
]

def bfs(now):
    x,y = now
    dq = deque()
    dq.append([x,y,0])
    visited = [[False]*N for _ in range(N)]
    visited[x][y] =True
    candidate = []
    #print(now)
    while dq:
        x,y,d = dq.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if 0<=nx<N and 0<=ny<N and not visited[nx][ny] and not loc_robots[nx][ny] and arr[nx][ny] >=0:
                if arr[nx][ny] == 0:
                    dq.append([nx,ny,d+1])
                elif arr[nx][ny] > 0 :
                    candidate.append([nx,ny,d+1])
                visited[nx][ny]=True
    if len(candidate) ==0:
        return [-1,-1]
    candidate.sort(key = lambda x : (x[2],x[0],x[1]))
    #print('1', candidate)
    return [candidate[0][0], candidate[0][1]]

while L:
    tmp = deque()
    answer  = 0
    while robots:
        robot = robots.popleft()

        # 제자리에 청소할 게 남았다면
        if loc_robots[robot[0]][robot[1]] and arr[robot[0]][robot[1]] > 0:
            tmp.append(robot)
        else:
            # 청소기 이동
            new_robot = bfs(robot)

            loc_robots[robot[0]][robot[1]] = False
            if new_robot == [-1, -1]:     # 못 움직이면
                new_robot = robot         # 원래 자리 그대로 유지

            tmp.append(new_robot)
            loc_robots[new_robot[0]][new_robot[1]] = True

    # 전부 이동 완료 후 청소 시작
    robots = deque(tmp)
    #print(robots)
    #print(arr)
    while tmp:
        cur_robot = tmp.popleft()
        sum_ = -1
        # 청소할 방향 정하기 (상,좌,하,우)
        for d in range(4): 
            inter_sum = 0
            for p in patterns:
                px, py = rotate_dir(p[0],p[1],d)
                nx = cur_robot[0] + px
                ny = cur_robot[1] + py
                #nx, ny = rotate_dir(nx,ny,d)

                if 0<=nx<N and 0<=ny<N and arr[nx][ny] > 0:
                    inter_sum += min(20, arr[nx][ny])
            if sum_ <= inter_sum: # 우선순위의 역순으로 방향을 탐색하니까 <= 로 처리
                sum_ = inter_sum
                dir = d
        # 방향대로 청소하기 
        #print(loc_robots)
        for p in patterns:
            px, py = rotate_dir(p[0],p[1],dir)
            nx = cur_robot[0] + px
            ny = cur_robot[1] + py
            #가운데
            if 0<=nx<N and 0<=ny<N and arr[nx][ny] > 0:
                arr[nx][ny] = max(0, arr[nx][ny]-20)

    # 먼지 축적
    for i in range(N):
        for j in range(N):
            if arr[i][j] > 0:
                arr[i][j] += 5

    #확산
    spread = [a[:] for a in arr]
    for i in range(N):
        for j in range(N):
            if arr[i][j] == 0:
                dust = 0
                for d in range(4):
                    nx = i + dx[d]
                    ny = j + dy[d]
                    if 0<=nx<N and 0<=ny<N and arr[nx][ny] > 0 :
                        dust += arr[nx][ny]
                spread[i][j] = (dust)//10
            
    #print((arr))
    arr = [s[:] for s in spread]
    for a in arr:
        for num in a:
            if num > 0:
                answer += num
    print(answer)

    # 종료조건
    L-=1
    if L == 0:
        break

[파이썬] 순열, 조합, 중복순열, 중복조합 직접 구현

beomseok99 — Wed, 3 Dec 2025 18:18:07 +0900

순열, 조합, 중복순열, 중복조합 구현

1. 순열 핵심

순서가 있기 때문에, 자기 자신보다 앞에 있는 원소도 선택 가능

rest = array[:i] + array[i+1:]

2. 중복 순열 핵심

순열의 특징을 그대로 가져가면서, i번째 원소도 중복 가능하도록 수정 == rest가 없는 것과 차이x

#rest = array[:i] + array[i+1:]
#rest를 주석처리하여 중복허용

3. 조합 핵심

순서가 없기 때문에 [1,2] [2,1] 같은 케이스 방지

rest = array[i+1:]

4. 중복 조합 핵심

조합의 특징은 그대로 가져가지만, 자기 자신을 중복 선택할 수 있게 조정

rest = array[i:]

# 조합
def combinations(array, n):
    result = []
    # n개를 다 골랐으면 빈 리스트 하나 반환 (쌓아올리기용 바닥)
    if n == 0:
        return [[]]
    
    for i in range(len(array)):
        elem = array[i]          # i번째 원소를 뽑고
        rest = array[i+1:]       # i 뒤에 있는 애들만 남김 (중복 방지의 핵심)
        # rest = array[i:]  ==> 중복조합
        
        # 남은 애들에서 n-1개 뽑는 조합들
        for c in combinations(rest, n-1):
            result.append([elem] + c)
    
    return result

# 순열
def permutations(array,n):
    result = []
    if n==0:
        return [[]]
    
    for i in range(len(array)):
        now = array[i]
        rest = array[:i] + array[i+1:] # rest를 주석처리 => 중복순열
        
        for p in permutations(rest,n-1):
            result.append([now]+p)
    return result
print(permutations([1,2,3], 2)) # [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]
print(combinations([1,2,3], 2))# [[1, 2], [1, 3],  [2, 3]]

[프로그래머스/파이썬] 디스크 컨트롤러

beomseok99 — Fri, 12 Jan 2024 01:20:06 +0900

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

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

정말 오랜만에 알고리즘 문제를 풀었다.

요즘 인생의 번아웃이 온 건지 운동이나 여행, 친구 만나기 등 말고는 손에 잡히지도 않고 그냥 빈둥대며 산다.

어제 1월 첫 랩실 세미나 갔다가 열심히 하는 다른 사람들의 모습을 보고 다시 열정의 불씨가 조금씩 지펴진 듯

나도 모르게 알고리즘에 손을 대기 시작했다.

문제풀이

1. 우선 굳이 힙을 써도, 안써도 된다

두 방법으로 모두 풀어보았는데, 시간복잡도 측면에서 힙을 사용하는 것이 훨씬 좋으니까

풀이가 막막한 경우 말고는 힙을 써보도록 하자 (리스트로만 풀 땐 예외 조건 몇 개만 잘 검사해주면 금방 풀린다)

2. jobs 들을 탐색하며 현재 작업을 시작할 수 있는 것들을 최소 힙에 담아준다.

이 때, 현재 작업을 시작할 수 있는 것들 중 작업시간이 최소인 애들을 먼저 처리해주어야 하므로 최소힙에 넣는 기준을

작업시간으로 설정해준다.

왜?? 직관적으로 설명해서, 현재 시작할 수 있는 일들 중 가장 오래 걸리는 일을 먼저 시작한다면 다른 일들은 오래 걸리는 일이 끝날 때까지 무한정 대기상태이다.

디스크에서 무한 대기라는 뜻은 그냥 크롬창 무한 로딩이라고 생각하면 편하다.

3. 2번 작업을 통해 힙에 무언가 들어왔다면 가장 최소(= 현재 처리 가능한 작업 중 작업 시간이 최소)인 노드를 꺼내와 걸린 시간, 현재 시간 등을 계산해준다.

그런 다음, i를 1 증가시켜 준다. 하나의 작업에 대해 처리가 끝났고, 우리는 job에 담긴 모든 작업들을 처리해주어야 하므로 i와 len(jobs)을 이용해준다.

i==len(jobs) 를 만족할 때 까지 돌려준다는 의미다.

4. 만약 2번 작업을 거쳐도 힙에 아무 것도 없다면, 지금 당장 시작할 수 있는 작업이 없다는 뜻이므로

1ms 기다려준다 (= now+=1)

import heapq
def solution(jobs):
    answer = 0
    now = 0
    start = -1
    heap = []
    
    i=0
    while i<len(jobs):
    #for i in range(len(jobs)):
        for job in jobs:
            if start < job[0] <= now:
                heapq.heappush(heap,[job[1],job[0]])
        if len(heap)>0:
            current = heapq.heappop(heap)
            start = now
            now += current[0]
            answer += (now - current[1])
            i+=1
        else:
            now += 1
    return answer // len(jobs)

[프로그래머스/파이썬] 징검다리

beomseok99 — Tue, 21 Nov 2023 23:06:51 +0900

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

프로그래머스

programmers.co.kr

꽤 어려운 이분 탐색 문제이다,,

우선 첫번째 의문!

이게 왜 이분탐색이지? -> 사실 이것만 해결되면 금방 풀린다.

문제의 조건을 보면 범위가 10억(?맞나 암튼)이므로 완전탐색으론 풀 수 없다.

보통 조건의 범위가 어마무시하면 이분탐색인 경우가 많다! 이건 소소한 꿀팁

여기서 중요한 것은 '도대체 뭘 탐색할 것인가?' 이다.

이 문제에서는 돌을 n개 제거했을 때의 최소 거리들 중 최대 거리를 구해야 하므로, 우선 최소 거리를 이분 탐색으로 구해보자

1. 양 끝 점 (left, right)를 설정한다.

2. mid (left + right // 2) 를 설정한다.

3. 현재 위치와 다음 돌 사이의 거리를 구한 뒤, 만약 이 거리가 mid (=최소 거리) 보다 작다면 돌을 제거한다.

왜?? 우리는 현재 mid 변수의 값을 '문제의 정답'으로 설정한 뒤 풀고 있다.

만약 mid가 13일 때 0 과 2 사이의 거리는 2이고, 이는 우리가 설정한 정답(=mid)보다 작은 값이 된다.

=> 우리가 문제의 정답이라고 설정한 것에 위배된다! 정답은 최솟값인데 최솟값보다 더 작은 값이 있게 되는 것이니까!

4. 만약 3번 조건에 합당하지 않는다면 최소 거리를 갱신해준다. (정답에 더욱 가까우니까!)

5. 만약 지워야 하는 n보다 더 많이 돌을 지웠다면 우리가 설정한 최소거리(=mid)는 틀린 답이니까 이분 탐색의 범위를 좁혀준다.

여기서 중요!

6. 딱 n만큼 돌을 지웠거나 덜 지웠다면, 최솟값들 중 최댓값을 찾아야 한다!!

그래서 일단 정답을 저장해준 뒤, left를 증가시켜 범위를 높인 다음 최솟값에서 만족하지 않고 반대 방향으로 탐색하여 최솟값들 중 최댓값을 찾아준다.

def solution(distance, rocks, n):
    answer = 0
    
    rocks.append(distance)
    rocks = sorted(rocks)
    
    left, right = 0, distance  
    
    while left <= right:
        
        mid = (left + right) // 2  
        min_distance = float('inf')  
        current = 0  
        remove_cnt = 0  
        
        for rock in rocks:
            diff = rock - current  
            if diff < mid:  
                remove_cnt += 1
            else:  
                current = rock  
                min_distance = min(min_distance, diff)  
        
        if remove_cnt > n:  
            right = mid - 1
        else:  
            answer = min_distance
            left = mid + 1

    return answer

[프로그래머스/파이썬] 단어 변환

beomseok99 — Sun, 5 Nov 2023 15:42:43 +0900

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

프로그래머스

programmers.co.kr

알파벳 한글자만 변환해서 target 단어에 도달하는 bfs문제이다.

완전탐색이 아니라 bfs 카테고리에 분류된 이유는 다음과 같다.

1. hit -> hot -> lot, dot ,,

2. lot -> log -> cog

2. dot -> dog -> cog

처럼 탐색이 진행되기 때문이다.

단어를 비교하여 오직 한 알파벳만 차이나는 경우 큐에 담아주고 bfs 탐색을 진행하면 된다.

다만 hot -> lot -> hot 처럼 이미 탐색한 단어를 다시 탐색하면 '반드시' 최소로 탐색하지 못하게 된다.

이 때 필요한 것이 '방문처리'인데 이는 파이썬의 dict 자료형을 사용하거나, 아래 코드처럼 인덱스로 접근하여 visited 배열을 이용한 방문 처리를 진행해주면 된다.

from collections import deque

def solution(begin, target, words):
    answer = 0
    length = len(begin)
    dq = deque()
    dq.append([begin,0])
    visited = [False] * len(words)
    
    while dq:
        now,times = dq.popleft()

        if now == target:
            answer = times
            break
            
        for i in range(len(words)):
            cnt = 0
            if words[i] == now : continue
            
            for j in range(length):
                if now[j] != words[i][j]:
                    cnt += 1
            if cnt == 1 and not visited[i]:
                visited[i] = True
                dq.append([words[i],times+1])
                
    return answer

[프로그래머스/파이썬] 기능개발

beomseok99 — Sun, 15 Oct 2023 23:25:26 +0900

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

프로그래머스

programmers.co.kr

스택, 큐 연습 문제이다..

사실 스택 큐 같은 경우는 파이썬에서 list로 모두 처리가능한 느낌이 없지 않아 있다

특히나 해당 문제 같은 경우 오히려 "스택이나 큐를 어디서 어떻게 활용할까?" 에 사로잡혀 복잡해질 수 있다.

문제 풀이

1. 진행 상황과 진행 속도를 이용해 각 작업이 끝나게 되는 일자를 구한다.

2. 맨 처음 작업에 pivot을 두고, pivot보다 더 오래 걸리는 작업이 있다면 여태까지 처리한 작업의 수를 정답에 넣어준다

!!!주의할 점!!!

항상 pivot을 변경해가며 자신보다 크거나 작은 수를 찾아나가는 과정엔 문제가 하나 있다.

바로 마지막 pivot에 대해서는 판단이 불가능하다는 건데, 문제 유형에 맞게 잘 처리해주면 된다.

def solution(progresses, speeds):
    answer = []
    left_days = []
    for i in range(len(speeds)): # len progresses == len speeds
        left_progress = 100 - progresses[i]
        
        if left_progress % speeds[i] != 0:
            left_day = left_progress // speeds[i] + 1
        else:
            left_day = int(left_progress / speeds[i])

        left_days.append(left_day)
    
    now = left_days[0]
    cnt = 1
    for i in range(1,len(left_days)):
        if left_days[i] > now:
            answer.append(cnt)
            cnt = 0
            now = left_days[i]
        cnt += 1
    answer.append(cnt)
    return answer

[프로그래머스/파이썬] 네트워크

beomseok99 — Thu, 12 Oct 2023 00:01:06 +0900

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

프로그래머스

programmers.co.kr

프로그래머스 Level 3 정도의 문제지만, 백준으로 치면 다른 트릭이나 복잡한 구현이 없는 기본적인 bfs/dfs 문제라서 골드 4-5정도 될 것 같다.

아무튼, 이 문제의 풀이에 대해 알아보자

문제에서 찾고자 하는 것은 '연결된 영역의 개수' 라고 할 수 있다.

n은 반드시 1 이상, 즉 주어진 그래프에는 노드 1이 반드시 존재함을 알 수 있다.

1을 기점으로, 재귀 형식의 dfs를 이용해 아직 방문하지 않은 다음 노드가 존재한다면 계속 탐색해준다.

이 때 한 번의 dfs 탐색이 종료된다는 것은 서로 연결된 하나의 영역을 모두 탐색했다는 뜻이므로 정답을 하나 증가시켜주면 된다.

그래프 입력도 친절히 이중리스트로 주어져서 그래프 상에서 dfs/bfs를 연습하기 좋은 문제인듯 하다.

def dfs(now, visited, n, computers):
    visited[now] = True
    
    for next in range(len(computers[now])):
        if computers[now][next] == 1 and now != next and visited[next]==False:
            dfs(next, visited, n, computers)
            
    return 0
            
def solution(n, computers):
    answer = 0
    visited = [False] * n
    
    for i in range(n):
        if visited[i] == False:
            dfs(i, visited, n, computers)
            answer += 1
    
    return answer

[프로그래머스/C++] 입국심사

beomseok99 — Wed, 4 Oct 2023 14:46:59 +0900

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

프로그래머스

programmers.co.kr

이분탐색 문제이다.

다만 이 문제가 좀 까다로운 점은, 도대체 뭘 탐색해야 할까? 에 대한 물음일 것이다.

최악의 경우를 따져보았을 때, 걸리는 시간이 너무 커서 탐색할 엄두도 안나겠지만, 이분탐색은 log n의 시간 복잡도를 가지므로 충분히 해결할 수 있다.

다른 이분탐색 코드와 다른 점이 있다면,

1. 개인의 심사원이 주어진 시간(mid)동안 처리할 수 있는 손님의 수를 구하는 코드

2. 예를 들어, 처리해야 할 손님이 10명이라 하자

28분에는 9명밖에 처리를 못하는데, 29분에는 11명을 처리할 수 있다면 어떻게 될까

손님은 11명이 아니라 10명뿐 이지만, 모두 처리할 수 있는 최소 시간을 구하는 것이므로 29분이 답이 될 것이다.

현재 처리한 인원의 수(=cnt)가 처리해야 할 인원의 수(=n)보다 클 경우에, 이분 탐색의 범위를 줄여주면서

동시에 현재 주어진 시간(=mid)를 정답으로 처리해준다.

이 문제의 경우, 반드시 답이 있다고 가정되어 있기 때문에 이분 탐색이 종료되는 순간에 answer에는 우리가 원하는 답이 들어 있을 것이다.

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

long long solution(int n, vector<int> times) {
    long long answer = 1e18;
    long long low = 0;
    long long high = 1e18;
    long long mid = 0;

    while(low <= high){
        mid = (low+high)/2;
        long long cnt = 0;

        for(int i=0; i<times.size(); i++){
            cnt += mid / times[i];
        }
        
        if(cnt < n) low = mid+1;
        else{
            high = mid-1;
            answer = mid;
        }
    }
    return answer;
}

[프로그래머스/파이썬] 가장 먼 노드

beomseok99 — Fri, 22 Sep 2023 13:11:01 +0900

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

프로그래머스

programmers.co.kr

그래프 문제이다

딱히 추가적으로 구현해야 할 건 없고, 양방향 그래프를 잘 입력받은 뒤

bfs로 탐색을 해주면 된다

간선에 가중치가 붙으면 다익스트라를 이용해주면 된다

from collections import deque

def solution(n, edge):
    answer = 0
    graph = [[] for _ in range(n+1)]
    visited = [False] *(n+1)
    dist = [0] * (n+1)
    q = deque()
    
    for start, end in edge:
        graph[start].append(end)
        graph[end].append(start)
    
    visited[1]=True
    dist[1] = 0
    q.append(1)

    while q:
        now = q.popleft()
        for next in graph[now]:
            cost = dist[now] + 1
            if not visited[next]:
                dist[next]=dist[now]+1
                q.append(next)
                visited[next] =True
    
    answer = dist.count(max(dist))
    return answer

[프로그래머스/파이썬] N으로 표현

beomseok99 — Wed, 20 Sep 2023 13:43:28 +0900

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

프로그래머스

programmers.co.kr

문제 유형 : dp를 베이스로 하는 완전 탐색

문제 풀이 : 숫자 n개를 이용해 만들기 위해선, 숫자 n-1개로 만든 수들을 이용해야 한다.

유의점 : N=4, number = 17 인 경우

-> 17 = (4*4) + (4/4)

이 경우는, 4를 4개를 이용해 17을 만들었는데, 4를 3개 이용한 조합에서 사칙연산한 것이 아니라,

4를 2개 이용한 숫자(= 4*4)와 4를 2개 이용한 숫자(= 4/4)를 이용해 답을 구한 것이다.

즉, 단순히 숫자 n개를 이용한 수를 만들기 위해선 n-1개로 만든 수에다가 추가로 사칙연산 하는 방법 이외에도

1개 + n-1개

2개 + n-2개

...

n-1개 + 1개

와 같은 다양한 조합들을 고려해야 한다.

def solution(N, number):
    answer = -1
    sign = 1
    breaker = False
    dp = [[] for _ in range(10)]
    
    # N 사용 횟수가 8보다 크면 -1 return
    for idx in range(1,9):
        dp[idx].append(int(str(N)*idx))
        
        if int(str(N)*idx) == number:
            answer=idx
            break
        
        if idx != 1:
            for i in range(1,idx):
                for num1 in dp[i]:
                    for num2 in dp[idx-i]:
                        dp[idx].append(num1+num2)
                        dp[idx].append(num1-num2)
                        dp[idx].append(num1*num2)
                        if num2 > 0:
                            dp[idx].append(num1//num2)
                    
                if number in dp[idx]:
                    answer = idx
                    breaker=True
                    break
                    
        if breaker: break
        
    return answer

[프로그래머스/파이썬] 카펫

beomseok99 — Sun, 17 Sep 2023 00:28:55 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42842?language=python3#

프로그래머스

programmers.co.kr

완전 탐색 문제이다.

다른 분들은 변수가 2개 (가로,세로)인 방정식 2개를 세워 연립하거나 근의 공식을 이용해 풀었다

또는

yellow는 최소 1x1 이상인, 사각형 꼴이므로 yellow 타일 개수의 약수를 이용해 식을 풀기도 하였다

내 풀이는 3중 for 문을 이용한 정말 '완전 탐색' 풀이이다.

시간 복잡도 측면에서 상당히 비효율적이므로 개선할 여지가 있다

def solution(brown, yellow):
    answer = []
    total_len = brown + yellow
    b_buf = brown
    y_buf = yellow
    for width in range(3,total_len+1):
        height = total_len // width
        
        if height > width or width*height != total_len or height < 3:
            continue
        #print(width, height)    
        
        # ex) 3행 4열
        for i in range(height): # 0 1 2
            for j in range(width): # 0 1 2 3
                if i == 0 or i==height-1:
                    brown-=1
                
                elif j==0 or j==width-1:
                    brown-=1
                
                else: yellow -= 1
                
        if brown == 0 and yellow == 0:
            answer.append(width)
            answer.append(height)
            break
            
        else:
            brown = b_buf
            yellow = y_buf
            
        
    return answer

[프로그래머스/파이썬] 소수 찾기

beomseok99 — Sat, 16 Sep 2023 01:53:39 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42839?language=python3

프로그래머스

programmers.co.kr

1) 주어진 문자열에서 순열을 1개, 2개, 3개,,, 문자열의 길이-1개 까지 뽑아준다.

2) 뽑힌 순열들을 정수로 바꿈과 동시에 set안에 삽입하여 중복을 제거해준다.

3) set안의 정수들 중 소수가 몇개인지 판별하여 개수를 세준다

from itertools import permutations as p

def is_prime(x):
    if x<2:return False

    for i in range (2, int(x**(1/2) + 1)):
    	if x % i == 0:		
        	return False
    return True				

def solution(numbers):
    answer = 0
    
    numbers = list(numbers)
    siz = len(numbers)
    p_nums = set()
    is_p_number=set()
    p_num=''
    
    for i in range(1,siz+1):
        number = list(p(numbers,i))
        
        for num in number:
            for atom in num:
                p_num+=atom
            #print(p_num)
            p_nums.add(int(p_num))
            p_num=''
        
        for x in p_nums:
            if is_prime(x):
                is_p_number.add(x)
            p_nums=set() 
    answer = len(is_p_number)
    return answer

[프로그래머스/파이썬] 큰 수 만들기

beomseok99 — Thu, 14 Sep 2023 16:49:51 +0900

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

프로그래머스

programmers.co.kr

그리디 문제이다

사실 문제 자체는 2중 for문을 쓰면 금방 풀리긴 하는데, 그렇게 호락호락 할리가 없지 ㅎㅎ

조건이 백만까지 주어져서, 2중 for문을 쓰면 시간초과가 뜰 것이다.

이 문제는 주어진 숫자들을 정렬해서 푸는 문제가 아니므로, 앞에서부터 작은 수들을 지워나가야 한다.

키포인트는 stack을 이용한 풀이이다.

숫자들을 스택에 넣다가, 만약 스택의 top보다 큰 수가 나오면 스택의 top은 '제일 큰 수'를 만드는데 걸림돌이 되는 수이므로 정답에 포함되면 안된다.

예를 들어, 4177252841 , k=4 라고 하자

1) stack = [], num = 4, k =4

2) stack = [4], num =1, k = 4

3) stack = [4,1], num =7, k= 4

4) stack =[7], num = 7, k=2

5) stack[7,7], num = 2, k=2

6) stack[7,7,2], num = 5, k=2

7) stack[7,7,5], num = 2, k=1

8) stack[7,7,5,2], num = 8, k=1

9) stack[7,7,5,8], num = 4, k=0

10) stack[7,7,5,8,4], num = 1, k=0

11) stack[7,7,5,8,4,1], end, k=0

이 순서를 하나씩 따라가다 보면 감이 올 것이다.

유의할 점!

ex) 4321, k=2 같은 경우는 어떻게 할까..?

=> answer = ''.join(arr[:len(arr)-k]) 를 잘 살펴보자

def solution(number, k):
    answer = ''
    arr = []

    for num in number:
        if k > 0:
            if len(arr)==0:
                arr.append(num)
            else:
                while len(arr)>0 and arr[-1] < num and k>0:
                    arr.pop()
                    k-=1
                arr.append(num)

        else: arr.append(num)
                         
    answer = ''.join(arr[:len(arr)-k])
    return answer

[프로그래머스/파이썬] 조이스틱

beomseok99 — Thu, 14 Sep 2023 00:29:46 +0900

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

프로그래머스

programmers.co.kr

이 문제의 포인트는 2가지이다.

1. A에서 해당 알파벳으로 가는 최소 횟수 구하기

2. 현재 위치에서 왼쪽과 오른쪽 어디로 갈 것 인지 정하기

1번은 사실 정해져있다

아스키코드를 이용해 풀이하면, 중간 인덱스를 기준으로 A에서 출발하는 것이 빠른지 아니면 Z로 이동해서 거꾸로 가는 것이 빠른지 알 수 있기 때문이다.

그렇다면 중요한 것은 2번인데

어떻게 풀지 생각해보면, 가장 중요한 포인트는 "연속된 A가 있을 경우, 반대쪽으로 피해가자" 이다'

그러나 무작정 피해가면 안된다,, 왜?

1) BBAAAAAAAABBBB

2) BBBBAAAAAAAABB

두 예시를 보자. 일단 한눈에 봐도 저 AAAA는 그냥 지나가면 손해일 것 같다.

1번 예시는 B에서 출발하여 바로 맨 뒤로 이동하는 것이 이득이다.

2번 예시는 일단 BBBB로 갔다가 다시 맨 처음 B로 돌아와서 맨 뒤에 있는 B로 이동하는 것이 가장 좋다

그렇기 때문에, 매 상황마다 연속된 A들을 기준으로 계속 진행 방향대로 갈지, 반대로 꺾을지 결정해야 한다.

def solution(name):
    answer = 0
    min_move = len(name) - 1

    # 위 아래 이동 횟수
    for idx in range(len(name)):
        
        ascii = ord(name[idx]) - 65
        
        if ascii > 13:
            answer += 26 - ascii

        else: answer += ascii            
    
    # 연속된 A 찾아서 좌우 이동 최적화
    for i in range(len(name)):
        next = i + 1
        while next < len(name) and name[next] == 'A':
            next += 1
        min_move = min([min_move, 2 * i + len(name) - next, i + 2 * (len(name) -next)])
    answer += min_move
    return answer

코드 설명

min_move = min([min_move, 2 * i + len(name) - next, i + 2 * (len(name) -next)])

쉽게 말해서

1) 그냥 쭉 전진 (min_move)

2) A의 왼쪽 부분 먼저 탐색하고 되돌아가서 오른쪽 부분 탐색

3) A의 오른쪽 부분 먼저 탐색하고 되돌아가서 왼쪽 부분 탐색

이 3가지 경우를 계속해서 비교하며 최적의 이동 횟수를 찾는 것이다

[프로그래머스/파이썬] 게임 맵 최단거리

beomseok99 — Sun, 10 Sep 2023 21:52:31 +0900

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

프로그래머스

programmers.co.kr

까다로운 조건이 없는 BFS 문제이다

한가지 팁은, 아래의 cnt 변수를 어떻게 잘 조작하면 굳이 방문 배열을 사용하지 않고도 풀 수 있다는 점을 잘 생각해보시길..

from collections import deque

def solution(maps):
    answer = -1
    
    dq = deque()
    dq.append([[0,0],1])

    end_x, end_y = len(maps), len(maps[0])
    
    dx = [0,1,-1,0]
    dy = [1,0,0,-1]
    
    visited = [[False for _ in range(end_y)] for _ in range(end_x)]
    visited[0][0] = True
    while dq:
        now, cnt = dq.popleft()
        x = now[0]
        y = now[1]
        #print(x,y)
        if x == end_x-1 and y == end_y-1:
            answer = cnt
            break
            
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            
            if nx < 0 or nx >= end_x or ny < 0 or ny >= end_y:
                continue
            if visited[nx][ny] or maps[nx][ny]==0:
                continue
                
            visited[nx][ny] = True
            dq.append([[nx,ny],cnt+1])
        
    return answer

[프로그래머스/파이썬] 올바른 괄호

beomseok99 — Fri, 8 Sep 2023 00:11:57 +0900

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

프로그래머스

programmers.co.kr

아주 기본적인, 스택을 활용한 괄호처리 문제이다.

아마 컴공 학생들이면 자료구조 과제로 한번쯤 접해봤으리라 생각된다 ㅋㅋ

파이썬 특성 상, 스택 자료구조를 굳이 사용하지 않아도 리스트나 데큐를 이용해 풀 수 있으므로 너무 문제 유형에 사로잡히지 말 것!

def solution(s):
    answer = True
    
    stack = []
    
    for now in s:
        if now =='(':
            stack.append('(')
        elif now == ')':
            if len(stack)==0:
                answer = False
            else:
                stack.pop()
                
    if len(stack) != 0:
        answer = False

    return answer

[프로그래머스/파이썬] 폰켓몬

beomseok99 — Thu, 7 Sep 2023 00:19:38 +0900

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

프로그래머스

programmers.co.kr

비교적 간단한 문제이다..

이 문제를 리뷰하는 이유는, 아래가 내가 푼 풀이인데 다른 사람의 풀이가 너무 좋아 리뷰하고자 한다.

문제를 풀 때 주어진 문제에 충실하는 것도 좋지만, 언제든 더 쉽게 풀 수 있는 방법이 있으므로 연습을 많이 하자.

생각해보면 우리가 수학 문제를 풀 때 정석대로 풀이하는 것도 배웠지만, 문제의 유형이나 테크닉을 익혀 쉽게 푸는 것도 배운 것 처럼,,

def solution(nums):
    answer = 0
    dict = {}
    can_get = len(nums)//2
    
    for num in nums:
        if num in dict:
            dict[num] = dict[num]+1
        else:
            dict[num]=1
            
    answer = len(dict)
    if len(dict) > can_get:
        answer = can_get
    return answer

## 다른 사람의 풀이 #1

set 함수를 이용해 바로 하나의 집합을 만들어 냈다. 물론 딕셔너리와는 다르지만, 중복을 허용하지 않는다는 공통점을 이용해 풀이한 것으로 추측한다.

def solution(ls):
    return min(len(ls)/2, len(set(ls)))

## 다른 사람의 풀이 #2

class ALWAYS_CORRECT(object):
    def __eq__(self,other):
        return True

def solution(a):
    answer = ALWAYS_CORRECT()
    return answer;

~~도대체 이건 뭘까,,~~

수정 -> 이 코드는 치팅 코드라고 생각된다.

__eq__ 함수는 동등 비교를 할 때 사용하는 함수인데, 이 함수를 오버라이딩해서 아무 조건 없이 True를 반환하게 해준 뒤,

해당 메소드를 가지는 인스턴스를 반환시켜서 프로그래머스 채점할 때 정답 값에 상관없이 전부 True를 출력하게 하여 통과되게 만드는 코드이다.

아마 언어를 좀 잘 다루는 분의 코드라고 생각된다 ㅋㅋ

[프로그래머스/파이썬] 피로도

beomseok99 — Mon, 4 Sep 2023 16:40:37 +0900

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

프로그래머스

programmers.co.kr

itertools 를 사용할 줄 안다면 정말 쉽게 풀 수 있는 문제이다.

itertools 에 대한 사용법은 여기 -->> https://oh2279.tistory.com/216

from itertools import permutations

def solution(k, dungeons):
    answer = -1
    
    for order in permutations(dungeons):
        ans = 0
        tmp = k
        for under, use in order:
            if tmp >= under:
                tmp -= use
                ans += 1
        
        if ans > answer:
            answer = ans
    
    return answer

[파이썬 ] itertools 사용법

beomseok99 — Mon, 4 Sep 2023 16:40:27 +0900

순열을 이용해 완전탐색 문제를 풀 때, dfs와 같은 재귀를 사용해야만 하는 경우도 있다.

그러나 재귀는 overflow를 유도하는 가장 쉬운 방법이기 때문에 항상 사용할 때 유의해야 한다.

우리는 이제 순열 조합을 이용한 문제를 코드 한 줄로 풀 수 있다.

combinations() # 조합
combinations_with_replacement() # 중복조합
product() # 데카르트 곱
permutations() # 순열

combinations(iterable, r)

iterable에서 원소 개수가 r개인 조합 뽑기

from itertools import combinations

if __name__ == '__main__':
    iterator = [1, 2, 3, 4]
    for i in combinations(iterator, 3):
        print(i)

출력 결과
(1, 2, 3)
(1, 2, 4)
(1, 3, 4)
(2, 3, 4)

combinations_with_replacement(iterable,r)

iterable에서 원소 개수가 r개인 중복 조합 뽑기

from itertools import combinations_with_replacement

if __name__ == '__main__':
    iterator = [1, 2, 3, 4]
    for i in combinations_with_replacement(iterator, 2):
        print(i)

출력 결과
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(2, 2)
(2, 3)
(2, 4)
(3, 3)
(3, 4)
(4, 4)

permutations(iterable,r)

iterable에서 원소 개수가 r개인 순열 뽑기

from itertools import permutations

if __name__ == '__main__':
    iterator = [1, 2, 3, 4]
    for i in permutations(iterator, 2):
        print(i)

출력 결과
(1, 2)
(1, 3)
(1, 4)
(2, 1)
(2, 3)
(2, 4)
(3, 1)
(3, 2)
(3, 4)
(4, 1)
(4, 2)
(4, 3)

product(*iterables, repeat=1)

여러 iterable의 데카르트곱 반환

from itertools import product

if __name__ == '__main__':
    iterator1 = ['A', 'B', 'C']
    iterator2 = ['1', '2', '3']

    for i in product(iterator1, iterator2, repeat=1):
        print(i)

출력 결과
('A', '1')
('A', '2')
('A', '3')
('B', '1')
('B', '2')
('B', '3')
('C', '1')
('C', '2')
('C', '3')

[프로그래머스/파이썬] 타겟 넘버

beomseok99 — Tue, 29 Aug 2023 03:25:32 +0900

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

프로그래머스

programmers.co.kr

BFS/DFS 연습용 문제이다

예시가 4,1,2,1이라고 하면,

4 -> 5 or 3 에서

5 -> 6 or 4 와 3 -> 4 or 2 ,,,

와 같은 식으로 갈 수 있다.

from collections import deque
def solution(numbers, target):
    answer = 0

    q = deque()
    q.append([numbers[0],0])
    q.append([-1*numbers[0],0])
    n = len(numbers)
    
    while q:
        number,idx = q.popleft()
        idx = idx + 1
        
        if idx < n:
            q.append([number + numbers[idx],idx])
            q.append([number - numbers[idx],idx])
            
        else:
            if number == target:
                answer = answer + 1
            
    return answer

[백준/파이썬] 13549번 숨바꼭질 3

beomseok99 — Sat, 8 Jul 2023 23:57:26 +0900

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

13549번: 숨바꼭질 3

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때

www.acmicpc.net

이 문제는 0-1 bfs 문제이다.

0-1 bfs란?? 그래프의 간선에서 가중치가 0과 1로만 이루어진 bfs 문제를 말한다!

이 문제가 해당 케이스이다.

-1, +1, *2 위치를 체크하는 것은 bfs와 다를 바 없으나,

가중치가 0인 간선이, 가중치가 1인 간선보다 더 앞에 삽입되어야 한다!

가중치가 0이라는 것은, 아무 cost가 없다는 것을 의미하기 때문에 가장 효율적이라고 볼 수 있다.

즉, 가중치 0인 간선을 appendleft()를 이용해 삽입하거나, 3개의 if문 중 제일 첫번째 순서에 작성해줘야 한다.

import sys
#sys.setrecursionlimit(10**6)
input = sys.stdin.readline
from collections import deque

def main():  
  print(bfs())
  
def bfs():
  ans = 0
  while len(q) > 0 :
    ord = q.popleft()
    pos = ord[0]
    cnt = ord[1]
    
    visited[pos]= True
        
    if pos == k:
      ans = cnt
      break
    
    if pos*2 >= 0 and pos*2 < 100001 and not visited[pos*2]:
      q.append([ pos *2, cnt ])

    if pos-1 >= 0 and pos-1 < 100001 and not visited[pos-1]:
      q.append([pos - 1, cnt + 1 ])
        
    if pos+1 >= 0 and pos+1 < 100001 and not visited[pos+1]:
      q.append([ pos + 1, cnt + 1 ])
      
    
  return ans
  
if __name__ == "__main__":
  n,k = map(int,input().split())
  q = deque()
  visited = [False] * 100010
  q.append([n,0])
  
  main()

파이썬 int(a/b)와 a//b 차이

beomseok99 — Thu, 6 Jul 2023 00:16:56 +0900

int(a/b)와 a//b는 일반적인 경우에는 동일한 결과를 반환합니다.

그러나 몇 가지 경우에는 차이가 발생할 수 있습니다.

1. 연산 과정의 차이

a/b는 항상 실수형(float) 결과를 반환합니다. 여기에 int() 함수를 적용하게 된다면, a//b 는 나눗셈의 결과를 가장 가까운 정수로 내림한 값을 반환합니다. 예를 들어, 5//2 의 결과는 2가 됩니다.

반면에, a//b는 정수형(integer) 몫을 반환합니다. 즉, 나눗셈의 결과를 정수 부분만 남기고 나머지는 버립니다. 따라서 5//2의 결과는 2가 됩니다.

=> 결과는 동일하지만, 나눗셈의 결과를 내림한다는 것과 정수 몫을 구하고 나머지는 버림한다는 애매한 차이가 있다고 볼 수 있겠습니다.

2. 음수의 처리

가장 큰 차이라고도 할 수 있는 음수 계산입니다.

int(a/b)는 버림 연산을 수행하고, 몫 연산(//)은 내림 연산을 수행하기 때문에, 음수의 경우에는 결과가 조금 다를 수 있습니다.

예를 들어, -5/3의 경우 -5/3은 1.666.. 이고 int(-5/3)은 -1 이고 -5//3은 -2 입니다.

a = -5
b = 3

print(a/b)
print(int(a/b))
print(a//b)

실행 결과

int(-1.666..)의 경우 버림을 취해 -1 이라는 결과를 보이며, -5//3 의 경우 -1.666..을 내림하여 -2가 되는 것을 확인할 수 있습니다.

따라서, 일반적인 경우에는 int(a/b)와 a//b는 동일한 결과를 반환하지만, 몇몇 상황에서는 다른 결과를 반환하는 것을 유의해야 합니다.

SegFormer custom data로 학습시키기!

beomseok99 — Fri, 23 Jun 2023 00:17:30 +0900

segformer의 offical github를 가져와서 custom data로 학습시키는 것을 해보겠다

0. 우선 기본적인 세팅은 끝마쳤다고 생각하겠다

(apt update, upgrade, conda 또는 docker를 이용해 환경 설정 등)

https://daeun-computer-uneasy.tistory.com/126 이 링크 참조하시면 좋을 것 같습니다.

mmcv 같은 경우, cuda 및 torch 버전에 엄청난 영향을 받아서,, 꼬일 대로 꼬이면 답도 없습니다 ㅜㅜ

[PyTorch] mmcv 설치하기 / cuda 버전에 맞게 mmcv downgrade하기 / mmcv._ext error 해결

오늘은 잊을만하면 나오는 mmcv 설치 방법에 대해 총정리하는 포스팅을 해보려고 한다. 사실 항상 설치할 때마다 열받는 것 같아서, 한번에 정리해보기로 했다. (미래에 내가 볼 수 있도록..) # mmcv

daeun-computer-uneasy.tistory.com

1. custom data set 폴더 설정

data/custom/images/train/*.jpg
data/custom/images/val/*.jpg

data/custom/annotations/train/*.png
data/custom/annotations/val/*.png

annotations 이미지들은 png로 확장자를 변경해주자. (확장자 변경하는 코드도 이 블로그의 파이썬 카테고리에 있다!)

2. local_configs/_base_/datasets/custom.py 생성(or 수정)

이미 있다면 수정해주고, 없다면 만들어주자.

# dataset settings
dataset_type = 'CustomDataset'
data_root = 'data/custom/'
img_norm_cfg = dict(
    mean=[], std=[], to_rgb=True)
crop_size = (512, 512)
train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations', reduce_zero_label=True),
    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
    dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
    dict(type='RandomFlip', prob=0.5),
    dict(type='PhotoMetricDistortion'),
    dict(type='Normalize', **img_norm_cfg),
    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
    dict(type='DefaultFormatBundle'),
    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
]
test_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(
        type='MultiScaleFlipAug',
        img_scale=(2048, 512),
        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
        flip=False,
        transforms=[
            dict(type='Resize', keep_ratio=True),
            dict(type='RandomFlip'),
            dict(type='Normalize', **img_norm_cfg),
            dict(type='ImageToTensor', keys=['img']),
            dict(type='Collect', keys=['img']),
        ])
]
data = dict(
    samples_per_gpu=8,
    workers_per_gpu=4,
    train=dict(
        type=dataset_type,
        data_root=data_root,
        img_dir='images/train',
        ann_dir='annotations/train',
        pipeline=train_pipeline),
    val=dict(
        type=dataset_type,
        data_root=data_root,
        img_dir='images/val',
        ann_dir='annotations/val',
        pipeline=test_pipeline),
    test=dict(
        type=dataset_type,
        data_root=data_root,
        img_dir='images/val',
        ann_dir='annotations/val',
        pipeline=test_pipeline))

다른 파일들과 다른 점은 없지만, 어떤 데이터셋을 쓸건지, 경로는 어디인지, mean과 std는 무엇인지 등 만을 수정해주었다.

(mean이랑 std 구하는 코드도 이 블로그의 파이썬 카테고리에 있다!)

여기서 samples per gpu는 배치사이즈고, workers per gpu은 데이터셋을 gpu로 넘기는 subprocess를 말한다.

3. config 파일 수정

segformer/B0~5/segformer.512x512.~~~.py 등이 있는데 원하는 것 아무거나 골라서 수정해주면 된다.

_base_ = [
    #'../../_base_/models/segformer.py',
    '../../_base_/datasets/custom.py',
    '../../_base_/default_runtime.py',
    '../../_base_/schedules/schedule_160k_adamw.py'
]

# model settings
norm_cfg = dict(type='BN', requires_grad=True)
find_unused_parameters = True
model = dict(
    type='EncoderDecoder',
    # pretrained='local_configs/segformer/B0/pretrained/mit_b0.pth',
    pretrained= None,
    backbone=dict(
        type='mit_b0',
        style='pytorch'),
    decode_head=dict(
        type='SegFormerHead',
        in_channels=[32, 64, 160, 256],
        in_index=[0, 1, 2, 3],
        feature_strides=[4, 8, 16, 32],
        channels=128,
        dropout_ratio=0.1,
        num_classes=2,
        norm_cfg=norm_cfg,
        align_corners=False,
        decoder_params=dict(embed_dim=256),
        #decoder_params=dict(),
        loss_decode=dict(type='CrossEntropyLoss', use_sigmoid=True, use_mask=False,loss_weight=1.0)),
    # model training and testing settings
    train_cfg=dict(),
    test_cfg=dict(mode='whole'))

# optimizer
optimizer = dict(_delete_=True, type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01,
                 paramwise_cfg=dict(custom_keys={'pos_block': dict(decay_mult=0.),
                                                 'norm': dict(decay_mult=0.),
                                                 'head': dict(lr_mult=10.)
                                                 }))

lr_config = dict(_delete_=True, policy='poly',
                 warmup='linear',
                 warmup_iters=1500,
                 warmup_ratio=1e-6,
                 power=1.0, min_lr=0.0, by_epoch=False)

이것 역시 크게 수정한 부분은 없지만, 모델의 config가 되는 부분이므로 바꿀 부분이 있다면 바꿔주자

ex) class 수, optimizer, pretrained 등 ,,

나는 binary segmentation을 진행해서 class 수를 2로 바꾸는 등 여러 작업을 했다.

4. 학습 돌리기!

원하는 config 파일명을 넣어서 돌려주면 된다.

python tools/train.py local_configs/segformer/B0/segformer.b1.512x512.ade.160k.py --gpus 1

----단일 gpu로 학습시킨다면, synBN을 BN으로 바꿔줄 것!-----

하기 전에 항상 데이터의 값을 찍어보자!

grayscale 이미지는 uint8의 범위 (0~255)를 가진다. 만약 binary segmentation을 할 경우, 이를 0과 1로 치환해야하므로 데이터를 load할 때 convert하는 코드를 넣어주면 된다.

아니면 loss단에

label = torch.where(label > 125, 1, 0)

이런 코드를 적어주면 되긴 하는데,, 추천하지 않는다.

파이썬 이미지 파일 확장자명 한번에 바꾸기

beomseok99 — Sat, 10 Jun 2023 21:09:51 +0900

아래 코드는 jpg 파일을 png파일로 변환하는 파이썬 코드이다

glob(~~)안에 데이터가 위치한 경로를 적어주고, src 변수에 .jpg를 뺀 파일의 이름을 저장해준 뒤 거기에 .png를 붙여주는 간단한 방식이다.

그냥 직관적이어서 좋은 것 같다.

import os
import glob

files = glob.glob('data/custom/annotations/train/*.jpg')

for i in files:
    src = i[:-4]
    os.rename(i,src+'.png')

[백준/파이썬] 1041번 주사위

beomseok99 — Wed, 31 May 2023 13:27:40 +0900

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

1041번: 주사위

첫째 줄에 N이 주어진다. 둘째 줄에 주사위에 쓰여 있는 수가 주어진다. 위의 그림에서 A, B, C, D, E, F에 쓰여 있는 수가 차례대로 주어진다. N은 1,000,000보다 작거나 같은 자연수이고, 쓰여 있는 수

www.acmicpc.net

2x2x2 주사위와

3x3x3 주사위, 4x4x4 주사위를 그리면서 직접 세보면 패턴을 찾을 수 있다.

정육면체 주사위는 N==1 이 아닌 이상, 최소 1면 ~ 최대 3면까지만 볼 수 있다.

import sys
#sys.setrecursionlimit(10**6)
input = sys.stdin.readline

if __name__ == "__main__":
    N = int(input())
    ans = 0
    dice = list(map(int,input().split()))
    
    if N == 1:
        print(sum(dice)-max(dice))
    else: # N >= 2
        
        # 제일 작은 수  3개 고르는데, 주사위의 특성 고려
        cube = [min(dice[0], dice[5]),
                min(dice[1], dice[4]),
                min(dice[2], dice[3])]
        cube.sort()

        # 한 면만 보이는 주사위
        ans += ((N-1) * 4 * (N-2) + (N-2)**2) * cube[0]
        
        # 두 면이 보이는 주사위
        ans += ((N-1) * 4 + (N**2-4-(N-2)**2)) * (cube[0] + cube[1])
        
        # 세 면이 보이는 주사위
        ans += 4 * sum(cube)
        
        print(ans)

SegFormer 논문 리뷰 (Simple and Efficient Design for Semantic Segmentation with Transformers)

beomseok99 — Tue, 30 May 2023 23:32:38 +0900

Abstact

- 간단한 구조의 Decoder

- multi-scale feature

- Positional Encoding X

1.Introduction

- Transformer가 vision task에 쓰이며 발생하는 문제는?

=> output이 single scale의 낮은 resolution feature + large image에 대해 높은 계산량

- Encoder, Decoder 모두 redesign

=> hierachical Transformer Encoder (no positional encoding) + 간단한 Decoder (All MLP, 계산량 감소) + 효율적이고 정확

positional encoding이 사라짐에 따라 학습에 사용되지 않은 이미지 사이즈를 테스트 시 interpolation 사용으로 인한 성능 하락을 피할 수 있다.

MLP로만 이루어진 Decoder를 사용하여, 각 feature map의 local attention + multiscale feature map들을 합침으로써 얻는 global attention을 통해 강력한 representation을 보인다.

2.Relate Work

- Semantic Segmentation

- Transformer backbones

- Transformers for specific tasks

3.Method

- 입력 :H x W x 3, patch size : 4 x 4

SegFormer는 두 개의 main module로 구성된다.

1. Hierarchical Transformer Encoder : high-resolution에선 coarse feature를, low-resolution에선 fine feature를 생성

2. lightweight ALL-MLP Decoder : 마지막 최종 semantic segmentation mask를 위해 multi-level feature를 합침

입력 이미지 사이즈가 H x W x 3 일때 VIT(Vision Transformer)에서는 patch size를 16 x 16으로 설정하였다.

저자들은 dense prediction task에서 더 높은 성능을 뽑기 위해 그보다 더 작은 4 x 4 patch size를 사용하였다.

이렇게 나눈 patch들은 multi-level feature map 을 뽑아내는 Transformer encoder로 들어가게 되며, 이때 각 feature map의 size는 원본 이미지에 대해 {1/4, 1/8, 1/16, 1/32}으로 설정한다.

MLP decoder에서는 multi-level feature map을 여러 레이어에 거쳐 최종적으로 H/4 x H/4 x N(class) resolution을 갖는 Segmentation mask를 예측하게 된다.

1. Hierarchical Transformer Encoder (MiT)

1-1. Hierarchical Feature Representation

: multi-level feature 생성

(high-resolution coarse feature, low-resolution fine-grained feature)

1-2. Overlapped Patch Merging

: 인접 Patch간 정보 교류가 부족

-> CNN kernel처럼 overlap하면서 Patch Merging

(stride, padding 이용)

ViT에서는 N x N x 3 patch를 1 x 1 x C 벡터로 표현하였다. 이때 각 patch들은 서로 non-overlap 상태이기 때문에 patch들 간에 local continuity 가 보존되기가 어렵다.

이를 해결하기위해 Swin Transformer에서는 Shifted Window를 통해 패치들간의 local continuity를 보존하려고 했고

SegFormer에서는 이 문제를 overlapping patch merging 으로 접근하였다.

1-3. Efficient Self-Attention

: 기존 수식은 O(N^2)의 계산 복잡도를 가짐 (N = H * W)

-> Reduction ratio 사용, Key와 Value의 N 감소

N을 R로 나누고 C에 R을 곱하면 Reshape이 가능해지고 이때 C dot R을 Linear 연산을 통해 다시 C로 줄임으로써

N/R x C차원의 Key, Value로 만들어 줄 수가 있다.

저자들은 실험을 통해 Stage-1부터 Stage-4 까지의 R을 [64, 16, 4, 1]로 설정

1-4. Mix-FFN

ViT에서는 지역 정보를 추가하기 위해 positional encoding을 적용시켰다.

하지만 이런 방식은 input resolution이 고정되어야 한다는 문제가 있으며 이는 input resolution이 달라지게 되면 interpolation을 통해 크기를 맞춰줘야 해서 성능 하락을 유발한다.

이에 저자들은 positional encoding이 semantic segmentation에 꼭 필요한 것은 아니라고 하며 positional encoding을 대신하여 3 x 3 Convolution (stride: 1 / padding: 1)을 FFN에 적용시켰다. (3 x 3 Conv의 zero padding을 통해 leak location의 정보를 고려할 수 있다고 주장)

실험을 통해 3 x 3 convolution이 충분히 Transformer에 위치 정보를 제공할 수 있다는 것을 보였고 파라미터 수를 줄이기 위해 3x3 convolution을 depth-wise convolution으로 사용하였다.

: positional embedding 대신 3 x 3 Convolution (zero padding)

(3x3 depth wise convolution)

depth wise convolution이란? 동일 channel 내에서만 convolution 연산 수행

= 필터 수는 입력 채널의 수와 동일

2. Lightweight All-MLP Decoder

1. multi-level feature들의 channel을 모두 C로 동일하게 통합

2. feature size를 original image의 1/4 크기로 Upsample

3. feature들을 concatenate and 4배로 증가한 channel을 C로 복원

4. 최종 segmentation mask를 예측

(batch x N(num of class) x H/4 x W/4)

위 1-4번을 식으로 표현하면 아래와 같다.

3. Effective Receptive Field Analysis (ERF Analysis)

Semantic Segmentation 에서는 context 정보를 포함하도록 큰 receptive field 를 유지하는 것은 핵심 문제이다.

DeepLabv3+의 ERF는 가장 깊은 stage-4 에서도 상대적으로 작고,

SegFormer의 Encoder는 하위 stage에서 local attention을 자연스럽게 생성하는 동시에 stage-4 에서 context를 효과적으로 캡처하는 non-local attention 을 출력할 수 있습니다.

또한 줌인 패치(맨 오른쪽)에서 볼 수 있듯이 Decoder의 MLP head(파란색 상자)의 ERF는 stage-4(빨간색 상자)와 다르며 non-local attention 보다 local-attention이 더 강합니다.

저자는 SegFormer의 Decoder 설계가 non-local attention을 활용하고 복잡하지 않으면서 더 큰 receptive field를 가진다고 설명합니다.

또한 SegFormer 의 Decoder 디자인은 본질적으로 local / non-local attention 을 모두 생성하는 트랜스포머의 이점을 취합니다.

4.Experiment

5.Conclusion

복잡한 디자인을 가지는 기존의 방법을 피하고 efficiency하면서 좋은 performance을 보여준다.

여러 Dataset에서 SOTA를 달성했다.

[프로그래머스/파이썬] 정수 삼각형

beomseok99 — Tue, 30 May 2023 00:41:02 +0900

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

프로그래머스

programmers.co.kr

프로그래머스에서 dp 문제 풀었다.

그런데 왠걸,, 백준에서 이미 비슷한 문제를 풀어본 적이 있었기에 금방 풀었다 ㅎㅎ

level 3의 다른 카테고리 문제들보면 좀 까다로운 경우가 많은데, 아무래도 dp인지라 기본적으로 level이 좀 높게 잡히는 것 같다.

그래도 이 문제는 크게 어려운 점화식도 아니니 찬찬히 코드 보면서 손으로 따라가면 금방 이해하실 수 있을 것 같다.

def solution(triangle):
    answer = 0
    dp = [[0 for _ in range(len(triangle))] for _ in range(len(triangle))]
    dp[0][0] = triangle[0][0]

    for i in range(1,len(triangle)):
        for j in range(len(triangle[i])):
            if j == 0:
                dp[i][0] = dp[i-1][0] + triangle[i][0]
            elif j == len(triangle[i]) - 1:
                dp[i][j] = dp[i-1][j-1] + triangle[i][j]
            else:
                dp[i][j] = max(dp[i-1][j-1] + triangle[i][j], dp[i-1][j] + triangle[i][j])
            #print(i,j,dp[i][j])

    answer = max(max(dp))
    return answer

UNet 논문 리뷰 (U-Net : Convolutional Networks for Biomedical Image Segmentation)

beomseok99 — Tue, 30 May 2023 00:04:58 +0900

Semantic Segmentation

- 픽셀 기반으로 이미지를 분할하여 구분

0.Short Summary

- 넓은 범위의 이미지 픽셀로부터 의미정보를 추출하고 의미정보를 기반으로 각 픽셀마다 객체를 분류하는 U 모양의 아키텍처

- 서로 근접한 객체 경계를 잘 구분하도록 학습하기 위한 Weighted Loss

1.Introduction

- 생물학 분야의 영상 처리에선 Localization이 포함된 Classification이 필요

- FCN (fully-convolution layer)

- Context(의미정보)를 얻기 위한 Contractinig Path

- Localization(각 픽셀이 어떤 객체에 속하는지)을 위해 Resolution을 키우는 Expanding Path

= 점진적으로 넓은 범위의 이미지 픽셀을 보며 의미정보(Context Information)을 추출하는 수축 경로(Contracting Path)

의미정보를 픽셀 위치정보와 결합(Localization)하여 각 픽셀마다 어떤 객체에 속하는지를 구분하는 확장 경로(Expanding Path)

수축 경로에서 확장 경로로 전환되는 전환 구간(Bottle Neck)

2.Architecture

- 1. Contracting Path (수축경로)

- 논문에서는 BN을 사용하지 않았지만, 대다수의 리뷰 또는 Github에서 BN을 적용한 것을 확인

= 수축경로는 주변 픽셀들을 참조하는 범위를 넓혀가며 이미지로부터 Contextual 정보를 추출하는 역할을 합니다.

3×3 Convolution을 수행할 때 패딩을 하지 않으므로 Feature Map의 크기가 감소합니다.

Downsampling 할 때 마다 채널(Channel)의 수를 2배 증가시키면서 진행합니다.

즉 처음 Input Channel(1)을 64개로 증가시키는 부분을 제외하면 채널은 1−>64−>128−>256−>512−>1024 개로 Downsampling 진행할 때마다 2배씩 증가합니다.

- 2. Bottle Neck (전환 구간)

- 수축 경로에서 확장 경로로 전환되는 구간, Drop out을 통해 모델을 일반화하고, 노이즈에 강하게 해줌

- 3. Expanding Path (확장 경로)

2 번 과정은 skip connection 을 의미

Expanding Path 2)Skip Connection을 통해 수축 경로에서 생성된 Contextual 정보와 위치정보 결합하는 역할을 합니다.

동일한 Level에서 수축경로의 Feature Map과 확장경로의 Feature Map의 크기가 다른 이유는 여러번의 패딩이 없는 3×3 Convolution Layer를 지나면서 특징맵의 크기가 줄어들기 때문입니다.

Expanding Path의 마지막에 Class의 갯수만큼 필터를 갖고 있는 1×1 Convolution Layer가 있습니다.

1×1 Convolution Layer를 통과한 후 각 픽셀이 어떤 Class에 해당하는지에 대한 정보를 나타내는 3차원(Width × Height × Class) 벡터가 생성됩니다.

3.Training

- 1. Overlap-tile strategy

본 논문에서 다양한 학습 장치들을 통해 모델의 성능을 향상시킵니다.

이미지의 크기가 큰 경우 이미지를 자른 후 각 이미지에 해당하는 Segmentation을 진행해야 합니다.

U-Net은 Input과 Output의 이미지 크기가 다르기 때문에 위 그림에서처럼 파란색 영역을 Input으로 넣으면 노란색 영역이 Output으로 추출됩니다

동일하게 초록색 영역을 Segmentation하기 위해서는 빨간색 영역을 모델의 Input으로 사용해야 합니다.

즉, 겹치는 부분이 존재하도록 이미지를 자르고 Segmentation하기 때문에 Overlap Tile 전략이라고 논문에서는 지칭합니다.

= Fully Convolutional Network 구조의 특성상 입력 이미지의 크기에 제약이 없다. 따라서 U-Net 연구팀은 크기가 큰 이미지의 경우 이미지 전체를 사용하는 대신 overlap-tite 전략을 사용

- 2. Mirroring Extrapolate

이미지의 경계부분을 예측할 때에는 Padding을 넣어 활용하는 경우가 일반적입니다. 본 논문에서는 이미지 경계에 위치한 이미지를 복사하고 좌우 반전을 통해 Mirror 이미지를 생성한 후 원본 이미지의 주변에 붙여 Input으로 사용합니다.본 논문의 실험분야인 biomedical 에서는 세포가 주로 등장하고, 세포는 상하 좌우 대칭구도를 이루는 경우가 많기 때문에 Mirroring 전략을 사용했을 것이라고 추측합니다.

- 3. Weighted Loss

- x는 feature map에 있는 각 픽셀

- w(x)는 weight map, 픽셀 별로 가중치를 부과하는 역할

모델은 위 그림처럼 작은 경계를 분리할 수 있도록 학습되어야 합니다. 따라서 논문에서는 각 픽셀이 경계와 얼마나 가까운지에 따른 Weight-Map을 만들고 학습할 때 경계에 가까운 픽셀의 Loss를 Weight-Map에 비례하게 증가 시킴으로써 경계를 잘 학습하도록 설계하였습니다.

Loss는 맨 마지막에 얻은 feature map에 픽셀 단위로 softmax를 수행하고 여기에 cross entropy loss function을 적용하는 식

weight map을 의미하는 w(x)는 특정 클래스가 가지는 픽셀의 주파수의 차이를 보완해주는 식이라고 보시면 됩니다. 같은 세포 클래스라도 픽셀값에 차이가 있으니 그런걸 채워준다 뭐 그런뜻이 아닌가 싶습니다.

weight map에 픽셀에서 얻은 클래스별 예측값을 soft-max한 것의 log를 곱한 것이 E라고 할 수 있겠습니다.

- 4. Data Augmentation

- shift, rotation, random-elastic deformation 기법을 사용

- elastic deformation ?

“We generate smooth deformations using random displacement vectors on a coarse 3 by 3 grid. The displacements are sampled from a Gaussian distribution with 10 pixels standard deviation. Per-pixel displacements are then computed using bicubic interpolation. Drop-out layers at the end of the contracting path perform further implicit data augmentation.”

4.Experiment

1. EM Segmentation challenge

EM Segmentation challenge의 Dataset을 활용, 약 30개의 data (이미지 + GT)

- Warping Error : 객체 분할 및 병합이 잘 되었는지를 확인하는 segmentation과 관련된 에러

2. EM Segmentation challenge

- Iou score 사용, 세포라고 구분한 영역과 실제 세포의 영역이 겹치는 정도로 성능을 측정

세포 분류 대회인 ISBI cell tracking challeng 에서 모델의 성능을 평가한 표는 아래와 같습니다.

“PhC-U373” 데이터는 위상차 현미경으로 기록한 35개의 이미지를 Training 데이터로 제공합니다.

“DIC-HeLa” 데이터는 HeLa 세포를 현미경을 통해 기록하고 20개의 이미지를 Training 데이터로 제공합니다.

5.Conclusion

U-Net은 다양한 biomedical segmentation applications에서 "아주" 좋은 성능을 보여줬습니다.

저자는 elastic deformation이 포함된 Data augmentation 덕분에 적은 사이즈의 데이터셋만 요구했고 합리적인 학습 시간(NVidia Titan GPU (6 GB)에서 10시간 학습)을 가졌다고 말했습니다.

그리고 마지막으로 U-Net의 구조가 다양한 task에 쉽게 응용될 수 있을거라 확신한다고 말하며 논문을 끝냅니다.

Skip Architecture는 Layer를 깊게 쌓을수 있게 하여 복잡한 Task를 잘 수행할 수 있게 합니다.

또한 Bottle Neck에서 생기는 정보의 손실을 줄이는 역할을 합니다.

Weighted Loss는 근거리에 있는 객체를 효과적으로 분리하여 학습하는 좋은 방법

[백준/파이썬] 12919번 A와 B 2

beomseok99 — Sat, 27 May 2023 22:59:56 +0900

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

12919번: A와 B 2

수빈이는 A와 B로만 이루어진 영어 단어 존재한다는 사실에 놀랐다. 대표적인 예로 AB (Abdominal의 약자), BAA (양의 울음 소리), AA (용암의 종류), ABBA (스웨덴 팝 그룹)이 있다. 이런 사실에 놀란 수빈

www.acmicpc.net

A와 B 1번 문제에 이어서 2번 문제이다.

A와 B 1번 문제는 while문을 이용해 T에서부터 S를 만들어 나갈 수 있었지만, 2번 문제 같은 경우 while 문을 이용하기엔 다양한 경우의 수가 존재해서 재귀 + 브루트 포스를 이용해 풀었다.

import sys
#sys.setrecursionlimit(10**6)
input = sys.stdin.readline

def dfs(s,t):
    if s==t:
        return 1
    
    if len(t)<=len(s):
        return 0
    
    ans = 0
    if t[-1] == 'A': # 마지막이 A면 그냥 제거
        ans = dfs(s,t[:-1])
    if ans == 1:
        return 1

    if t[0]=='B': # 처음이 B면 reverse 후 제거
        ans = dfs(s,t[::-1][:-1])
        
    return ans

if __name__ == "__main__":
    S = list(input().rstrip())
    T = list(input().rstrip())
 
    print(dfs(S,T))

[백준/파이썬] 1111번 IQ Test

beomseok99 — Fri, 26 May 2023 19:15:29 +0900

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

1111번: IQ Test

다음 수를 출력한다. 만약 다음 수가 여러 개일 경우에는 A를 출력하고, 다음 수를 구할 수 없는 경우에는 B를 출력한다.

www.acmicpc.net

문제를 보면, 다음 수는 이전 수 * a + b이다.

이걸 잘 풀어보면 y = ax + b인 방정식으로 풀 수 있다. 여기서 x는 이전 수이고, y는 현재 수이다.

만약 아래와 같이 입력이 들어온다면, 2 = 1 * a + b인 것이다. 그렇다면 2를 f(1)로 표현할 수 있다!

1 2 3 4 5

여기서 a는 직선의 기울기를 의미하게 되는데, 기울기를 구하는 공식은 다음과 같다.

즉, f(2) - f(1) / 2 - 1 로 구할 수 있고, f(a)는 3이고 f(1)은 2 이므로 결국 예시에서의 기울기는 1이다.

y절편은 원래는 x에 0을 넣어서 구하지만, 이 문제에서는 다르게 구했다. 앞서 구한 기울기를 이용하면,

y = 1 * x + b 가 된다. 이는 f(x) = x + b와 동일하고, 위 예제의 숫자를 넣어보면 다음과 같다.

2 = 1 * 1 + b 가 된다. 이제 y절편인 b를 구할 수 있다.

또한, N==1, N==2, N==3 일 때 경우를 잘 따져서 구분해주면 된다.

import sys
#sys.setrecursionlimit(10**6)
input = sys.stdin.readline

def get_A(i):
    if numbers[i]-numbers[i-1] == 0: return 1
    return int((numbers[i+1]-numbers[i]) / (numbers[i]-numbers[i-1])) # 기울기 공식 f(a)-f(b) / a-b

def get_B(i,a):
    return int(numbers[i] - a * numbers[i-1]) # y절편

def isEqual(x):
    return len(set(x)) <= 1

if __name__ == "__main__":
    N = int(input())
    numbers = list(map(int, input().split()))
    
    if N == 1: print('A')
    elif N == 2:
        if numbers[0] == numbers[1]: print(numbers[1])
        else:
            print('A')
    else: # N==3
        if isEqual(numbers):
            print(numbers[0])
            
        else:
            for i in range(1,N-1):
                a = get_A(i)
                b = get_B(i,a)
                end = False
                flag = True
                for idx in range(1,N):
                    if numbers[idx] != (numbers[idx-1] * a + b) :
                        flag = False
                        break
                    
                if flag:
                    print(int(numbers[-1] * a + b))
                    end = True
                    break
            if not end: print('B')

[python] 프레임으로 나눠진 이미지들을 동영상으로 합치기

beomseok99 — Tue, 23 May 2023 15:42:55 +0900

아래 코드에서 주의할 점은, 본인의 프레임 개수는 약 370개로 0번 ~ 369번 이미지들이 존재했다.

만약 프레임 개수가 천단위가 넘어간다면 추가적인 배열이 하나 더 필요할 것이다.

배열을 따로 하는 이유는, sorting 할때 0, 1, 2... 순서가 아니라 0, 1, 10, 100, 101... 순으로 sorting 되기 때문이다.

natsort를 이용하는 방법도 있다고 한다!

그리고 fps를 20으로 지정해뒀는데, 이건 원하는 fps 값에 따라 적절히 바꿔주면 된다

import cv2
import re
import os
import numpy as np

path = '이미지들(프레임들)이 모여있는 폴더 경로'

# 파일 가져오기
def get_files(path):
    for root, subdirs, files in os.walk(path):
       
        list_files = []

        if len(files) > 0:
            for f in files:
                fullpath = root + '/' + f
                list_files.append(fullpath)

    return list_files


image_files = get_files(path)

### 정렬하기
store1 = []
store2 = [] # 정렬한 프레임들을 담을 배열
store3 =[]
for i in image_files :
    if len(i) == 10: # ex) frame0.jpg
        store1.append(i)
    elif len(i) == 11 : # ex) frame10.jpg
        store2.append(i)
    elif len(i) == 12 : # ex) frame100.jpg
        store3.append(i)

paths = list(np.sort(store1)) + list(np.sort(store2)) + list(np.sort(store3))
### 정렬 끝

pathOut = '동영상 파일 이름.mp4'
fps = 20

frame_array = []

for idx in range('이미지 개수') : 
    img = cv2.imread(paths[idx])
    height, width, layers = img.shape
    size = (width,height)
    frame_array.append(img)
    
out = cv2.VideoWriter(pathOut,cv2.VideoWriter_fourcc(*'MPEG'), fps, size)
for i in range(len(frame_array)):
    # writing to a image array
    out.write(frame_array[i])
out.release()

[Pytorch] custom dataset의 mean, std 구하기

beomseok99 — Tue, 23 May 2023 15:28:12 +0900

import numpy as np
import matplotlib.pyplot as plt
from pycocotools.coco import COCO
import torch
from torchvision import datasets
from tqdm.notebook import tqdm

def image_stats(data):
    total_images = len(data)
    total_pixels = 0
    pixel_sum = np.zeros(3)
    pixel_squared_sum = np.zeros(3)

    for i in range(total_images):
        # 이미지 데이터를 numpy 객체로 변환하고 정규화(0~1)
        img, _ = data[i]
        img_np = np.asarray(img) / 255.0
        total_pixels += img_np.size // img_np.shape[-1]

        # 픽셀값의 합과 제곱의 합을 계산
        pixel_sum += np.sum(img_np, axis=(0, 1))
        pixel_squared_sum += np.sum(np.square(img_np), axis=(0, 1))

    # 평균과 표준편차 계산 및 반환
    mean = pixel_sum / total_pixels
    std = np.sqrt(pixel_squared_sum / total_pixels - np.square(mean))
    return mean, std
    
    
train_data = datasets.CocoDetection('train데이터셋의 위치', 'instances_train.json파일의 위치')
#test_data = datasets.CocoDetection('test데이터셋의 위치', 'instances_test.json파일의 위치')

mean, std = image_stats(train_data)
print("Mean:", mean)
print("Std:", std)

EfficientDet ： Scalable and Efficient Object Detection Review (2020) 논문 리뷰

beomseok99 — Mon, 22 May 2023 18:23:02 +0900

EfficientNet의 후속작인 EfficientDet에 대해 리뷰하겠습니다. 혹시 EfficientNet을 읽어보지 않으셨거나, 기억이 안나시면 제 블로그에 있으니 찾아보시는 걸 추천 드립니다.

0.Abstact

- SOTA detectors become too expensive

- model efficiency becomes more important

- both accuracy and efficiency

논문의 저자들은 SOTA 모델이 너무 비싸다, 모델의 efficiency 역시 중요하다. 정확도와 효율성 모두 잡은 모델은 없을까 고민하다가

EfficientDet을 고안해냈다.

1. Introduction

- Question : Is it possible to build a detection architecture with both higher accuracy and better efficiency across a wide spectrum of resource constraints?

앞서 말한 것처럼, 한정된 자원에서 높은 정확도와 효율성을 모두 잡을 모델을 만드는 것은 불가능할까?

- Two Challenges

1. Efficient multi-scale feature fusion

= 보통 CNN은 width와 height가 줄어들면서 feature의 abstraction level이 올라간다. 다양한 level의 feature를 섞어서 operation 후 연산하는 구조가 기존에 많이 있었다. (예를 들어 FPN, PANet, NAS-FPN 등등)

기존에는 다양한 scale의 feature map을 사이즈만 맞춰준 뒤, sum 연산을 진행하였는데, sum만으로는 부족하다고 논문의 저자들은 생각하였다.

2. Model Scaling

= 보통 작은 모델에서 점점 큰 모델로 키워나가는 방식인데, EfficientNet에서 했던 것처럼 compound scaling을 진행 하였다. (resolution, depth, width 세가지를 적절히 scaling하는 방식)

=> EfficientNet backbone + BiFPN + Compound scaling == EfficientDet

2. Related work

- One stage detector

- Multi-Scale Feature Representations

- Model Scaling

EfficientDet은 one-stage detector이고, BiFPN 방식을 적용했으며, 새로운 compound scaling 방식을 적용했다.

3. BiFPN

3-1. Problem Formulation

feature pyramid 구조에서 사용할 feature map을 Pin 벡터로 정의, Pin 벡터들을 넣었을 때 좋은 feature map output이 나오도록 하는 transformation 함수 f를 찾는 것이 목표이다. (goal : find a transformation f )

Pin 벡터들은 level 3~ 7의 feature level을 가지는데, 각각 resolution이 input image의 1/2^i 이다. 예를 들어, input image가 640x640일 때, Pin level3의 resolution은 640 / 2^3 = 80x80이다.

위 그림은 다음과 같은 수식으로 연산된다

3-2. Cross-Scale Connections

- PANet(Pyramid Aggregation Net) adds an extra bottom-up path

- NAS-FPN employs NN search to search for better cross-scale feature network topology

PANet은 FPN 구조에 bottom-up path를 추가하였다.

NAS_FPN은 neural network가 스스로 FPN 구조를 찾도록 만든 것이다. 그러나 엄청난 GPU 시간을 필요로 하고, 그 구조가 매우 어렵고 불규칙적이다.

PANet을 좀 더 알아보자면,

앞서 말했듯, PANet은 FPN 구조에 bottom-up path를 추가한 구조이다.

왜? 입력 이미지와 가까운 feature map에서 작은 물체를 탐지한다. 그런데 abstraction level이 낮아서 성능이 좋지 못하다.

그래서 FPN 구조에서는 top-down 방식을 통해 abstraction level이 높은 feature map과 합쳐지면 괜찮을거라 생각하였다.

PANet 저자들은 입력이미지와 가까운 feature map의 장점(위치 정보를 많이 가지고 있음)을 살리고 싶어, 위치 정보를 약 10 layer의 bottom-up 구조로 올렸고, 실제로 꽤 괜찮은 성능을 보였다고 한다.

NAS-FPN에 대해 좀 더 알아보자면, 구조는 다음과 같다.

다시 돌아와서,

- PANet achieves better accuracy then FPN, NAS-FPN but, use Simplified PANet (removing those nodes that only

have one input edges with no feature fusion) and, adding extra edge from original input to output if they are at the same level

PANet이 FPN이나, NAS FPN보다 성능이 더 좋아서 이 방식을 채택했는데, 약간 간소화된 PANet 구조를 사용했다.

simplified PANet에서 알 수 있듯, fusion이 없는 node들을 지웠는데 왜 그랬냐면 fusion이 없다면 그냥 conv 연산 또는 아무 연산이 일어나지 않는다. 결국 fusion을 하는 node가 아니면, FPN 구조에서 역할이 없을 것이라 판단하여 삭제하였다고 한다.

결국엔 simplified PANet에서 edge가 더 추가된 BiFPN 구조를 사용하였다.

BiFPN에서는 추가적인 엣지를 하나 더 사용했는데, 이유는 더 많은 fusion을 할수록 성능이 좋아지니까 input node를 가져다 사용한 것이라고 한다.

=> 더 많은 feature를 fusion할 수 있게 되어 성능이 더 향상되었다.

- repeat the same layer

또한, 점선 박스로 된 구조를 3개 정도 이어서 사용하였다.

BiFPN의 수식은 다음과 같다.

3-3. Weighted Feature Fusion

1. Unbounded fusion

: just weight * layer

2. Softmax-Based Fusion

: apply to softmax to weighted sum, but, leads to slowdown GPU

3. Fast Normalized Fusion

: weight / (sum all weights + epsilon), 분자 Wi는 ReLU func에 의해 >=0 임을 보장받는다.

실제로 논문의 저자들은 3번 방법을 사용했다고 한다. 2번 방법과 성능차이가 없는데, 30%가량 빨라서 사용했다고 한다.

4. Architecture

1. Architecture

- pre-trained EfficientNet

- weights are shared (=> BiFPN에서 Class/box pred layer로 넘어갈 때 보이는 점선들은 실제 어떤 layer가 존재하는 것이 아니라, 가중치들이 전부 공유되기 때문에 다음과 같이 표현한 것이다.)

2. Compound Scaling

compound scaling에 관한 내용은 EfficientNet 참조!

- backbone, BiFPN, class/box network, resolution에 모두 compound scaling 을 진행

- heuristic scaling 진행( 논문의 저자들은 scaling할게 너무 많아서 어쩔 수 없이 휴리스틱한 방법을 이용했다고 함)

backbone : same EfficientNet

BiFPN : Width = 64 * 1.35^Φ, Depth = 2 + Φ

class/box prediction : Width = 64 * 1.35^Φ,

Depth box/class = 3 + int(Φ/3)

resolution : 512 + Φ * 128 (because level 7, ½^7)

수식은 다음과 같다.

연산량은 layer수에 비례 + 채널의 제곱에 비례 + resolution의 제곱에 비례하기 때문에 다음과 같은 수식이 도출된다.

결국, 전체 연산량은 2^Φ 에 비례한다.

5. Experiment

D0 ~ D7은 백본, 인풋 사이즈, scaling의 차이이다.

Ratio를 보면 1x가 기준이고, 예를 들어 yolo v3의 FLOPS는 28x인데 이는 EfficientDet-D0의 연산량이 1/28 이라는 의미이다.

[LeetCode] 416. Partition Equal Subset Sum

beomseok99 — Wed, 17 May 2023 23:23:10 +0900

처음으로 릿코드 문제를 풀어보았다.

어떤 정수 배열이 주어졌을 때, 이 배열을 '합이 동일한 2개의 부분 집합으로 나눌 수 있는지' 를 판단하는 문제였다.

dp를 이용해 풀었다. 아래 알고리즘은 직접 손으로 따라가며 풀면 금방 이해할 수 있을만한 코드이다.

TIP! 배열의 합이 22일 때, 배열에 속한 몇가지의 수를 선택해 배열의 합의 절반인 11을 만들 수 있으면 자연스레 선택받지 못한 나머지 수들의 합도 11이 된다. (배열의 합이 짝수인 경우만 2개의 부분 집합으로 나눌 수 있기 때문!)

혹시 이런 문제가 백준에도 있다면 댓글 남겨주세요,,

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        total = sum(nums)

        if total % 2 != 0: return False
        
        total //= 2

        dp = [0] * 20001
        dp[0] = 1
        
        for num in nums:
            idx = total
            while idx-num >= 0 :
                if dp[idx] or dp[idx-num]:
                    dp[idx] = 1
                idx -= 1

            if dp[total]: return True

        return False

EfficientNet : Rethinking Model Scaling for Convolutional Neural Networks 논문 리뷰

beomseok99 — Fri, 12 May 2023 12:11:19 +0900

-1. Before start

모델의 크기를 크게 만드는 3가지 방법

1. depth 증가

2. width 증가 (= filter 개수 증가)

3. 고해상도 이미지 사용

기존에는 3가지 방법을 수동으로 조절하였기에, 최적을 찾지 못하였다.

EfficientNet은 이 3가지의 최적의 조합을 AutoML을 통해 찾아내고, 수식으로 만든 논문이다.

조합을 효율적으로 만들 수 있도록 하는 compound scaling 방법을 제안하며, NAS 구조 수정을 통해 더 작은 크기의 모델로도 SOTA를 달성한 논문이다.

일반적으로 모델을 scaling하는 방법이란, b,c,d방법을 적절히 조절하는 것을 의미한다.

0.Abstract

- 한정된 자원으로 최대의 효율

- compound coefficient 방법

- 더 작으면서 더 빠르고 더 정확

기존 convnet보다 8.4배 작으면서 6.1배 빠르고 더 높은 정확도, compound coefficient 라는 scaling 방법을 제안한다.

1.Introduction

이 논문의 저자들은, 논문의 작성배경을 다음과 같이 말한다.

“ConvNet의 크기를 키우는 것은 널리 쓰이는 방법. 그러나 제대로 된 이해를 바탕으로 이루어지지는 않았던 것 같음. 그래서 scaling하는 방법을 다시 한 번 생각해보고 연구하는 논문을 제안. 그 방법이 compound scaling method.”

2.Related Work

- ConvNet Accuracy : 깊어지고 커질수록 정확도가 상승되는 경향, 그러나 자원 사용률 증가

- ConvNet Efficiency : 깊은 Network는 가끔 over-parameterized 됨. 효율을 높이기 위해 모델을 압축하는 여러 기법이 제안됨 ex) MobileNet

- Model Scaling : 많은 연구가 진행되었으나, 효율적인 조합을 찾는 것은 정립되지 않음

Over-parameterization은 필요한 갯수보다 더 많은 parameter가 있다는 뜻, 이는 over-fitting을 유발하기 쉽다

3.Compound Model Scaling

1. Problem Formulation

위 그림에서 입력값은 각 레이어 함수 f를 거쳐 최종 출력값을 생성하는데, 이를 수식으로 표현하면 아래의 식과 같다.

이를 일반화한 것이 아래 식인데, ConvNet을 수식화해 정리한 것이다.

H,W,C를 입력의 크기, F를 conv layer라고 하면 아래와 같이 표현할 수 있다.

자원이 제한된 상태에서 정확도를 최대화하는 문제를 풀고자 하기 때문에, 이를 수식으로 정리하면 다음과 같다.

레이어 함수 f를 고정하고, 레이어 수 d, 채널 수 w, 입력 이미지 크기 r에만 집중하면 다음과 같은 수식이 된다.

이 w,d,r 간의 관계를 연구한 것이 EfficientNet 이다.

2. scaling Dimensions

w(너비), d(깊이), r(입력 해상도)에 따른 정확도 값이다. 그림을 보면 w, d, r이 일정 값 이상이 되면 정확도가 빠르게 포화한다.

그리고, w, d, r이 낮을 때는 약간만 값을 조절해도 효과가 dramatic한 것을 확인할 수 있다.

그러나, 공통적으로, 어느 정도 이상 증가하면 모델의 크기가 커짐에 따라 얻는 정확도 증가량이 매우 적어지는 것을 알 수 있다.

3. Compound Scaling

=> w,d,r 값을 따로 조절하는 것이 아닌 함께 조절하여 최적의 효율을 찾아내는 것!

α,β,γ는 수식2와 3에 기반해 grid search로 결정되는 상수이다. 그리고, ϕ는 주어진 연산량에 따라 사용자가 결정하는 상수이다.

compound scaling 과정

STEP 1: ϕ=1로 고정 후, α,β,γ에 대해서 grid search를 수행 (

(grid search란, 해당 범위 및 step의 모든 경우의 수를 탐색하는 하이퍼파라미터 탐색 알고리즘)

(논문에서 찾은 값은 α=1.2,β=1.1,γ=1.15)

STEP 2: 이제 α,β,γ를 고정하고 ϕ를 변화시키면서 전체적인 크기를 키움 (B0~B7)

직관적으로, 더 높은 해상도의 이미지에 대해서는 네트워크를 깊게 만들어서 더 넓은 영역에 걸쳐 있는 feature(by larger receptive fields)를 더 잘 잡아낼 수 있도록 하는 것이 유리하다.

또, 더 큰 이미지일수록 세부적인 내용도 많이 담고 있어서, 이를 잘 잡아내기 위해서는 layer의 width를 증가시킬 필요가 있다.

FLOPs(초당 부동소수점 연산)는 너비와 해상도에 따라 제곱배가 상승한다. 너비를 2배 키우면 FLOPs는 4배가 증가하는 것.

따라서 FLOPs는 (α⋅β^2⋅γ^2)^2 배 만큼 증가합니다.

논문에서는 α⋅β^2⋅γ^2≈2로 제한하는데, 제한된 범위에서 α,β,γ를 찾는 것이다. 총 FLOPs는 2^ϕ 만큼 증가합니다.

4.Architecture

MBConv는 MnasNet에서 사용하는 Conv 구조이다.

5. Experiment

위 사진은 각 scaling 방법을 사용했을 때, 이미지의 어디에 집중하는지를 보여준다 (attention 사용은 x)

compound scaling이 좀 더 좋은 것을 알 수 있다.

[백준/파이썬] 17144번 미세먼지 안녕!

beomseok99 — Thu, 4 May 2023 02:36:35 +0900

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

17144번: 미세먼지 안녕!

미세먼지를 제거하기 위해 구사과는 공기청정기를 설치하려고 한다. 공기청정기의 성능을 테스트하기 위해 구사과는 집을 크기가 R×C인 격자판으로 나타냈고, 1×1 크기의 칸으로 나눴다. 구사

www.acmicpc.net

진짜 순수 구현문제다.. 방향벡터를 이용해야하는 정도?만 제외하면..

오랜만에 푸는 문제라 많이 어지러웠지만, 그래도 풀었다..!

문제의 해결방법은 다음과 같다

1. 미세먼지가 확산한다.

2. 공기청정기가 작동한다.

3. 위 과정을 T번 반복한다.

사실 2번은 정말 노가다..라고 할 수 있다. 그냥 값들을 앞으로 옮기기만 하면 되는데, for문이든 while문이든 취향껏 골라서 풀면 된다.

이제 보니 while문써서 인덱스 하나(행 또는 열 값)만을 가지고 푸는 방법이 더 깔끔할 것 같긴 하다.

1번이 살짝 어려울 수 있는데, 어려운 이유는 아마 다음과 같을 것 이다.

미세먼지가 확산을 하는데, 근처 칸에다가 확산된 값을 더해주면 원래 있던 값이 훼손된다 !!

이를 방지하기 위해, 임의의 배열을 하나 만들어서 여기에는 확산된 먼지를 적어주고, tmp에는 확산된 미세먼지의 총량을 기록해주어서

확산이 되고난 후, 확산의 기준점에 tmp 값을 빼줘서 수식을 만족시켜준다. 그리고 마지막으로 원래 배열과 임의의 배열끼리 더해서 확산을 마무리한다!

이 같은 방식이 가능한 이유는, 미세먼지 확산 시에 원래 있던 미세먼지 총량이 커지거나 작아지지 않기 때문이다! (숫자 계산해보면 알게 되실 겁니다)

import sys
from collections import deque
#sys.setrecursionlimit(10**6)
input = sys.stdin.readline

dx = [0,1,0,-1]
dy = [1,0,-1,0]

def clean():
    for i in range(first[0]-1,-1,-1): # ㅜ
        if board[i+1][0] == -1: board[i][0]=0
        else : board[i+1][0] = board[i][0]
        
    for i in range(1,c): # ㅓ
        board[0][i-1] = board[0][i]
    
    for i in range(1,first[0]+1): #ㅗ
        board[i-1][c-1] = board[i][c-1]
        
    for i in range(c-1,0,-1): # ㅏ
        if board[first[0]][i-1] == -1 : board[first[0]][i]=0
        else :board[first[0]][i] = board[first[0]][i-1]
    #------
    
    for i in range(second[0]+1,r): #ㅗ
        if board[i-1][0] == -1: board[i][0]=0
        else : board[i-1][0] = board[i][0]
        
    for i in range(1,c): #ㅓ
        board[r-1][i-1] = board[r-1][i]
    
    for i in range(r-1,second[0],-1): #ㅜ
        board[i][c-1] = board[i-1][c-1]
        
    for i in range(c-1,0,-1): #ㅏ
        if board[second[0]][i-1] == -1 : board[second[0]][i]=0
        else : board[second[0]][i] = board[second[0]][i-1]

def bfs():
    for _ in range(t):
        tmp_arr = [[0] * c for _ in range(r)]
        for x in range(r):
            for y in range(c):
                if board[x][y] > 0:
                    tmp = 0
                    for i in range(4):
                        nx = x + dx[i]
                        ny = y + dy[i]
                    
                        if nx <0 or ny <0 or nx >= r or ny >= c:
                            continue
                        if board[nx][ny] == -1: continue
                        
                        tmp_arr[nx][ny] += board[x][y] // 5
                        tmp += board[x][y] // 5
                    board[x][y] -= tmp
                    
        for i in range(r):
            for j in range(c):
                board[i][j] += tmp_arr[i][j]    
        
        clean()
        
    sum = 0
    for row in board:
        for data in row:
            if data != -1:
                sum += data
    return sum

if __name__ == "__main__":
    r,c,t = map(int,input().split())
    board = [[0]*c for _ in range(r)]

    first = [0,0]
    second = [0,0]
    
    for i in range(r):
        board[i] = list(map(int,input().split()))
        for j in range(len(board[i])):
            if board[i][j] == -1:
                if first==[0,0]:
                    first = [i,j]
                else: second = [i,j]
            
    print(bfs())

Deformable DETR : Deformable Transformers for End-to-End Object Detection 논문 리뷰

beomseok99 — Tue, 2 May 2023 02:05:49 +0900

Introduction

- DETR의 후속작이다.

- 느린 수렴(Convergence)과 작은 물체에 대한 낮은 성능에 대한 대안

- multi scale feature 사용

- deformable attention module 사용

Attention weight가 uniform하게 초기화되고 나서, 의미있는 위치에 focus 시키기 위해 학습하는 시간이 매우 길다.

(uniform이란, 평균이 0이고 분산이 1인 분포)

ex) key가 160개라면, 1/160으로 시작해서 gradient도 매우 작은 상태, query가 주어졌을 때 key는 이미지의 다른 모든 pixel이 되기 때문에 학습이 오래 걸림

작은 객체를 detection은 주로 high resolution feature map에서 이뤄지는데, Encoder는 feature size의 제곱에 비례한 시간복잡도를 가지기 때문에, high resolution image를 감당할 수 없음-> 작은 물체 탐지 성능 저하

또한 resnet(backbone)에서 나온 마지막 feature map을 사용하는데, 이는 low resolution 이미지이므로 작은 물체에 대한 탐지 능력이 부족함

deformable convolution에서 영감을 받아왔다고 한다.

Related Work

- Efficient Attention Mechanism

- Multi-scale Feature Representation for Object Detection

위 두 가지 방법을 참고했다고 한다.

특히 Deformable DETR은 Deformable Conv Network (DCN)으로부터 영감을 얻었다.

일반적인 Convolution 연산은 고정된 크기의 kernel을 기반으로 수행되지만 deformable convolution은 feature를 특정 layer에 통과시켜 Sampling point를 예측한 후, 해당 point를 기반으로 convolution 연산을 수행한다.

특정 위치의 object들에 맞추어 sampling이 이루어지면서 고정된 크기의 kernel로부터 오는 한계점을 극복할 수 있다.

=> 큰 물체에 대한 탐지 능력 향상

Loss는 DETR과 동일하다.

Revisiting Transformer and DETR

1. Multi head attention

=> query, key 쌍의 attention 정도 = attention weight

MHA는 attention weight를 각각의 key와 융합하는 것을 의미한다. 이는 다양한 관점에서 상관관계를 보기 위함이라고 한다.

(query : 질문용 단어)

(key : 문장 안의 모든 단어, query를 key의 모든 단어에 모두 질문하는 방식)

2. DETR

- Encoder’s MHA : q,k 모두 feature map의 pixel

- Decoder’s MHA : cross-attention

- Loss : 동일

CNN의 backbone(=ResNet)에서 추출한 feature map을 encoder의 input으로 사용

cross-attention이란, MHA와 deformable attention 둘 다 연산하는 것

Deformable Attention - Encoder,Decoder

1. Encoder

multi head deformable attention

reference point란, feature안의 어떠한 한 기준점에서 offset을 얼마나 설정해서 attention을 해야 하는지를 결정하는 기준점이다.

encoder의 경우, reference point가 input query(=feature map의 모든 pixel)와 동일하다.

input feature map x의 특정 쿼리의 위치에서 독립적인 linear layer를 거친 후,

query feature을 또 다른 linear layer를 통과시켜 sampling offset을 얻고,

위 두 방법의 결과물을 통해 sampling points들을 얻는다.

그 후, sampling points들을 통해 feature들을 뽑게 된다(그림에서 세로 블럭들)

그리고 query feature를 또 다른 linear layer에 통과시켜 얻은 attention weight와 feature를 aggregate하여 value를 얻는다.

detr의 경우, 한 위치에서 모든 픽셀에 대해 attention 연산을 수행하는 반면,

deformable detr은 한 위치에서 sampling points들에 대해서만 attention 연산을 수행함. 또한 하나의 scale이 아닌, 다른 모든 scale에서의 pixel에 대해서도 attention 연산 수행하므로 속도와 여러 크기의 물체에 대해 이득!(이 때 좌표를 0-1 사이 값으로 normalize)

2. Decoder

decoder의 경우, self attention부분과 cross attention하는 부분이 존재한다.

self attention은 decoder의 input인 object queries들을 multi head attention하는 부분이고 (기존 DETR과 동일)

cross attention은 object queries들을 linear layer에 통과시켜 reference points들을 추출하고, 각 reference point에서 sampling points를 뽑아 인코더와 동일한 방식으로 value를 계산하는 부분이다.

Method

1. Deformable Attention Module

annotation

2. Multi scale Deformable Attention Module

multi-scale의 feature map을 이용하는 것 이외에 큰 차이는 없다. 다만, 앞서 reference point 좌표값을 0-1 사이로 normalize 했기에 이를 해당 feature map에 맞게 rescale해주는 부분이 존재한다.

3. Deformable Transformer Encoder

- Input : multi-scale feature map, 1x1 conv 연산을 통해 동일한 차원으로 변환된다.

= input과 output은 동일한 resolution을 가지게 된다!

그리고 위에서 언급되었던 multi-scale deformable attention module을 통해 진행함

- 기존 Transformer Encoder의 Attention 방식을 multi-scale deformable attention module로 변환

4. Deformable Transformer Decoder

- cross-attention, self-attention module로 구성, self attention은 기존의 MHA를 그대로 사용하지만 cross-attention은 multi-scale deformable attention module을 사용한다

Experiments

DETR보다 성능, 시간적인 면에서 향상됨을 확인할 수 있다.

효율적이고 빠르게 수렴하는 end-to-end object detector이다.

multi-scale feature map을 이용해서 작은 물체 검출에도 유용하다.

Visualization

encoder output 시각화

decoder output 시각화

[프로그래머스/python] Level 2 : 이모티콘 할인 행사

beomseok99 — Fri, 28 Apr 2023 00:14:55 +0900

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

프로그래머스

programmers.co.kr

문제 독해 능력이 중요한 구현 문제이다 ㅋㅋ

읽어보면 알겠지만, 모든 가능한 할인율의 경우의 수를 전부 대입하여 풀어봐야한다. 즉 브루트 포스 + 백트래킹 구현 문제 정도로 생각할 수 있다.

문제 풀이는 다음과 같다.

1. 필요한 변수들을 선언해주고 dfs를 시작한다

2. 할인율의 경우의 수를 기록하는 배열을 sale_board라 할 때, 이 배열이 다 채워지면 cal() 함수를 호출해서 각 경우의 최대 이모플 가입자와 구매 가격을 계산한다

3. 계산된 값을 answer와 비교하여 더 큰 값을 넣어준다. 이 때 [이모플 가입자 수, 이모티콘 구입 금액]은 한 세트라는 걸 놓치지 말자!

tmi. 유저의 구매 기준과 할인율을 비교하는 if문에서 뭐에 홀렸었는지 부등호를 반대로 적었다ㅜ

이런 실수는 아무리 간단한 문제라도 쉽게 저지를 수 있고, 쉽게 찾지 못한다는 것이 큰 문제이다. 주의하자,,,

answer = [0,0]
def solution(users, emoticons):
    n = len(users)
    m = len(emoticons)
    sale_percent = [40,30,20,10]
    sale_board = [0] * m
    def dfs(idx):
        global answer
        
        def cal():
            cnt = 0; sale_money=0;
            for i in range(n): # 유저 별로
                money = 0
                for j in range(m): # 이모티콘 별
                    if users[i][0] <= sale_board[j]: # 만약 유저의 구매 기준이 할인율 보다 높다면
                        money += emoticons[j] * ((100-sale_board[j])/100) # 구매
                        if money >= users[i][1]: # 만약 구매 시, 비용을 초과한다면
                            cnt += 1 # 이모플 가입자 +1
                            money = 0
                            break
                sale_money += money

            return [cnt, sale_money]
        
        if idx == m:
            tmp = cal()
            if tmp[0] > answer[0] : answer = tmp
            elif tmp[0] == answer[0]:
                if tmp[1] > answer[1]:
                    answer = tmp   
            return

        for i in range(4):
            sale_board[idx] = sale_percent[i]
            dfs(idx+1)
    
    dfs(0)

    return answer

[백준/파이썬] 2877번 4와 7

beomseok99 — Wed, 26 Apr 2023 17:43:42 +0900

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

2877번: 4와 7

창영이는 4와 7로 이루어진 수를 좋아한다. 창영이가 좋아하는 수 중에 K번째 작은 수를 구해 출력하는 프로그램을 작성하시오.

www.acmicpc.net

기사 공부하랴, 텝스 하랴 소홀히 했던 알고리즘을 정말 오랜만에 다시 풀어보았다.

4와 7로 이루어진 수 중, n번째로 작은 수를 출력하는 문제다.

단번에 아이디어가 떠오르지 않는데, 분명 패턴이 있을 것 같아서 찾을 때 까지 수를 계속 적어보았다.

문제에서 알 수 있듯, 이 문제는 이진수(0과 1로 이루어진 수)를 활용해 푸는 문제이다!

패턴을 살펴보자.

정수 1 = 이진수 1 = 4

정수 2 = 이진수 10 = 7

정수 3 = 이진수 11 = 44

...

이런 식으로 가다보면 뭔가 보일락 말락 할 것이다. 그럼 이제 패턴을 다시 살펴보자. 여기서 괄호는 생략이다!

정수 1 = 이진수 (1) = x

정수 2 = 이진수 (1)0 = 4

정수 3 = 이진수 (1)1 = 7

정수 4 = 이진수(1)00 = 44

...

입력받은 정수에 1을 더해서 패턴을 이어 나간 것이다.

이제 다들 알 수 있을 것이다. 숫자 4를 이진수0으로 치환하고, 숫자 7을 이진수 1로 치환해서 풀면 된다.

import sys
#from collections import deque
#sys.setrecursionlimit(10**6)
from collections import Counter
input = sys.stdin.readline

if __name__ == "__main__":
    k = bin(int(input())+1)
    ans = ""

    for i in range(k.find('b')+2,len(k)):
        if k[i] == '0':
            ans += '4'
        elif k[i] == '1':
            ans += '7'
            
    print(ans)

Yolo v3 논문 리뷰

beomseok99 — Tue, 25 Apr 2023 23:14:35 +0900

이번 리뷰 논문은 Yolo v3입니다. 이미 워낙 유명한 Yolo 라서 그저 참고용으로만 봐주시길 바랍니다.

논문 시작에 앞서, IOU와 mAP에 대해 설명하겠습니다.

IOU & mAP

- IOU : 쉽게 말해서, 내가 예측한 박스가 정답 박스와 얼마나 유사한지를 측정하는 metric 입니다.

- mAP : 위 IOU를 평가하는 metric이 mAP 입니다.

Introduction

- Tech Report : 논문의 저자들은 v3는 논문이 아니라, Tech Report라고 합니다. 엄청 super interesting 한 것은 아니고, 작은 변화들을 모아 더 나은 모델로 발전시켰다고 합니다.

- Better, Not Faster, Stronger(?) : v2보다 모델이 무거워져서 더 빨라지진 않았으나 더 정확해졌다고 합니다.

Bounding Box prediction

- Yolo v2와 바뀐 부분 ? : 없다!

미리 anchor box를 정의해놓고 regression을 통해 얼마나 움직일 지 결정합니다.

수식

앵커 박스의 가운데 점의 좌표는 (Cx, Cy)이며, 이 때 x,y 방향으로의 이동은 sigmoid 함수를 적용해서 이동하게 됩니다.

sigmoid 는 0에서 1 사이의 값을 출력하기 때문에, bounding box의 중심은 아래 그림처럼 빨간 네모를 벗어나지 못합니다.

또한 박스의 width와 height는 원래 예측값 (Pw)과 박스가 움직여야하는 값(tw, th)의 지수 함수의 제곱을 통해 계산합니다

- loss : sum of squared error loss 사용

- objectness score (일종의 confidence) 가 각 바운딩 박스마다 존재합니다. (0에서 1 사이 값)

- 이 때, 다른 박스들보다 정답과 가아아아아장 유사한 박스는 objectness score가 반드시 1이 되어야 함!

- 각 ground truth마다 bounding box가 단 하나씩만 할당 됩니다. (다른 알고리즘들과의 큰 차이)

Class prediction

- 항상 detection 문제는 regression + classification을 동시에 해야하는 multi task 입니다.

- Yolo v3에서는 multi label classification을 수행합니다

multilabel classfication이란? 만약 클래스가 80개라면 (COCO 기준) 기존 classification은 80개의 클래스에 대해 softmax를 하는데, v3에서는 80개의 클래스에 sigmoid를 취해서 binary classifcation으로 바꿨다 함. 그래서 multi label classification이 가능하다고 합니다.

- 장점? Person, Women처럼 계층적인 데이터가 있는 경우, Person과 Women 클래스가 동시에 1이 되어야하는 경우가 필요합니다. 이 때 logistic regression 형태가 도움이 된다고 합니다!

Predictions Across Scales

- Anchor box ? 미리 pre-defined 된 bounding box

- 3 scale에 대해 3가지 bounding box를 사용하였습니다

=> 가로, 세로가 N x N 일 때 Prediction Feature Map의 크기는 N x N x Channel 입니다. (Channel 수는 255)

- 채널 수 = 3 x (4 + 1 + 80)입니다. 여기서 3은 한 scale에서 뽑는 bounding box의 수, 4는 x,y,w,h이고, 1은 objectness score, 80은 COCO dataset의 클래수 개수

Anchor Boxes

- Yolo만의 특성 : 가지고 있는 traing set을 분석하여 K-means clustering 통해 Bounding box의 priors를 정합니다.

ex) 보행자 탐지를 할 때, 사람은 서 있는 경우가 대부분이다. 바꿔 말해서 세로로 길쭉한 박스가 필요하지, 가로로 길쭉한 박스는 굳이 필요 없을 것이다.

- 즉, 찾고자 하는 객체에 대한 특징을 찾고, 분석하여 bounding box를 정하는 것이 앵커박스와 관련한 yolo의 특징입니다.

각각 작은 객체용, 중간 객체용, 큰 객체용

- 9개의 앵커박스를 사용합니다. 작은 객체용으로 3개, 중간 객체용으로 3개, 큰 객체용으로 3개해서 총 9개 입니다.

- v3는 416x416 이미지 기준, 10647개의 bounding box를 뽑아냅니다. 성능을 높이기 위해서는 어쩔 수 없는 과정인 것 같습니다.

Feature Extraction

- Yolo v3의 backbone : Darknet-53을 사용했습니다.

- v2보다는 느리고 연산량도 많지만 더 정확하고, ResNet 계열과는 정확도는 비슷한데 더 빠르고, 연산량도 적습니다. (약 2배 빠름)

특히, 초당 가능한 연산량이 제일 많아서 처리속도가 좋을 수 밖에 없는 것 같습니다.

Yolo v3 Architecture

- FPN과 형태가 비슷합니다.

- 맨 마지막 feature map(제일 작은 feature map)에서 conv 연산을 몇번 더 거쳐, 제일 큰 물체를 위한 3개의 앵커박스를 이용해 제일 큰 물체를 탐지합니다. (그림 기준 가장 작은 강아지 사진 부분)

- 그 후, 다시 피쳐맵의 사이즈를 키우고, 그 크기에 맞는 다른 피쳐맵을 가져와서 연산을 하고 객체를 뽑아냅니다. 쉽게 말해서 FPN 구조를 활용했다고 생각하시면 될 것 같습니다.

- 그래서 3 scale이 의미하는 것이, 위 구조에서 3개의 feature map을 통해 나온 3개의 이미지를 뜻한다고 보시면 될 것 같습니다.

- resoltion이 제일 큰 scale에서 제일 작은 객체를 찾고, resolution이 제일 작은 scale에서 제일 큰 객체를 찾습니다.

Training

- 특이한 점? : full image 전체를 사용, no hard negative mining

- hard negative mining이란 ? 보통 Detection을 할 때 bounding box를 뽑으면 수천 개를 뽑게 되고, 그 안에 물체가 있는 박스가 평균 수십 개 있다고 가정하면 나머지 박스들 즉, 물체를 포함하지 않는 박스들은 어떻게 할까요? 다른 모델에서는 background class가 존재하고, 그에 따라 background 객체 수만 엄청 증가하여 불균형해지게 됩니다. 이를 방지하는 것이 hard negative mining입니다.

하지만 Yolo는 background class가 없습니다. 그건 바로 objectness score를 통해 물체가 없다고 판단되면 날려버리기 때문입니다.

그래서 Yolo는 hard negative mining이 필요 없습니다.

- multi-scale training (이미지를 다양한 resolution으로 집어넣기), lots of data augmentation, BN 등등을 적용했다고 합니다.

Result

- v3의 저자는 AP 방식에 대해 불만이 있다고 합니다.. (threshold를 0.5부터 시작해서 0.05씩 늘려나가며 성능을 측정하고 그것들을 averaging 하는 방식)

- 다만, AP50 (IOU threshold가 0.5) 에서는 준수한 성능을 보입니다.

- 또한 작은 객체는 다른 모델들도 잘 탐지하지 못하는데, 의외로 v3가 큰 물체에 대해서 다른 모델들보다 성능이 낮음을 볼 수 있습니다.

이것도 역시 mAP50 기준

2023 정처기 실기 1회 후기

beomseok99 — Tue, 25 Apr 2023 20:51:12 +0900

4/23 일요일에 수원 동남보건대에서 시험을 보고왔다

생각보다 사람이 엄청 몰리길래 놀랐는데, 정처기 말고도 소방설비기사 등등 다른 기사 시험도 같이 보는 것이었다.

게다가 한 강의실에 20명도 없었고 그 중 내 또래처럼 보이는 사람들은 죄다 정처기 수험생들이었다 ㅋㅋ

수제비 카페를 통해서 정보도 얻고, 자료도 얻고 했다. 생각보다 유익하니 밑져야 본전이라는 마인드로 다들 가입해보시는 걸 추천한다.

필기 정식 발표일부터 공부를 시작했는데, 사실 시험이 5월인줄 알고 있어서 그랬다.. 갑자기 시험이 4월 23일이라길래 그 날부터 부랴부랴 준비했다.

한 3주정도 공부했으며, 하루에 못해도 3시간 이상 ~ 10시간까지 했던 것 같다. 딱히 공부 시간을 재지 않으므로 의자에 앉은 시간과 공부를 끝낸 시간으로 유추해보면 그럴 것이다.

카페에 있는 데일리 문제, 2021~2023 예상족보, 2020~2022 기출, 수제비 기본서, 수제비 파이널 모의고사 이용해서 공부했다.

앞서 말한 것들 전부 2-3회독씩 했다.

다들 n수생도 많고, 시험이 어렵다길래 겁을 잔뜩 먹고 들어갔는데, 올해 실기 시험은 완전 물시험이었다.

약술형은 거의 사라지는 추세이고, 코딩과 sql이 합쳐서 10문제 가량 나온 시험이었다. 단답형도 보기를 주는 문제가 대부분이어서 미친듯이 달달 외울 필욘 없는 것 같다.

기억을 되살려 복원된 정답과 비교해보니, 단답형 한 문제 + sql 실수 + 보기 고르는 문제 해서 총 3문제 정도 틀린 것 같다.

단답형 문제의 답은 L2TP 였는데 이건 난생 처음 들어봤고,

sql 문제는 조건이 '이상' 이었는데 >만 적고 =을 빼먹어서 틀릴 예정이다.(내 기억으론 안적었지만 내 손이 몰래 적었길 바라며 ㅎㅎ)

ㄱ,ㄴ,ㄷ 고르는 문제는 아직도 말이 많다. 문제지마다 보기와 답 적는 순서가 모두 다르고, 내용도 굉장히 애매하고 지엽적이라 의견이 분분한 것 같다.

그래도 ㄱ,ㄴ,ㄷ 3개 중에 하나는 정확히 맞았으니 부분 점수 있지 않을까

그리고 답안 적을 때 고민을 많이 하시던데, '찾아 적으시오'는 답을 어떻게 쓰든 올바르게만 쓰면 된다.

다만, '기호를 적으시오'는 반드시 기호를 적어야 하므로 이것만 유의하시면 될 것 같다.

[네이버 1784 스쿨혁명] 대학생 멘토 수료 !

beomseok99 — Thu, 20 Apr 2023 15:17:29 +0900

로봇 사전 교육 듣고, 커리큘럼 준비해서 평택 서재초 아이들과 로봇 가지고 인공지능을 주제로 수업했던 것이 엊그제 같은데 벌써 수료증이 나왔다 ㅎㅎ

시간도 부족하고, 실수도 해서 아이들에게 더 많은 재미를 주지 못한게 아쉽지만 언젠가 또 기회가 있겠지,,

M1, M2 맥북에서 아나콘다 파이썬 3.6 또는 3.7 설치하기

beomseok99 — Mon, 17 Apr 2023 22:55:21 +0900

애플 실리콘 맥북에서는 아나콘다에서 파이썬 3.8 버전 밑으로는 설치가 안될 것이다.

그럴 땐 다음과 같은 방법을 이용하면 된다

## create empty environment
conda create -n py37

## activate
conda activate py37

## use x86_64 architecture channel(s)
conda config --env --set subdir osx-64

## install python, numpy, etc. (add more packages here...)
conda install python=3.7

https://stackoverflow.com/questions/70205633/cannot-install-python-3-7-on-osx-arm64

정처기 실기를 공부하면서 느낀 점

beomseok99 — Sun, 16 Apr 2023 03:44:03 +0900

혹자는 말한다.

개발자에게 정보처리기사 자격증은 필요없다고, 학점도 필요없다고, 알고리즘 실력과 짱짱한 포트폴리오와 함께라면 취업은 문제없다고.

문득 드는 생각인데, 과연 그게 옳은 방법일까 싶다.

기사 실기를 공부하면서 깨달은건데, 사람이 한번 공부한 내용은 그리 쉽게 잊혀지지 않는 것 같다.

물론 벼락치기로 가져간 단기 기억 말고 짧으면 몇 주에서 길면 몇 개월, 몇 년정도 공부한 것은 아주 약간의 불씨만 있으면 다시 살아난다.

그럼 학교에서 배우는 이산수학, 선형대수학, 확통, C, C++, 파이썬, 자바, 자료구조, OS, 네트워크, 컴파일러, 오픈소스, 소프트웨어 공학, 머신러닝, 딥러닝, 컴퓨터 비전, 웹, 데이터베이스, 알고리즘, 정보보안, 컴퓨터 구조, 시스템 프로그래밍 등등..

어느 분야나 그렇듯, 정말 특출난 사람을 제외하면 대부분은 평균에서 웃돌 것이다. 동일한 시간을 쏟았다고 가정했을 때..

내가 인사 또는 채용팀이라 생각해보면, 사실 이제 갓 학부 딱지를 뗀 24~26살 정도가 해봤자 얼마나 하겠는가? (특출난 사람 제외..ㅎㅎ)

만약 나라면, 평소 태도를 볼 것 같다. 이 사람이 평소에 좀 성실히 공부하고자, 배우고자 하는 태도가 있고 그 태도를 실행으로 옮길 만큼 의지가 있는 사람인지가 중요하지 않겠는가. 그럼 똑같은 일을 가르쳐주고, 시켜도 뭔가 다른 결과를 내봄직 하지 않을까

물론 나 혼자만의 생각이므로 이게 옳다 그르다 할 수 없다! 세상 사람 모두가 다 나랑 생각이 같으면 얼마나 좋을까 ㅋㅋ 하지만 절대 전혀 그럴 일 없기 때문에 흔히 유행이라 말하는 '메타'를 따라가는 것이지.

인생을 아주 길게 바라보았을 때, 비록 학부생이지만 이 4년동안 내가 쏟은 노력들이 언젠간 나에게 아주 소중한 선물이 되어 돌아오리라 믿는다.

그냥.. 그렇다고..

p.s. 어쩌면 그래서 내가 대학원에 가고싶은 것 일지도?