나의 개발일지

트랜스포머 모델의 개요 (Transformer)

YoonJuHan — Wed, 23 Oct 2024 16:21:45 +0900

트랜스포머 모델은 자연어처리 분야에서 상당히 중요한 모델로 자리잡고 있습니다. 머신러닝의 발전과 함께 이러한 트랜스포머 모델은 많은 주목을 받고 있으며, 그 구조와 학습 방식에 대해 깊이 이해하고 사용하는 것이 필수적입니다. 이번 포스트에서는 트랜스포머 모델의 기본 개념부터 시작하여, 아키텍처, 학습 과정, 응용 분야, 그리고 BERT와 GPT 모델의 차이까지 살펴보겠습니다.

트랜스포머 모델은 2017년 논문 "Attention is All You Need"에서 처음 소개되었습니다. 이 모델은 자연어 처리(NLP)에서 효과적인 성능을 보여주며, 특히 번역, 텍스트 생성, 질의 응답 등 다양한 작업에서 활용됩니다. 트랜스포머의 가장 큰 장점은 시퀀스 데이터를 처리하는 데 있어 RNN이나 LSTM보다 빠르고 효율적이라는 점입니다. 이러한 이유로 현재 많은 최신 모델들이 트랜스포머를 기반으로 하고 있습니다.

트랜스포머 아키텍처 이해하기

트랜스포머 모델은 크게 인코더(Encoder)와 디코더(Decoder)라는 두 가지 주요 구성 요소로 나뉩니다. 인코더는 입력 데이터의 정보를 추출하고, 디코더는 이 정보를 바탕으로 출력 데이터를 생성합니다. 트랜스포머의 핵심 원리는 '어텐션 메커니즘'으로, 입력 데이터의 각 단어가 서로 어떻게 관련되어 있는지를 계산합니다.

인코더는 여러 층으로 구성되어 있으며, 각 층은 멀티헤드 어텐션, 피드포워드 네트워크, 정규화 등의 과정을 포함합니다. 디코더 또한 유사한 구조를 가지고 있지만, 이전 단어를 예측하기 위해 마스킹된 어텐션을 사용합니다. 이 과정을 통해 모델은 문맥을 이해하고 다음 단어를 예측할 수 있게 됩니다.

트랜스포머 아키텍처의 구조는

이미지 출처

과 같이 시각적으로 표현될 수 있으며, 다양한 레이어와 셀프 어텐션 메커니즘이 어떻게 연결되는지를 보여줍니다. 또한,

이미지 출처

에서는 전체적인 흐름을 통해 인코더와 디코더 간의 정보 전달 과정을 시각적으로 잘 나타내고 있습니다.

트랜스포머 모델 학습 과정

트랜스포머 모델의 학습은 주어진 입력에 대해 정답 단어의 확률을 높이는 방향으로 진행됩니다. 입력 데이터와 출력 데이터 쌍을 활용하여, 모델은 잘못된 예측을 점차 수정하며 성능을 향상시킵니다. 이러한 학습 과정은

이미지 출처

에서 다양한 데이터 유형과 함께 수행되는 모습을 보여줍니다.

훈련 과정에서 모델은 여러가지 작업을 수행할 수 있으며, 질문 응답, 감정 분석, 정보 추출 등 다양한 작업들이 가능합니다. 트랜스포머는 이러한 다양한 작업에 적합하도록 설계되었기 때문에, 각 작업에 맞는 데이터 세트를 통해 지속적으로 학습하고 적응할 수 있습니다.

트랜스포머의 다양한 응용 분야

트랜스포머 모델은 자연어 처리 분야 외에도 컴퓨터 비전, 음성 인식 등의 다양한 분야에서도 사용됩니다. 예를 들어, 이미지 캡셔닝, 객체 인식 및 지시 사항 따르기와 같은 작업에서도 효과적으로 활용될 수 있습니다. 이러한 다양한 응용은 트랜스포머 모델의 유연성과 강력함을 잘 보여줍니다.

BERT와 GPT 모델 비교

트랜스포머 모델의 발전으로 두 가지 중요한 변형 모델인 BERT와 GPT가 등장했습니다. BERT는 양방향 인코더 사전 훈련 모델로, 입력 문장을 양 방향에서 이해하고 예측하는 데 강점이 있습니다. 반면, GPT는 주로 텍스트 생성에 특화되어 있으며, 기본적으로 단방향 어텐션을 사용합니다. 이 두 모델은

이미지 출처

에서 각각의 구조와 특징을 비교하여 보여줍니다.

BERT는 질문-응답 시스템과 같은 작업에 매우 효과적이며, GPT는 스토리 생성, 대화 생성 등의 작업에서 뛰어난 성능을 발휘합니다. 두 모델 모두 트랜스포머 아키텍처를 기반으로 하고 있지만, 각자의 특화된 학습 방식과 사용 용도가 다릅니다.

마무리 및 참고 자료

트랜스포머 모델은 다양한 자연어 처리 작업에서 필수적인 도구로 자리잡고 있습니다. 그 아키텍처와 학습 과정, 그리고 응용 분야까지 폭넓은 이해가 필요하며, BERT와 GPT와 같은 모델의 발전도 주목해야 합니다. 이러한 트랜스포머 모델의 이해는 앞으로의 데이터 과학과 AI 기술 발전에 중요한 역할을 할 것입니다.

더 많은 정보를 원하신다면, 다음의 자료들을 참고하시기 바랍니다:

이 포스트를 통해 트랜스포머 모델에 대한 깊은 이해가 도움이 되길 바랍니다.

[프로그래머스] Lv.2 디펜스 게임 [Python, 파이썬]

YoonJuHan — Thu, 25 Jul 2024 14:35:35 +0900

문제 : https://school.programmers.co.kr/learn/courses/30/lessons/142085
우선순위 큐 (hqepq)
- 먼저 무적권 횟수만큼 라운드를 클리어하고 큐에 적 정보를 저장한다. (heappush)
- 무적권을 다 사용했으면 클리어 한 라운드 중 가장 적이 적었던 라운드를 무적권이 아닌 병사로 처리한다. (heappop)
  - 병사로 처리했으므로 무적권을 다시 사용할 수 있음
- 위 방법으로 무적권을 효율적으로 사용해서 라운드를 최대한 클리어할 수 있다.

from heapq import heappush, heappop

def solution(n, k, enemy):
    answer = 0
    hq = []
    
    for i in range(len(enemy)):
        heappush(hq, enemy[i])
        
        if len(hq) <= k:    # 일단 무적권 모두 사용
            answer += 1
            continue
        
        # 다 사용했으면 무적권을 사용한 라운드 중 가장 적이 적은 라운드를 병사로 처리
        n -= heappop(hq)    
        
        if n < 0: break     # 처리 못하면 종료
        
        answer += 1         # 처리할 수 있으면 라운드 클리어
    
    return answer

[프로그래머스] Lv.2 가장 큰 정사각형 찾기 [Python, 파이썬]

YoonJuHan — Thu, 18 Jul 2024 14:00:16 +0900

문제 : https://school.programmers.co.kr/learn/courses/30/lessons/12905
다이나믹 프로그래밍 (DP)
- 점화식 : dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1
- board[i-1][j-1] == 1일 때 dp배열의 왼쪽, 위, 왼쪽 위 중 최솟값 + 1을 dp[i][j]에 기록한다.
- board리스트(위) dp리스트(밑) 결과

def solution(board):

    answer = 0
    dp = [[0] * (len(board[0]) + 1) for _ in range(len(board) + 1)]
    
    for i in range(1, len(board) + 1):
        for j in range(1, len(board[0]) + 1):
            if board[i-1][j-1] == 1:
                dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1
    
                if dp[i][j] > answer:
                    answer = dp[i][j]
                
    return answer ** 2

[프로그래머스] Lv.2 테이블 해시 함수 [Python, 파이썬]

YoonJuHan — Mon, 15 Jul 2024 15:27:53 +0900

문제 : https://school.programmers.co.kr/learn/courses/30/lessons/147354
정렬, 비트연산 XOR
- 먼저 이 문제에서 컬럼이나 튜플의 순서는 0이 아닌 1부터 시작한다.
- 2단계 정렬 : col 번째 값을 기준으로 오름차순, col 번째 값 동일하면 기본키 첫 번째 값 기준 내림차순 정렬
  - 음수 기준으로 정렬하면 내림차순 정렬 가능 → -x[0]
- 3단계 나머지들의 합 : 정렬된 리스트 순회하면서 row_begin ~ row_end까지 튜플에 대해 나머지 합 계산 후 리스트에 저장
- 4단계 저장된 나머지 합들 XOR 연산 : 나머지 합 저장된 리스트 순회하면서 모두 XOR 연산
  - answer ^= S[i]로 answer에 XOR 연산된 값 저장

def solution(data, col, row_begin, row_end):
    
    # 2단계
    data.sort(key=lambda x : (x[col-1], -x[0])) # col 번째 오름차순, 같으면 기본키 내림차순
    
    # 3단계
    S = []
    for i in range(row_begin-1, row_end):
        s = 0
        for j in data[i]:
            s += j % (i+1)
        S.append(s)
    
    # 4단계
    answer = S[0]
    for i in range(1, len(S)):
        answer ^= S[i]
    
    return answer

[프로그래머스] Lv.2 미로 탈출 [Python, 파이썬]

YoonJuHan — Thu, 23 May 2024 18:20:52 +0900

문제 : https://school.programmers.co.kr/learn/courses/30/lessons/159993
두 번의 BFS
- 시작 위치에서 레버까지 BFS
- 레버 위치에서 탈출 위치까지 BFS
- 하나의 BFS 함수에 레버 여부를 매개변수로 두고 레버를 찾는지, 탈출구를 찾는지 구분
- 레버를 못 찾거나, 탈출구를 못 찾으면 -1을 리턴

from collections import deque

def solution(maps):
    answer = 0
    
    def bfs(start, lever):
        visit = [[0] * len(maps[0]) for _ in range(len(maps))]
        dx, dy = [0, 0, 1, -1], [1, -1, 0, 0]
        q = deque([start])
        visit[start[0]][start[1]] = 1

        while q:
            x, y = q.popleft()

            for i in range(4):
                mx, my = x + dx[i], y + dy[i]
                
                if 0 <= mx < len(maps) and 0 <= my < len(maps[0]) and visit[mx][my] == 0 and maps[mx][my] != "X":
                    if not lever and maps[mx][my] == "L":   # 레버 찾기
                        return visit[x][y]
                    elif lever and maps[mx][my] == "E":     # 레버 찾은 후 출구 찾기
                        return visit[x][y]
                    else:                                   # 그냥 통로
                        q.append([mx, my])
                        visit[mx][my] = visit[x][y] + 1
        return -1
    
    # 시작 위치 찾기
    for i in range(len(maps)):
        for j in range(len(maps[0])):
            if maps[i][j] == "S":
                start = [i, j]
            elif maps[i][j] == "L":
                lever = [i, j]
                
    time_to_lever = bfs(start, False)   # 레버 찾기
    
    if time_to_lever == -1:
        return -1
    else:
        time_to_exit = bfs(lever, True) # 출구 찾기
        if time_to_exit == -1:
            return -1
        
    return time_to_lever + time_to_exit

[프로그래머스] Lv.3 섬 연결하기 [Python, 파이썬]

YoonJuHan — Fri, 19 Apr 2024 16:07:30 +0900

문제 : https://school.programmers.co.kr/learn/courses/30/lessons/42861
프림 알고리즘
- 출발 위치는 상관없음
- 현재 섬에서 갈 수 있는 섬들을 큐에 넣고 비용이 가장 적은 길을 뽑아내 섬을 연결하는 방식
- 큐를 힙으로 구현했기 때문에 항상 최소 비용의 길을 뽑아내서 이동함
- 최소 비용의 길을 뽑아서 갔으면 또 갈 필요가 없기 때문에 방문 리스트를 통해 못 가게 막음

from collections import defaultdict
from heapq import heappush, heappop

def solution(n, costs):
    answer = 0
    graph = defaultdict(list)
    
    for cost in costs:
        graph[cost[0]].append((cost[2], cost[1]))   # 섬1 : [(비용, 섬2)]
        graph[cost[1]].append((cost[2], cost[0]))
    
    visit = [False] * n
    q = [(0, 0)]
    
    while q:
        cost, node = heappop(q)
        
        if not visit[node]:
            visit[node] = True
            answer += cost
            
            for next_cost, next_node in graph[node]:
                heappush(q, (next_cost, next_node))
    
    return answer

[프로그래머스] Lv.2 무인도 여행 [Python, 파이썬]

YoonJuHan — Fri, 15 Mar 2024 20:02:57 +0900

문제 : https://school.programmers.co.kr/learn/courses/30/lessons/154540
BFS로 연결된 무인도를 탐색
- maps를 순회하면서 무인도를 만나면('X'가 아닌 부분) 현재 위치에서 BFS 탐색을 실시
- BFS를 시작하는 위치와 연결된 무인도들을 모두 탐색하면서 식량 개수를 카운트하고 'X'로 바꾼다.
- BFS 종료 시 식량 개수를 리턴
- 또 maps를 순회하면서 무인도를 찾고 BFS 탐색 반복

from collections import deque

def solution(maps):
    
    def bfs(x, y):
        mx, my = [0, 0, 1, -1], [1, -1, 0, 0]
        q = deque([(x, y)])
        food = int(maps[x][y])
        maps[x][y] = 'X'

        while q:
            x, y = q.popleft()

            for i in range(4):
                nx, ny = x + mx[i], y + my[i]

                if 0 <= nx < len(maps) and 0 <= ny < len(maps[0]) and maps[nx][ny] != 'X':
                    food += int(maps[nx][ny])
                    maps[nx][ny] = 'X'
                    q.append((nx, ny))

        return food

    answer = []
    
    for i in range(len(maps)):
        maps[i] = list(maps[i])
        
    for i in range(len(maps)):
        for j in range(len(maps[0])):
            if maps[i][j] != 'X':
                answer.append(bfs(i, j))
    
    return [-1] if answer == [] else sorted(answer)

[Kaggle] Spaceship Titanic

YoonJuHan — Wed, 13 Mar 2024 17:16:08 +0900

https://www.kaggle.com/code/yoonjuhan/spaceship-titanic/notebook

제출 결과 1 (Version name : RandomForest)

Model : RandomForest

[프로그래머스] Lv.3 베스트 앨범 [Python, 파이썬]

YoonJuHan — Fri, 23 Feb 2024 12:06:36 +0900

문제 : https://school.programmers.co.kr/learn/courses/30/lessons/42579
딕셔너리, 힙
- music 딕셔너리
  - "장르" : [(-재생 횟수, 고유 번호), (-재생 횟수, 고유 번호)]
  - value의 리스트는 힙이고 재생 횟수를 음수값으로 넣어 최대 힙 구현
- play 딕셔너리
  - "장르" : 총 재생 횟수
  - 앨범에 먼저 수록할 장르를 구하기 위한 딕셔너리
- play 딕셔너리를 총 재생 횟수 기준으로 정렬
- 1번 조건 : 노래가 많이 재생된 장르를 먼저 수록합니다.
  - 정렬한 play 리스트에서 pop()
- 2번 조건 : 장르 내에서 많이 재생된 노래를 먼저 수록합니다.
  - music["장르"]에서 heappop()
  - 장르 내에 속한 곡이 1개 일 때 처리를 try-except 문으로 처리

from collections import defaultdict
from heapq import heappop, heappush

def solution(genres, plays):
    answer = []
    
    music = defaultdict(list)
    play = defaultdict(int)

    for i in range(len(genres)):
        heappush(music[genres[i]], (-plays[i], i))
        play[genres[i]] += plays[i]
    
    play = sorted(list(play.items()), key=lambda x : x[1])
    
    for i in range(len(music)):
        genre = play.pop()[0]
        try:
            answer.append(heappop(music[genre])[1])
            answer.append(heappop(music[genre])[1])
        except:
            continue
        
    return answer

[백준] 1765 닭싸움 팀 정하기 [Python, 파이썬]

YoonJuHan — Wed, 17 Jan 2024 15:04:11 +0900

문제 : https://www.acmicpc.net/problem/1765
union, find
- 입력으로 친구가 들어오면 서로 union
- 원수가 들어오면 양방향 그래프로 원수 관계를 생성
- 생성된 원수 관계 그래프를 이용해 "내 원수의 원수도 내 친구이다." 조건을 해결한다.
  - 나 → 내 원수 → 내 원수의 원수
  - 이렇게 거쳐서 (나, 내 원수의 원수)를 union

from collections import defaultdict

n = int(input())
m = int(input())
    
def union(a, b):
    x = find(a)
    y = find(b)
    parent[y] = x

def find(x):
    if parent[x] == x:
        return x
    parent[x] = find(parent[x])
    return parent[x]

parent = [i for i in range(n+1)]
E = defaultdict(list)   # 원수 그래프

for i in range(m):
    relation = input().split()
    a, b = int(relation[1]), int(relation[2])

    if relation[0] == 'F':
        union(a, b)
    else:
        E[a].append(b)
        E[b].append(a)

for k in E:             # 나
    for i in E[k]:      # 나의 원수
        for j in E[i]:  # 나의 원수의 원수
            union(k, j) # (나, 나의 원수의 원수) union

answer = set()
for i in range(1, n+1):
    answer.add(find(parent[i]))

print(len(answer))