위와 같은 문제를 많이 접해봤을 것이다. 이번 글에서는 미루고 미뤘던 부동소수점에 대해서 다루어 보려고 한다.

컴퓨터의 수

대부분의 프로그래밍 언어에서는 수를 표현하기 위해 크게 두 가지 타입을 제공한다. 바로 정수 타입(int in python)과, 부동소수점 타입(float in python)이다.

정수도 실수에 포함이 되는데 왜 정수타입과 부동소수점 타입을 애써 나눠 놓은 것일까? 이유는 무척 간단하다. 부동소주점이 실수를 완벽하게 표한할 수 없기 때문이다. 정확하게 따지고 들어가면 정수조차도 제대로 표현하지 못한다고 한다. 즉, 정수를 가지고 계산을 할 때, 부동소수점 타입을 사용할 경우 정확한 결과를 얻을 수 없게 된다.

그리고 또 한 가지 이유는, 보통 부동소수점이 1보다 작은 소수를 표현하기 위해 도입된 개념이라는 인식을 많이들 가지고 있다. 아마도 이름 자체에 "소수점"이라는 표현이 들어가있기 때문일 것이다. 분명 그런 목적도 있긴 하지만 본래 목적의 일부분만을 나타낼 뿐이다. 부동소수점은 아주 작은 수와 아주 큰 수 양쪽을 모두! 표현하기 위해서 도입됐다.

고정소수점과 부동소수점

부동소수점은 부동이라는 말에서 알 수 있듯이 실수를 표현할 때 소수점의 위치를 고정하지 않는 것을 말한다. 그렇다면 왜 고정하지 않는 것일까. 만약 123.456를 표현한다고 할 때 고정소수점은 정수 부분 123과 456을 나눠서 표현해야 한다. 결국 한정된 비트에 정수와 소수 부분을 분할해 배치할 경우 고정소수점이 나타낼 수 있는 범위가 무척 한정된다.

그에 비하여 부동소수점에서는 123.456을 123456이라는 유효숫자와 3이라는 소수점 위치를 통해서 고정소수점보다 훨씬 넓은 범위의 수를 표현할 수 있다는 장점이 있다. 그래서 프로그래밍에서 실수를 표현할 때는 부동수서점을 주로 사용하게 된다. 이런 부동소수점은 계산기에서도 볼 수 있다. 계산기가 표현할 수 있는 한계(칸)을 넘어설 경우 e가 나오면서 지수 표기법이 나오는 것을 확인할 수 있다.(주로 공학용계산기에서 쉽게 확인할 수 있다.) 여기서 e가 바로 부동소수점, 즉 소수점의 위치를 표시하겠다는 의미다.(C++도 이런 방식을 이용하여 부동 소수점을 표현한다.)

❓123과 456을 저장하는게 왜 123456과 3을 저장하는 것보다 왜 넓은 범위의 수를 표현할 수 있다는건가요?
보통 한정된 비트안에서 각각의 부분을 할당하여 수를 표시하게됩니다. 그리고 위의 이미지는 고정소수점 방식에서 비트할당을 나타낸 것입니다. 정수를 표현하는 bit를 늘리면 큰 숫자는 표현할 수 있지만 소수부가 작아져서 그만큼 정밀한 숫자를 표현하기 힘들어집니다. 그 반대 역시 Trade-off관계이기 때문에 마찬가지입니다.
이와 달리 부동소수점 방식은 하나의 실수를 가수부와 지수부로 나누어 표현합니다. 이런 표현방식은 매우 큰 실수까지 표현할 수 있습니다. 따라서 현재 대부분의 시스템에서는 부동 소수점 방식으로 실수를 표현하고 있습니다. 부호 비트는 0일 경우 양수, 1일 때 음수를 나타냅니다. 만일 어떤 수를 이진법으로 나타내면 1001101.011001011 라고 가정해봅시다. 이러면 부호는 양수이기 때문에 0이 됩니다. 그리고 주어진 수를 맨 앞에 있는 1 바로 뒤로 소수점을 옮겨서 표현하도록 변환합니다. 그러면 1.001101011001011*2^6으로 표현됩니다. 이때 6을 이진법으로 나타내면 110이고 IEEE754 표현방식에서는 127을 더해서 지수를 기록하기 때문에 지수부분은 10000110이 되고, 가수부분이 001101011001011이 되는 것입니다.
이런 방식을 통하여 고정소수점보다 훨씬 넓은 범위의 수를 표현할 수 있게 됩니다. 하지만 이런 방식의 표현은 항상 오차가 존재한다는 단점을 가지고 있습니다.

2진법과 부동소수점

정수를 2진법으로 나타내는 것은 무척 간단하다. 그렇다면 소수부분은 어떻게 2진법으로 표현할까? 이는 초등학교에서 배운 방식의 반대로 생각하면 된다. 정수 부분을 2진수로 변환할 때는 2로 나눠서 나머지를 구했다면, 소수 부분의 경우 2를 곱해서 정수 부분을 취하면 된다. 만약 0.6875를 2진수로 변환한다면 절차는 다음 그림과 같다.

위의 그림에서는 0.0이 나와서 멈췄지만, 보통의 경우 대부분의 실수는 무한히 순환하면 반복된다. 즉, 적당한 개수의 유효숫자만을 취하게 되고, 여기서 앞 서 언급한 오차가 필히 발생하게 된다.

그리고 위의 그림에서도 볼 수 있듯이 32비트 방식에서 가수부는 23비트가 할당되기 때문에 만약 $2^{23}$보다 큰 실수의 소수점은 남지 못하고 삭제된다. 즉, 지수부의 지수가 23 이상일 경우에는 더 이상 소수점을 표현할 수 없다는 의미이다.

다시 처음으로..

그렇다면 이제 0.1 + 0.2 == 0.3이 왜 False인가에 대해서 대답하면 "파이썬의 Float는 부동소수점 방식으로 수를 저장하기 때문이다."라고 대답할 수 있다.

실제로 0.1과 0.2(두번째 사진, 소수점 30자리까지 표현)을 파이썬에서 저장하는 값은 위와 같다고 한다.그리고 0.3(소수점 30자리까지 표현)은 다음과 같은 값은 가진다.

❗️출처

1. 파이썬 0.1+0.2 not same as 0.3 사진출처
2. C++ 프로그래밍: 부동소수점 구조와 원리
3. 부동 소수점 수
4. 부동 소수점 산술: 문제점 및 한계

열심히 정리글을 작성했는데 아무리 글을 전체공개로 바꿔도 자동 비공개로 바뀌었다. 이런 현상이 궁금해서 공식 깃허브 Repo issue탭에서 검색해봤다.

나 말고도 이런 버그를 경험하신 분들이 많은 것 같다 대표적으로 ㅂㅏㄷㅜㄱㅇㅣ를 정상적으로 입력하면 비공개로 글이 자동으로 전환된다.

그냥 전체 글에 저런 단어가 들어가는 순간 글을 전체공개로 돌릴 수 없는 것이다. 아무래도 스팸관리 차원에서 글을 전체공개 못하도록 시스템이 구성되어 있는 것 같다.

우선, 이런 경험을 겪으신 분들의 해결 내용을 정리하면 다음과 같다.

1. 외국에서 글을 작성했을 때

외국에서 글을 작성하면 글이 전체공개가 안되고, 한국으로 귀국해서 재작성하니 해당 버그가 해결되었다는 분이 있다. 만일 해외에서 글을 작성했는데 전체공개가 안된다면 한국으로 돌아와서 글을 업로드 해보시는 것을 추천드린다.

2. 글에 특정 단어가 포함된 경우

• ㅂㅏㄷㅜㄱㅇㅣ -> 바둑은 가능합니다!
• ㅁㅏㅈㅣㄴㅗㅅㅓㄴ
• ㅋㅏㅈㅣㄴㅗ
• ㅎㅜ ㄹㅣ -> 후 뒤에 리가 바로 오면 글이 비공개처리 됩니다.
• 일본어, 한자로만 이루어진 제목 또는 글: 둘 중 하나라도 한자 또는 일본어로만 이루어져 있으면 비공개

...등 이라고 할 수 있겠다. password, coinbase, center 등도 스팸으로 처리되어 비공개 설정이 되는 버그가 있었던 것 같은데 이는 해결된 것으로 보인다. 이글이 보인다는 것이 그 증거이다.

참고로 ㅁㅏㅈㅣㄴㅗㅅㅓㄴ은 한글이 아니라 영어로 maginot line이라고 입력하면 또 된다.

3. 위에 해당사항이 없는데도 비공개?

이런 경우는 노가다로 문단 -> 문장 -> 단어 순으로 찾아내려가는 방법외에는 없습니다.

정리

이 드라마 이야기 Velog에서 못합니다. 이상.

장난이고 아무래도 불법 토토나 도박 사이트들이 판을 치다보니까 이런 필터링 기능이 만들어진 것 같다. 그러니 만일 동일한 버그를 겪는다면 문단을 삭제하면서 어떤 단어가 필터링 되는지 확인해보시길 추천드린다.

• 알고리즘 개념을 숲을 보는 시점으로 생각하기.
• Dynamic Programming(동적계획법)에 대해 배운다.
• Greedy Algorithm(그리디 알고리즘 - 탐욕 알고리즘)에 대해 배운다.

✏️ 알고리즘 설계 기법/ 문제 해결 접근 전략

• 브루트 포스(Brute Force)
  • 무차별 대입 공격, 가능한 모든 조합을 대입해보는 방식
  • 예: 네자리 비밀번호를 풀 때 0부터 9999까지 다 넣어보기
• 분할 정복(Divide and Conquer)
  • 문제를 분할(Divide)해서 해결(Conquer)한다.
  • 복잡한 문제를 간단한 문제로 나누고, 하위 문제들의 결과를 다시 합쳐서 해결한다.
• 동적 계획법(Dynamic Programming)
• 탐욕법(Greedy)

📌 피보나치 수열 문제

피보나치 수열이란 앞의 두 수의 합이 바로 뒤의 수가 되는 수열을 의미한다. 피보나치 수 $F_n$은 다음과 같은 초기값 및 점화식으로 정의되는 수열이다. $$ F_1 = F_2 = 1\ F_n = F_{n_1} + F_{n_2} $$ 이 피보나치 수열을 간단하게 재귀함수로 구현하면 다음과 같다.

# 재귀함수로 구현
def fibo(n):
        if n == 1 or n == 2:
                return 1
        return fibo(n-1) + fibo(n-2)
        # 한 줄로도 가능
        # return fibo(n-1) + fibo(n-2) if n >= 2 else n

print(fibo(10))

알고리즘 설계 기법과 문제 해결 접근 전략을 이야기하는데 갑자기 피보나치가 등장해서 의아할 수 있다.

피보나치 수열의 경우 재귀함수를 설명하는데 사용되는 대표적인 문제이다. 하지만 이 코드는 치명적인 단점이 존재하는데, 바로 항이 커질수록 계산속도도 매우 느려진다는 점이다.

동일한 계산이 반복적으로 수행되며 시간 복잡도는 $O(2^n)$이 된다. 이런 문제를 해결하기 위해서 재귀함수로 구성하는 것이 아닌 Dynamic Programming방법을 이용한다면 단점을 보완하며 더 빠른 속도로 문제를 해결할 수 있다.

✏️ Dynamic Programming(동적 프로그래밍)

하나의 문제를 여러 작은 문제로 나누고, 작은 문제의 답을 재사용하여 문제를 효율적으로 푸는 것

• 기억하며 풀기 또는 기억하기 알고리즘이라고도 할 수 있다.
• 분할정복과 차이: 문제의 답을 재사용하는 것
  • 다이나믹 프로그래밍은 이미 했던 계산은 반복하지 않는다.
  • 메모리를 조금 더 사용해서 연산속도를 비약적으로 증가시킨다.(메모리에 계산결과를 저장)
• Memoization(메모이제이션), Tabulation(테뷸레이션) 두 가지 방법론이 있다.
• "동적"이라는 말에 몰입하여 어느 부분이 동적으로 작동하는지 찾을 필요는 없다. 이 말을 처음 사용한 사람도 그저 이름이 멋있어서 붙인 이름이다.

💡Dynamic Programming의 조건 1. 작은 문제들이 반복된다. 2. 같은 문제는 구할때 마다 정답이 동일하다.
위와 같은 조건을 충족할때만 동적 프로그래밍을 사용할 수 있다. 작은 문제의 결과 값이 항상 같다는 점을 이용해서 큰 문제를 해결하는 방법이니 당연한 것이다.

👉 Memoization(메모이제이션, Top-down(하향식)방식)

• 메인 문제를 분할하면서 해결하는 하향식 방법(Top-Down)
• 재귀를 이용하여 값을 위에서 부터 계산한다.
• 주어진 입력값에 대한 결과를 저장해 같은 입력값에 대해서는 함수가 한 번만 실행된다. -> 함수 실행 횟수 감소
• 답을 재활용한다는 의미로 동일한 계산을 할 경우 한 번 계산한 결과를 메모리에 저장해 두었다가 꺼내 씀으로써 중복 계산을 방지할 수 있게 하는 기법이다.
• 이 기법은 메모리라는 공간적 비용을 투입해 시간적 비용을 줄이는 방식이다.

이제 위에서 나온 피보나치 수열문제를 메모이제이션으로 구성하면 다음과 같은 코드가 된다.

# 메모이제이션

def fibo_memo(n):
    # n이 2보다 작거나 같은 경우
    if n <= 2:
        return 1
    else:
        # 계산된 이력이 있는 경우
        if memo_[n] != 0:
            # 해당 함수값 반환하고 호출 종료
            return memo_[n]
        else:
            # f(n) = f(n-1) + f(n-2)
            memo_[n] = fibo_memo(n-1) + fibo_memo(n-2)
            # 결과값 반환 (f(n))
            return memo_[n]

num = 10
# 값 저장용 리스트(계산된 숫자는 해당 숫자의 인덱스에 값이 저장됨)
memo_ = [0]*(num+1)
print(fibo_memo(num))

코드를 보게 되면 계산된 이력이 있는지 살펴보고 없다면 아래의 재귀함수 부분으로 들어가게 된다. 즉 위에서부터(큰 수부터) 계산된 이력이 있는지 파악하면서 작은 수로 내려가기 때문에 하향식 방식이라고 부른다.

위 코드의 시간 복잡도는 $O(n)$의 시간복잡도를 가지게 된다.

👉 Tabulation(타뷸레이션, Bottom-Up(상향식) 방식)

• 가장 작은 문제를 먼저 해결하고 최종적으로 메인 문제를 해결하는 상향식 방법
• 반복문을 이용해 밑에서부터 계산하기 때문에 memoization과 달리 재귀함수를 사용하지 않는다.
• 값을 미리 계산해두고 필요하지 않는 값도 미리 계산한다.
  • 반복문을 통해 부분 문제에 대한 해답을 하나씩 저장한다.
• 메모하기 부분에서 Memoization이라고 했는데, Bottom-up(상향식)일때는 Tabulation이라고 부른다. 왜냐하면 반복을 통하여 Dp[0]부터 채우는 과정을 "table-fillint"라고 하며, 이런 방식을 이용하여 작은 문제부터 큰 문제까지 하나하나 테이블을 채워나간다는 의미이다. 근복적인 개념은 결과값을 기억하고 재활용한다는 측면에서 Memoization과 크게 다르지는 않다.

# 태뷸레이션
def fibo_tabul(n):
    # 태뷸레이션 : Botton-Top 방식
    # 0~2번째 값을 먼저 설정
    tab = [0, 1, 1]

    # 3번째 인덱스부터 진행. i번째 자리에 i-1, i-2의 값을 합쳐서 append -> for문
    for i in range(3, n + 1):
        tab.append(tab[i-1] + tab[i-2])

    return tab[n]

print(fibo_tabul(10))

이 코드 역시 시간복잡도는 $O(n)$에 해당한다. 하지만 이미 계산된 값을 저장한 리스트에서 값을 가져오는 작업 자체는 $O(1)$의 시간 복잡도를 가진다.

두 가지 방법 중 더 다은 것이 있을까?, 하나만 가능한 경우는?

두 방법 중 어느 것이 시간적으로 더 효율적인지 묻는다면, 그에 대한 답은 "알 수 없다"이다.
Top-Down 방식을 사용하는 Memoization은 재귀를 통해 답을 찾아 내려간다. 그렇다보니 재귀함수 호출로인한 Stack이 쌓여서 stackOverFlow같은 에러가 발생할 수 있다. 특히 Python에서는 해당 케이스가 잦다보니 이럴 경우 Bottom-up방식의 Tabulation으로 풀면된다.
두 방법 중 두 가지를 모두 사용하지 못하고 하나만 사용할 수 있는 경우가 있는지에 대해서는 있다고 할 수 있지만 그것은 동적 프로그래밍에 익숙해지고 경험적으로 알아낼 수 있는 부분이라고 한다.

Dynamic programming의 목적

우리가 프로그래밍을 배울 때 항상 기억해야하는 것은 모든 알고리즘은 기존에 있던 문제를 해결하기 위해서 고안되었다는 것이다.

완전 탐색, DFS,BFS와 같은 알고리즘은 수많은 경우의 수를 전부 따져봐야 하는데 그 경우의 수가 너무 많아서 속도가 느려지는 문제를 개선하고자, 수행 시간을 단축하고자 만들어진 알고리즘이 Dynamic programming이다.

💡 Dynamic Programming의 유형

• DFS/BFS로 풀 수 있지만 경우의 수가 너무 많을 때
  • 패턴을 파악하여 경우의 수가 얼마나 증가할지 고려
  • DFS나 완전 탐색으로 진행하는 maginot line은 500만 개의 경우의 수로 볼 수 있다.
  • $5*10^6$을 넘어가는 경우의 수라면 동적 프로그래밍방법 사용을 고려해 볼 것.
• 경우의 수들에 중복적인 연산이 많은 경우
• DP를 사용하게 되는 상황: 이진 검색, 최단경로 알고리즘, 최적화 문제, 외판원 문제

Dynamic Programming과 분할정복

• DP는 분할정복에 다음과 같은 개념이 추가된 것이라고 할 수 있다.
  • 중복된(반복되는) 서브문제(Overlapping Subproblems)
    • 메인과 서브문제를 같은 방법(반복)으로 해결할 수 있어야 한다.(문제해결관점)
  • 최적 부분 구조(Optimal Substructure)
    • 메인문제 해결방법을 서브문제에서 구하여 재사용하는 구조여야 한다.(문제의 구조관점)

👉 정리: DP는 최적 부분 구조로 구성된 중복된 서브문제를 분할정복으로 해결한다.

Greedy Algorithm(탐욕법)

뒤는 생각하지 않고 오로지 매 순간 현재 최선인 답을 선택하여 최종적으로 최적값, 또는 근사값을 구하는 방법

• 중복되지 않는 서브문제를 더 빨리 풀 수 있는 방법론이다.
• 매 순간 현재 최선인 답을 선택해서 최종적으로 최적값, 또는 근사값을 구한다.
  • 전체에서 최적값(가장 좋은 결과)을 항상 보장하지는 않는다.
  • 코드 작성이 쉽고 연산 시간도 빠르다.
  • 완벽한 베스트는 구하지 못하더라도 최악의 결과는 아닐 수 있다.
• 탐욕 알고리즘은 모든 경우의 수를계산하는데 시간이 오래 걸리거나 방법이 복잡한 경우 간단한 방법으로 비교적 빠르게 최적의 결과 또는 최적의 근사값을 얻을 수 있을 때 주로 사용한다.
• 그리디 알고리즘 문제는 문제를 푸는 것보다 문제 파악이 더 어려울 때가 많다.
  • 어떤 문제가 주어지면 문제를 파악하는 능력과 함께 어떤 알고리즘이 가장 효율적인지 알아내는 것은 매우 중요하다. 어떤 알고리즘이 효율적인지 알아내는 것은 직관에 의존하기 때문에 문제를 많이 풀어봐야 한다.
• Greedy Algorithm은 특별한 코드가 있는 알고리즘이 아닌 개념적인 알고리즘이다. 어떠한 문제에도 적용할 수 있지만, 문제마다 적용하는 방식은 모두 다르다.
• Greedy Algorithm에서 가장 어려운 점은 다음과 같다.
  • 이 문제에 Greedy Algorithm을 써야 할지 다른 알고리즘을 써야할지 알아내는 것.
  • Greedy Algorithm적용 시 최선의 선택 기준을 어떻게 알아내느냐 하는 것.

• 모든 경우의 수를 확인하는 방법(=무차별 대입)을 Brute-Force(브루트 포스)방법이라고 한다. 무차별 대입법은 알고리즘이라고 불리기는 조금 민망하지만, 모든 경우의 수를 일일이 확인하기 때문에 시간을 오래 걸려도 정답을 확실히 찾을 수 있다는 장점이 있다.

Greedy Algorithm 언제 사용할까?

Greedy Algorithm은 크게 2가지 경우에서 사용한다.

1. Greedy Algorithm으로 최적의 해를 찾을 수 있는 경우 Greedy Algorithm은 다른 알고리즘에 비해 코드를 쉽게 작성할 수 있고 처리 속도 또한 뛰어나다.
2. 최적의 해를 계산하는데 시간이 오래걸리는 문제에 대해 Greedy Algorithm을 이용하면 적당히 빠르면서 괜찮은 근사해를 구할 수 있는 경우

💡 풀이 방식 기본적으로 그때그때 가장 좋은 해결책을 찾아가는 기법이다. 해를 구하는 일련의 선택과정 마다 가장 좋아보이는 최선을 선택하면, 전체적으로 최적 해를 구할 수 있다는 방법론이다. 각 단계마다 최상으로 보이는 해결핵으로 구한 해들을 모아서 제시하게 된다.

💡 적용문제

• 동전 거스름돈을 가장 적은 수의 동전으로 주는 문제
• 최단경로 알고리즘(다익스트라 알고리즘)
• 최소비용 신장트리(Spanning Tree)를 구하는 알고리즘(크루스칼 알고리즘, 프림 알고리즘 등)(참고)

# 탐욕 알고리즘 예제: 잔돈
# 잔돈갯수를 구하자.(갖고 있는 돈 : 100원)
price = int(input('물건값을 입력하세요.'))

# 거스름돈
change = 100 - price
print(f'잔돈은 {change}원입니다.')

coin_list = [50, 40, 20, 10, 5]   # 받을 수 있는 잔돈의 종류. 크기순으로 적는다.(중요)

change_count = []   # 잔돈갯수

while change != 0:
    for coin in coin_list:
        change_bool = 0 # (동전 종류마다)동전 갯수에 대한 변수 생성
        # Greedy: 우선 금액이 큰 동전부터 거슬러준다.
        change_bool = change_bool + (change // coin)  # 몫이 동전의 갯수.
        print(change_bool)
        change_count.append(change_bool) # 잔돈 갯수 리스트에 추가
        change = change - (change_bool * coin) # 잔돈 갱신
        print(coin, change_count)

print('잔돈갯수 :',sum(change_count)) # 잔돈의 갯수를 합한다.(sum 내장함수 활용)

DP와 Greedy

• 최적 부분 구조 문제를 푼다는 점에서 비교된다.
  • Dynamic programming
    1. 문제를 작은 단위로 분할하여 해결한 후, 해결된 중복문제들의 결과를 기반으로 전체문제를 해결한다.
  • Greedy
    1. 각 단계마다 최적해를 찾는 문제로 접근한다.
    2. 해결해야 할 전체 문제의 갯수를 줄이기 위해서 개별적으로 문제를 해결해나가는 선택을 한다.

❗️ 참고자료

1. 코드스테이츠 교육자료

❗️ 화이트 모드 권장

학습목표

• 중요한 자료구조인 Hash Table에 대해 학습한다.
• N531~N534의 방향은 기본적인 자료구조를 활용하여 다양한 프로그램을 위한 자료구조와 알고리즘에 대해서 익힌다.

💡 해시테이블(Hash Table)이란?

해시 테이블은 Key(키)를 활용하여 Value(값)에 직접 접근이 가능한 자료구조를 의미한다.

만일 정렬된 배열(array)에서 원소를 추가한다고 생각해보자. 원소의 수는 12개이고(이미지에서는 보이지 않는 공간이 있다고 생각), 앞에서부터 10개의 데이터가 오름차순으로 저장되어 있다. 여기에 만일 70을 추가한다고하면 과정은 다음과 같다.

1. index 5번과 6번 사이에 값이 추가되도록 이진 검색법을 사용하여 검사
2. 6번 이후의 모든 원소를 한 칸씩 뒤로 이동.
3. 6번 인덱스에 70 대입

원소가 이동하는데 필요한 복잡도는 $O(n)$이고 그 비용은 결코 작지한다. 물론 데이터를 삭제하는 경우에도 똑같은 비용이 발생하며, 이런 프로세스는 파이썬에서 pop()을 사용할 때 ()안에 숫자를 넣게 되면 실행시간이 달라지는 이유이다.

해시법(Hashing)

위에서 나타난 배열의 인덱스를 하나씩 미루어서 바꾸고 다시 데이터를 삽입하는 과정없이 바로 데이터를 넣기 위해 만들어진 방법이 해시법(Hashing)이다.

해시법은 "데이터를 저장할 위치 = 인덱스"를 간단한 연산으로 구하는 것을 말한다. 이 방법을 이용한다면 원소의 검색뿐 아니라 추가, 삭제도 효율적으로 수행할 수 있다. 정렬알고리즘과는 다르게 값을 정렬할 필요없이 해시함수(Hash Function)을 통해 해시값(Hash value)을 얻어서 값을 검색하는 것이 목적이다.

해시함수(Hash Function)는 말그대로 함수로, 나누기 연산 등 다양한 방식으로 구현할 수 있다. 이런 방식으로 값을 저장하면 원소를 이동할 필요없이 해시함수를 통해 출력된 해시값을 통해 저장된다. 그리고 이렇게 저장되어 만들어진 원소들을 Bucket이라고 한다.

그리고 이런 해시법을 이용하여 만들어진 자료구조를 Hash Table이라고 한다.

파이썬의 Dictionary는 내부적으로 해시테이블 구조로 구현되어 있다. 해시 테이블은 검색을 위한 역할도 하고, 딕셔너리르 위한 자료구조의 역할도 수행한다.

📌 중간정리

• 해시(Hash)는 해시 함수를 통해 나온 값이다.
• 해시테이블은 키를 빠르게 저장 및 검색할 수 있는 테이블 형태의 자료구조이다.
• 해시함수는 여러 키를 분할하기 위해 키를 해시값(정수값)으로 매칭시키는 역할을 한다.
• 해싱(Hashing)은 쉽게 말해서 다 흩뜨려놓고, 키와 매칭되는 값을 검색하는 과정이다.

파이썬의 딕셔너리, 리스트와 튜플을 이용하여 해시테이블을 작성해보자.

import time
# case 1 - 딕셔너리로 활용되는 해시테이블을 확인할 수 있다.
test_dict = {i:chr(i) for i in range(1,91)}

time_1 = time.time()
print(test_dict[33]) 
print(test_dict[38])
print(test_dict[90])
time_2 = time.time()
time_interval = time_2 - time_1
print(time_interval)

# case 2 - 리스트와 튜플을 활용해서 해시테이블을 확인한다.
test_list = [(i,chr(i)) for i in range(1,91)]

def insert(item_list, key, value):
    item_list.append((key, value))

def search(item_list, key):
    # 데이터를 검색하려면 딕셔너리보다 오래 걸린다.(키, 값 쌍이 없어서 개별 값으로 반복해서 검색하기 때문이다.)
    for item in item_list:
        if item[0] == key:
            return item[1]      
    print('not matching')   

time_1 = time.time()
print(search(test_list, 33))
print(search(test_list, 38))
print(search(test_list, 90))
time_2 = time.time()
time_interval = time_2 - time_1
print(time_interval)

해시함수(Hash Function)

• 위의 그림처럼 해시함수는 키를 해시테이블 내의 버킷(=Hashes=해시값)으로 매핑시킨다.
• 해시함수: 입력값의 형태는 다양하고, 출력값의 형태는 정수이다.
  
• 해수함수 요구조건:
  • 해시함수는 **입력값이 같다면, 동일한 출력값을 받아야 한다.
  • 입출력값이 일정하지 않다면 적절한 해시함수가 아니다.
    • 예를 들어, 입력값 'aqua'가 4를 반환한다면, 입력값 'beige'는 4를 반환할 수 없다. 하지만 같은 경우가 출력될 수도 있는데 이를 해시충돌이라고 한다.
      • 해시함수는 특정 범위 안에 있는 숫자를 반환해야 한다.
        
• 하나의 해시함수가 입력 데이터별로 다른 숫자와 매핑된다면, 그것은 완벽한 해시함수이다.
  • 해시함수가 입력데이터에 따라 다른 숫자를 반환하게 되면 해시충돌을 최소화하는 것이다.

해시함수는 보통은 문자열 입력값에 정수형 출력값을 반환한다. 정수형에서 문자열로 변환하기 위해서, 해시함수는 문자열에 해당하는 개별적인 단어를 활용한다.

다음 예시는 파이썬에서 encode()메소드를 활용하여 문자열에서 바이트 코드로 인코드하는 것이다. 인코딩 된 후에 정수형은 각 단어를 나타낸다.

# 인코딩 예제
bytes_representation = "hello".encode()

for byte in bytes_representation:
    print(byte)
----
> 
104
101
108
108
111

이제 정수값의 합을 반환하는 방법을 활용하여 여러개의 정수들을 하나의 문자열로 변환하여보자.

# 정수값의 합 반환
bytes_representation = "hello".encode()

sum = 0
for byte in bytes_representation:
    sum += byte

print(sum)
----
> 534

# 해시함수를 만들고 활용해보자.
def my_hashing_func(str, list_size):
    bytes_representation = str.encode()    
    sum = 0
    for byte in bytes_representation:
        sum += byte

    return sum % list_size

print(my_hashing_func('hello',5))
----
> 2

위의 해시함수를 활용하는 예시를 더 보여주면 다음과 같다.

먼저 5개의 빈 슬롯이 들어가는 리스트를 초기화 시킨 후 리스트에 있는 적합한 인덱스에 색상 이름 문자열이 매핑되기 위해 해시함수를 사용하며, 인덱스에 해당 헥사코드값을 저장하면 해시함수를 사용하여 값을 검색할 수 있다.

# 위의 my_hashing_func이라는 해시함수를 활용하여 아래처럼 값을 확인할 수 있다.
my_list = [None] * 5

# 해시테이블 값을 입력
my_list[my_hashing_func("aqua", len(my_list))] = "#00FFFF"

# 해시테이블 있는 값을 출력
print(my_list[my_hashing_func("aqua", len(my_list))])

# 전체 해시테이블 출력
print(my_list)
---
#00FFFF
[None, None, None, None, '#00FFFF']

좋은 해시함수란?

• 해시함수를 어떻게 구현하는지에 따라서 해시의 성능이 결정된다.
• 좋은 해시함수의 조건
  • 키와 값의 계산과정이 쉬워야 한다.
  • 충돌을 피할 수 있어야 한다.
    • 해시함수는 가능한 해시값의 전체 집합에 데이터를 균일하게 배포한다.
      • 해시함수는 유사한 문자열에 대해 다른 해시값을 생성한다.

해시성능

해시테이블 자체는 해시충돌을 해결해주지는 않는다.

만일 해시충돌로 인해서 모든 Bucket의 Value를 찾아야해서 반복문이 필요한 경우를 제외하고는 해시테이블 자체는 $O(1)$ 시간복잡도 안에 검색, 삽입, 삭제를 할 수 있다. 검색/삽입/삭제 무엇을 하든지 해시함수는 키를 통해 저장된 값에 연관된 인덱스를 반환하기 때문이다.

해시충돌

일반적인 경우에서 모든 입력에 대해서 1:1로 대응되는 해시함수는 존재하지 않는다. 일반적으로는 n:1의 관계이다. 이처럼 저장할 버킷이 중복되는 현상을 충돌(Collision)이라고 한다. 그리고 이런 충돌이 가장 적은 해시함수를 만드는 것이 해시테이블의 가장 중요한 목적이다.

그리고 이런 충돌이 발생하는 경우 다음 2가지 방법으로 대처할 수 있다.

1. 체인법(Chaining): 해시값이 같은 원소를 연결 리스트로 관리 2. 오픈 주소법(Open adressing): 빈 버킷을 찾을 때까지 해시를 반

체인법(Chaining)

체인법은 해시값이 같은 데이터를 체인(chain)모양의 연결 리스트로 연결하는 방법을 말하며 오픈 해시법(Open hashing)이라고도 한다.

해시테이블에서 동일한 해시값에 대해 충돌이 일어나면, 그 위치에 있던 버킷에 키값을 뒤이어 연결한다. 데이터의 형태는 위의 그림처럼 연결리스트의 형태를 갖게 된다.

💡 Chaining의 원리

1. 키의 해시값을 계산한다.
2. 해시값을 이용해 리스트의 인덱스를 구한다.
3. 같은 해시값이 있다면(충돌한다면) 리스트로 연결한다.

위의 그림은 나누기 방법(Division method)을 사용한 것인데, 나누기 방법은 쉽기 때문에 많이 사용되는 기본적인 해시함수로서 키값이 정수로 가정된다. 위 그림에서 해시함수의 공식은 $키의,값%,13$이다. 69와 17 두 수 모두 13으로 나눈 나머지가 4이기 때문에 해시값 4에서 충돌이 발생하여 체이닝을 통해 연결되는 것을 확인할 수 있다.

# 체이닝을 예시코드로 배워보자.
# 아래와 같이 리스트안에 중첩되는 리스트를 만들어서 연결개념으로 해시테이블을 생성한다.
chain_hash_table = [[] for _ in range(10)]  # 이번에는 10의 길이로 테스트를 진행한다.(0~9, 총 10개의 인덱스)
print(chain_hash_table)
---
> [[], [], [], [], [], [], [], [], [], []]

# 해시함수는 위와 동일하게 테스트할 수 있다.
def chain_hash_func(key):
    return key % len(chain_hash_table)

print(chain_hash_func(10)) 
print(chain_hash_func(20)) 
print(chain_hash_func(25))
---
>
0
0
5

# append를 활용해서 키-값 쌍을 해시테이블에 삽입한다.
def chain_insert_func(chain_hash_table, key, value):
    hash_key = chain_hash_func(key)
    chain_hash_table[hash_key].append(value)

chain_insert_func(chain_hash_table, 10, 'A')
print(chain_hash_table)

chain_insert_func(chain_hash_table, 25, 'B')    # 5번째 인덱스에 B가 삽입된다.
print(chain_hash_table)

# 아래 결과값과 같이 중첩되는 결과값이 있더라도 값이 대체(충돌)되는 것이 아니다.
# 리스트 메소드 개념(list.append)이 활용되어 값을 이어 붙인다.('A' -> 'C')
chain_insert_func(chain_hash_table, 20, 'C')    
print(chain_hash_table)
---
[['A'], [], [], [], [], [], [], [], [], []]
[['A'], [], [], [], [], ['B'], [], [], [], []]
[['A', 'C'], [], [], [], [], ['B'], [], [], [], []]

위의 코드는 체인법의 개념을 초기에 이해하기에 좋은 예시코드이다. 실제로 Class와 함수를 이용하여 체인법을 구성하면 다음과 같이 구성할 수 있다.

from __future__ import annotations # 변수의 type에 대한 주석
from typing import Any, Type       # 타입힌트를 지원하는 모듈
import hashlib                     # 문자열을 해싱할 때 사용하는 모듈

구현 시 사용할 라이브러리들이다. 대체로 어노테이션과 관련된 라이브러리로 타입힌트 등을 사용하지 않으면 hashlib라이브러리를 제외하고 사용하지 않아도 이상이 없을 것으로 예상한다.

class Node:
    '''해시를 구성하는 노드'''
    def __init__(self, key:Any, value: Any, next: Node) -> Node:
        '''초기화'''
        self.key = key      #키
        self.value = value  # 값
        self.next = next    # 뒤쪽 노드를 참조

Node 클래스는 개별 버킷을 나타낸다. Node 클래스는 키와 값이 짝을 이루는 구조이다. 키에 해시 함수를 적용하여 해시값을 구한다.

class ChainedHash:
    """
    체인법으로 해시 클래스 구현
    """
    def __init__(self, capacity: int)-> None:
        '''초기화'''
        self.capacity = capacity            # 해시 테이블의 크기를 지정
        self.table = [None]*self.capacity   # 해시 테이블(리스트)를 선언

    def hash_value(self, key: Any) -> int:
        '''해시값을 구함'''
        if isinstance(key, int):
            return key % self.capacity
        return(int(hashlib.sha256(str(key).encode()).hexdigest(), 16) % self.capacity)

    def search(self, key:Any) -> Any:
        hash = self.hash_value(key) # 검색하는 키의 해시값
        p = self.table[hash]        # 노드를 주목

        while p is not None:
            if p.key == key:
                return p.value  # 검색 성공
            p = p.next          # 뒤쪽 노드를 주목
        return None

    def add(self, key:Any, value:Any) -> bool:
        '''키가 key이고 값이 value인 원소를 추가'''
        hash = self.hash_value(key)
        p = self.table[hash]

        while p is not None:
            if p.key == key:
                return False # 추가실패
            p = p.next

        temp = Node(key, value, self.table[hash]) # self.table[hash]는 None이 된다.
        self.table[hash] = temp # 노드를 추가
        return True

    def removes(self, key:Any) -> bool:
        '''키가 key인 원소를 삭세'''
        hash = self.hash_value(key)
        p = self.table[hash]
        pp = None

        while p is not None:
            if p.key == key:
                if pp is None:
                    self.table[hash] = p.next
                else:
                    pp.next = p.next
                return True # key 삭제 성공
            pp = p
            p = p.next  # 뒤쪽 노드를 주목
        return False    # 삭제 실패(key가 존재하지 않음)

그리고 각각의 기능을 클래스에 구현하여 주었다. 다른 설명은 제외하고 hash_value함수의 key가 int형이 아닌 경우에 대해서 설명하겠다.

Key가 정수가 아닌 경우에는 그 값으로는 바로 나눌 수 없다. 그래서 sha256알고리즘, encode()함수, hexdigets()함수, int()함수 등의 표준 라이브러리로 형 변환을 해야 해시값을 얻을 수 있다.

• sha256 알고리즘 hashlib모듈에서 제공하는 sha256은 RSA의 FIPS알고리즘을 바탕으로 하며, 주어진 바이트(byte) 문자열의 해시값을 구하는 해시 알고리즘의 생성자(Constructor)이다. Hashlib모듈은 sha256외에도 MD5 알고리즘인 md5 등 다양한 해시 알고리즘을 제공한다.

• encode( )함수 hashlib.sha256에는 바이트 문자열의 인수를 전달해야 한다. 그래서 Key를 str형 문자열로 변환한 뒤 그 문자열을 encode()함수에 전달하여 바이트 문자열을 생성한다.
• hexdigest( )함수 sha256알고리즘에서 해시값을 16진수 문자열로 꺼낸다.
• int(문자열,16) 함수 hexdigest()함수로 꺼낸 문자열을 16진수 문자열로 하는 int형으로 변환한다.

만일 위에서 원소를 출력하여 보고 싶다면 다음과 같은 함수를 추가하면 된다.

def dump(self) -> None:
    for i in range(self.capacity):
        p = self.table[i]
        print(i, end="")
        while p is not None:
            print(f' -> {p.key}({p.value})', end ="")
            p = p.next
        print()

다음과 같이 객체를 생성하여 테스트하면 다음과 같이 출력된다.

hash_table = ChainedHash(13)
hash_table.add(1, 14)
hash_table.add(3, 29)
hash_table.add(4, 69)
hash_table.add(9, 17)
hash_table.add(19, 5)
hash_table.add(6, 6)
hash_table.add("이것은 Key", 46)
hash_table.add(15, 20)
hash_table.add(23, 33)
hash_table.add("key", "value")
hash_table.dump()
---
0
1 -> 이것은 Key(46) -> 1(14)
2 -> 15(20)
3 -> 3(29)
4 -> 4(69)
5 -> key(value)
6 -> 6(6) -> 19(5)
7
8
9 -> 9(17)
10 -> 23(33)
11
12

오픈 주소법(Open addressing)

해시 충돌이 발생할 때 해결하는 또 다른 방법으로 오픈 주소법^{open addressing}이 있다. 오픈 주소법은 충돌이 발생했을 때 재해시^rehashing를 수행하여 빈 버킷을 찾는 방법을 말하며 닫힌 해시법^{closed hashing}이라고도 한다.

이미지 출처

위의 그림처럼 오픈 주소법은 빈 버킷이 나올 때까지 재해시를 반복하므로 선형 탐사법^{linear probing}이라고도 한다.

이처럼 재해시를 하게되면 원소를 삭제할 때 문제가 발생한다. 위의 그림의 가장 마지막 배열에서 5를 삭제한다고 가정해보자. 인덱스가 5인 버킷을 비우기만 하면 될 것 같지만 실제로는 그렇지 않다. 해시값이 같은 18을 검색할 때 해시값이 5인 데이터는 존재하지 않는다고 착각하여 검색에 실패하기 때문이다. 18이 재해시한 것으로 보이지만 해시함수 자체는 변하지 않기 때문에 방금 추가한 18의 해시값은 여전히 5이기 때문이다.

이러한 오류를 방지하기 위해서 각 버킷에 다음과 같은 속성을 부여한다.

• 데이터가 저장되어 있음(숫자)

• 비어 있음(-)
• 삭제 완료(⭐️)

속성이 부여되면 인덱스가 5인 버켓의 데이터가 삭제되도 삭제 완료라는 속성으로 인해서 재해시를 진행하여 검색하는 값이 나올 때까지 탐색하게 된다.

위의 그림에서도 알 수 있듯이 오픈 주소법은 체이닝과 다르게 저장공간이 정해져 있다.

❗️ 파이썬의 해시충돌 해결법은?

파이썬에서 해시테이블로 구현된 자료형은 딕셔너리(Dictionary)이다. 그렇다면 이 딕셔너리 자료형은 해시충돌이 발생했을 때 어떤 방식으로 해결할까?

파이썬의 경우 내부적으로 오픈 주소법 방식을 활용한다고 한다. 파이썬에서 오픈 주소법을 활용하기 때문에 빈 공간이 없는 경우 시간이 오래 걸릴 수 있다. 따라서 로드 팩터를 작게 설정하여 성능 저하 문제를 해결한다.

그렇다면 또 이런 의문이 들것이다. 이에 대해 찾아보니 공식문서 QnA에서 그저 크기 조정이 가능한 해시테이블로 구현한다고 나와있다. 여기서부터는 정확하지 않지만 어느 정도의 기본적인 크기를 지정하고 해시테이블이 모두 채워지면 더 많은 버킷을 가진 테이블을 새로 생성하는 것 같다.

Load Factor(로드 팩터)?

• 해시 테이블에 저장된 항목 수(해시 테이블에 입력된 키 갯수)를 슬롯 수(해시 테이블 전체 인덱스 갯수)로 나눈 값이다.
  • 오픈 주소법을 사용하면 최대 로드 팩터는 1정도 나온다.
  • 체이닝을 사용하면 로드 팩터는 오픈 주소법보다 좋은 성능(Load Factor <= 1)을 보일 수 있다. 하지만 체이닝 기법에 필요한 연결 리스트 구현에 큰 오버헤드가 요구된다.
    • 로드 팩터를 낮추면 해시값이 비어있는 슬롯을 가르킬 확률이 높기 때문에 해시에 대한 성능이 올라간다.
      
• 위의 공식에 나와있는 방식으로 로드 팩터를 계산하여 비율에 따라 해시함수 재작성 여부, 해시테이블 크기 조정 여부가 결정된다.
  • 로드 팩터값을 통해 해시 테이블의 성능정도를 파악할 수 있다.
    
• 하지만 어디까지나 대략적인 성능측정도구로 절대적이지 않다.
  • 로드 팩터에는 해시 테이블의 상황, 입출력의 상황, 메모리에 적재되는 시간 등 영향을 주는 요소가 다양하다.
  • 로드 팩터에서 발생할 수 있는 상대성을 고려하며 개념을 활용하기 보다 이러한 개념이 있다는 것을 인지하여야 한다.

💡 해시테이블의 다양한 실생활 사례

• 전화번호부(사람의 이름을 전화 번호에 매핑)
• DNS확인(웹 주소를 IP주소에 매핑)
• 학생 기록(고유한 학생 ID가 학생 정보에 매핑)
• 도서관 시스템(책의 고유 식별자가 자세한 책 정보에 매핑)

정리

❗️참고자료

1. 코드스테이츠 교육자료
2. 파이썬 딕셔너리(네이버 블로그)
3. 파이썬 공식문서
4. BohYoh Shibata, 옮긴이 강민, DO it! 자료구조와 함께 배우는 알고리즘 입문 파이썬 편, 서울:이지스퍼블리싱, 2022

• 깊이 우선 탐색(Depth-First Search, DFS)을 배우고 DFS 코드를 이해한다.
• 너비 우선 탐색(Breadth-First Serach, BFS)을 배우고 BFS 코드를 이해한다.
• 위의 개념과 기존에 배웠던 기본적인 스택, 재귀, 트리, 그래프 등을 연관지어 이해한다.

BFS & DFS

이전 시간에 그래프와 트리의 순회에 대해소 학습했다. 순회란 그래프에서 모든 노드를 방문하는 것을 말한다. 그리고 이러한 순회의 방법으로 DFS와 BFS가 있다.

• 목적: 모든 정점을 1번씩 방문하기 위한 것

• 순회(방문)하면서 탐색하는 탐색 알고리즘

• 출발 노드와 그래프/트리 구조에 따라 탐색하는 순서와 노드가 달라질 수 있다.

• 주의사항: 방문한 노드인지 아닌지에 대한 확인이 필요하다.

  

  ## 깊이 우선 탐색(Depth-First-Serach, DFS) 깊이 우선 탐색이란 현재 정점에서 갈 수 있는 점들까지 최대한 **깊게 들어가면서 탐색**한다. 자료구조 중 **스택(Stack)** 또는 **재귀**를 이용하여 구현할 수 있다.

  

• 시작 정점으로부터 하나의 분기를 전부 방문한 후 다음 분기로 넘어가는 방식

  • DFS는 깊이를 우선적으로 탐색 후, 재귀적으로 아래에서부터 탐색하지 않은 정점이 있는지 확인하는 방법

• 이전 경로의 정보가 필요한 경우나, 모든 노드를 방문하는 경우 사용된다.

• 활용예시

  • 가중 그래프의 최소 스패닝 트리 찾기
  • 길 찾기
  • 그래프에서 주기 감지
  • 미로 문제

    💡 DFS 절차(재귀)

  1. 노드를 방문 리스트에 기록
  2. 현재 노드에 인접한 노드를 기준으로 반복
  3. 노드의 인접리스트가 비었을 경우 종료(Base Case)
  4. 방문하지 않은 노드인 경우 DFS함수 재귀호출

     def dfs_recur(start, graph, visited=[]):
     # 방문리스트에 체크
     visited.append(start)
     # 현재 노드에 인접한 노드를 기준으로 반복
     for node in graph[start]:
       # 방문하지 않은 노드인 경우:
       if node not in visited:
           # dfs 재귀 수행
           dfs_recur(node, graph, visited)
     return visited

💡 DFS 절차(Stack) 1. 방문 리스트에 시작 노드 기록 2. Stack에 시작 노드의 인접 노드 삽입(Push) 3. Stack에서 노드를 POP하면서 방문처리(출력) 한다. 4. 꺼내온 노드와 이웃한 노드를 Stack에 넣는다.(Push) 그 후 방문했던 노드인지 아닌지 체크한다. 5. Stack에 아무것도 남지 않을 때까지 24를 반복한다. 6. 모든 노드를 방문할때까지 15를 반복한다.

def dfs_stack(start_node, graph):
    visited = []   # 방문 리스트
    stack = [start_node]
    # 반복문(스택 안에 값이 있는 동안 반복):
    while stack:
        # 스택에서 pop
        node = stack.pop() 
        # 방문 리스트에 없는 경우:
        if node not in visited:
            # 스택에 인접 노드 push
            visited.append(node)
            # 방문리스트에 기록
            stack.extend(graph[node])
    return visited

위 두 코드를 실행하면 사실 다른 결과가 나온다.

# 테스트 해보기

graph_0 = {
    1: [2,3,4],
    2: [5],
    3: [6],
    4: [],
    5: [7],
    6: [5],
    7: [6]
}

print(dfs_recur(1, graph_0, visited=[])) # [1, 2, 5, 7, 6, 3, 4]
print(dfs_stack(1, graph_0))             # [1, 4, 3, 6, 5, 7, 2]

이는 Stack의 경우 POP이라는 명령어를 이용해서 제일 끝 단 노드를 꺼내오면서 탐색을 시작하기 때문이다. 만일 재귀함수로 구현한 DFS와 Stack을 통해 구현한 DFS의 결과값을 동일하게 하고 싶다면 다음과 같이 코드를 수정해주면 된다.

# 재귀와 똑같이 하려면? 순서를 바꾸면 됨.

# DFS 구현 2. 스택
def dfs_stack(start_node, graph):
    visited = []   # 방문 리스트
    stack = [start_node]

    # 반복문(스택 안에 값이 있는 동안 반복):
    while stack:
        # 스택에서 pop
        node = stack.pop() 
        # 방문 리스트에 없는 경우:
        if node not in visited:
            # 스택에 인접 노드 push
            visited.append(node)
            # 방문리스트에 기록
            stack.extend(graph[node][::-1])# 이 부분 변경
            # [::-1] : 연결리스트 안에있는 노드를 역순으로 꺼내면 됨
    return visited

print(dfs_stack_2(1, graph_0))   # [1, 2, 5, 7, 6, 3, 4]

재귀와 스택의 차이점

• 로직이 직관적이고 이해하기 쉽다.
  • 스택은 리스트의 메소드만을 활용하였기 때문에 위에서 아래로 코드를 해석하면 되므로
• 스택이 실행 속도 또한 재귀보다 빠르다.
  • 스택의 특징인 후입선출 개념을 적용하였기 때문에, 마지막에 삽입된 노드를 기준으로 깊이우선탐색을 진행한다.
• 재귀구현의 경우는 자기함수를 호출하는 형태이기 때문에 코드가 간결해진다는 장점이 있다.
  • 재귀와 스택 방법의 차이점을 찾을 수 있도록 각 방법의 특징을 이해해야 한다.

DFS와 백트랙킹(Backtracking)

DFS는 가능한 모든 경로(후보)를 탐색한다. 따라서, 불필요할 것 같은 경로를 사전에 차단하는 등의 행동이 없으므로 경우의 수를 줄이지 못한다.

탐색하는 방향에 답이 없다고 판단되면, 되돌아가서 다른 방향을 탐색하는 기법을 바로 백트래킹이라고 한다. 즉, 반목문의 횟수를 줄일 수 있으므로 효율적이다. 이를 가지치기라고 하는데, 불필요한 부분을 쳐내고 최대한 올바른 쪽으로 간다는 의미이다.

❗️ 백트래킹 예시 문제: 백준 9663번 (문제 링크)

너비 우선 탐색(Breadth-First Search, BFS)

현재 정점에 연결된 가까운 점들부터 최대한 넓게 탐색한다. 자료구조 중 큐(Queue)를 이용해 구현할 수 있다.

• 노드가 적은 그래프를 순회하거나, 최단경로를 탐색할 때 유용
• 단점: Queue를 활용하므로 노드가 많아지는 경우 필요한 메모지 저장공간이 증가한다.
  • 인접한 노드의 정보를 모두 가진 상태에서 밑으로 내려간다.
• 활용예시
  • 길 찾기, 라우팅
  • BitTorrent와 같은 P2P 네트워크에서 인접 노드 찾기
  • 웹 크롤러
  • 소셜 네트워크에서 멀리 떨어진 사람 찾기
  • 그래프에서 주변 위치 찾기
  • 네트워크에서 방송
  • 그래프에서 주기 감지
  • 연결된 구성 요소 찾기
  • 몇 가지 이론적 그래프 문제 풀기

    💡 BFS 절차

  1. 방문 리스트에 시작 노드 기록
  2. Queue에 시작 노드의 인접 노드 삽입(Enqueue)
  3. Queue에서 노드를 Dequeue하면서 방문처리(출력)한다.
  4. 꺼내온 노드와 인접한 노드를 큐에 넣는다.(Enqueue) 그 후 방문했던 노드인지 아닌지 체크한다.
  5. Queue에 아무것도 남지 않을 때까지 2~4를 반복한다.
  6. 모든 노드를 방문할때까지 1~5를 반복한다.

# deque 라이브러리를 활용한 queue 구현하기

# 우선 deque를 위해 자료구조의 큐에서 배웠던 내용을 복습한다.
from collections import deque

queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")             # append: 오른쪽끝 삽입   
queue.append("Graham")
# print(queue.pop())
print(queue.popleft())            # popleft: 왼쪽끝 빼오기 pop(0)와 같은 역할이지만 상수시간 보장
# print(queue.popleft())
print(queue)

# BFS 구현 - deque 사용
"""
1. 방문 리스트에 시작 노드를 기록
2. Queue에 시작노드의 인접 노드를 삽입(enqueue)
3. 큐에서 노드를 Dequeue하면서 방문처리(출력)한다.
4. 꺼내온 노드와 이웃한 노드를 큐에 넣는다.(enqueue)
  방문했던 노드인지 아닌지 체크한다.
5. 큐에 아무 것도 남지 않을때까지 2-4 반복
6. 모든 노드를 방문할때까지 1-5를 반복
"""

# deque 라이브러리 불러오기
from collections import deque

# BFS 메서드 정의
def bfs(start_node, graph):
    # 방문 처리용 리스트 만들기
    visited = []
    # 시작 노드를 큐에 삽입
    queue = deque([start_node])

    # 큐가 완전히 빌 때까지 반복
    while queue:
        # 큐에서 값을 뽑아낸다.
        cur_node = queue.popleft()  # 리스트의 queue.pop(0)과 같다. 그러나 시간복잡도 상수시간 보장
        # 해당 노드가 방문처리 된 노드라면
        if cur_node not in visited:
            # 방문처리용 큐에 노드 추가
            visited.append(cur_node)
            # 해당 노드의 인접한 노드를 큐에 추가
            queue.extend(graph[cur_node])
    return visited

정리

• 먼저 생각해볼 점

  • 각 알고리즘이 요구하는 메모리는 주어진 자료구조(그래프, 트리 등)의 행태와 알고리즘의 목적(탐색, 정렬 등)에 따라 달라질 수 있다.

• DFS

  • Search할 노드의 세로 위치가 깊을 수록, BFS보다 노드를 찾는 속다가 빠르다.
  • 노드의 갯수가 주어진 컴퓨터의 자원(메모리, 소프트웨어 등)이 감당할 수 있는 범위 이상으로 증가하는 경우, Stack과 재귀방법을 활용하여 탐색을 진행하기 때문에 무한루프 에러가 발생할 확률이 높아진다.

• BFS

  • Search할 노드가 가로 위치로 인접한 경우, DFS보다 효과적일 수 있다.
  • Queue를 이용해 노드를 저장하는데, Queue는 탐색할 모든 노드를 저장하는 특징이 있다.
  • 때문에 메모리를 벗어날 정도로 노드의 갯수가 증가하는 경우 DFS보다 메모미를 많이 소비할 수 있다.

❗️참고자료

1. 코드스테이츠 교육자료

• 쾨니히스베르크의 다리 (링크)

"임의의 지점에서 출발하여 일곱 개의 다리를 한 번씩만 건너서 원래 위치로 돌아오는 방법"에 대한 문제가 있었고, 많은 사람들이 이 문제의 답을 찾기 위해 노력을 했다.

그렇다면 정답은 무엇일까.

없다.

당시 레온하르트 오일러는 이 문제를 다음 그림과 형태로 각각의 다리에 a부터 g까지 이름을 부여하고 도식화했다.

오일러의 스케치를 현대식 그래프 구조에 따라 나타낸 아래 그림에서는 A부터 D까지를 정점(Vertex), a부터 g까지는 간선(Edge)으로 구성된 그래프라는 수학적 구조를 찾아볼 수 있다.

그래프

• 정점(vertex=node)과 간선(=edge=link)으로 이루어진 자료구조
• $G = (V, E)$

그래프의 유형

방향성, 순환, 가중치

• 그래프의 특성은 directed(방향성) 또는 undirected(무방향성) 그래프가 있다.

• Directed Graph : 방향성이 있는 그래프이다. (유향 그래프 또는 방향성 그래프라고 불림)

  “한쪽 방향(one-way)”으로 설명될 수 있다면 directed가 가장 적합하다. 방향성그래프는 보는 것처럼 순서가 있으므로 마지막 노드(리프, leaf)가 있다. 위 그림에서는 'F'가 리프노드이다.

• bidirectional(양방향)

  위처럼 Directed Graph는 양방향이 될 수 있다.

  하지만 노드연결관계의 목적이 상호 교환이라면, undirected graph가 가장 적합하다.

  • 상호 교환 : 화살표로 연결된 노드들이 서로 노드정보를 공유하는 것

• Undirected Graph : 방향성이 없는 그래프이다.

  위처럼 무방향성은 방향(화살표)이 따로 지정되어있지 않다. 간선으로 연결된 노드들끼리 서로 인접(adjacent)해있다고 하며, 이웃(neighbor)라고 칭한다.

• Weighted Graphs(가중 그래프)

  • 가중 그래프에는 edge(간선)와 관련된 값이 있다.

    • 각 edge의 가중치에 할당된 특정값을 호출한다.
    • 가중치는 서로 다른 그래프에서 서로 다른 데이터를 나타낸다.
    • 일상 예시
      • 교대역 —2분→ 강남역 —1분—>역삼역

• Cyclic and Acyclic Graphs(순환 및 비순환 그래프)

  • 순환(루프)을 형성할 수 있는 경우(예 : 방문한 노드에 다시 방문) 그래프는 순환 그래프이다.
    • 순환 그래프
    • 비순환 그래프
      • 참고 : undirected 그래프는 항상 동일한 노드에 재방문할 수 있으므로 순환 그래프이다.
      • 순환을 형성할 수 없는 경우(예 : 모서리를 따라 이미 방문한 노드에 방문할 수 없음) 비순환 그래프라고 한다.

• Directed Acyclic Graphs (DAGs) - 방향성 비순환 그래프

  

  • 순환되지 않고 특정한 단방향 그래프이다.
  • 그림처럼 edge가 순서대로 향하도록 DAG의 노드를 선형(단방향)으로 정렬할 수 있다.
  • 트리도 DAGs의 일종이다.
  • DAG는 작업들의 우선순위를 표현을 할 때 DAG를 많이 사용하게 된다. 예를들어 공장에서 작업 스케줄링을 할 때 A 라는 작업이 끝나고 B를 해야하고 B 가 끝난 다음에는 C,D를 해야한다는 것을 DAG로 표현할 수 있다.
    • 활용 예시 : airflow DAG(링크)
  • 또한 사이클이 없는 방향그래프라는 정의를 통해 모든 트리는 DAG임을 알 수 있다.  (어떤 그래프가 주어졌을 때 이 그래프가 DAG인지 판단하기 위해서는 사이클의 존재여부를 확인하면 된다.)
    • 처음 출발한 노드(정점) v에서 시작하여 끝내 다시 v로 돌아가 순환 반복될 수 있는 방법이 없는 그래프라고 이해하면된다.

트리

• 트리의 특성: 루트가 있고, 아래로 차일드 노드들이 있고, 노드를 연결하는 엣지가 있고,

  엣지의 방향성은 위에서 아래로 진핸된다.

• 트리는 그래프의 한 형태이다.

  • 트리는 루트가 있고, 사이클이 없는, 아래로만 흐르는 방향그래프이다.

    트리와 그래프의 차이

    

참고 : https://gmlwjd9405.github.io/2018/08/13/data-structure-graph.html

그래프의 활용

인접행렬, 인접리스트

• 그래프를 표현한다는 것은 인접성을 표현한다는 것을 이야기 합니다. 어떤 노드와 어떤 노드가 edge로 연결되어 있는지를 표현하는 것
• 두 노드가 간선으로 연결되어 있다면 ‘두 노드는 인접하다’라고 표현한다.

그래프를 나타내는 방법

• 인접행렬(adjacency matrices) : 이차원 배열에 표시하는 방법
• 인접리스트(adjacency lists) : 배열의 노드들을 나열하고 관계를 연결리스트로 표현하는 방법

• 각 유형을 사용할 때, verts C와 D 사이의 관계를 어떻게 표현하는지가 중요하다.

인접행렬 (Adjacency Matrix)

• 인접 행렬은 표 형태로 표현하는 방법으로, 2차원 배열에 각 노드가 연결된 형태를 기록하는 방식이다. 파이썬에서는 2차원 리스트로 구현할 수 있다.

# 리스트로 구현한 인접행렬
# 아래 코드처럼 위의 간선 가중치는 1이다.
class Graph:
    def __init__(self):
        self.edges = [[0,1,0,0,0,0,0],
                      [0,0,1,1,0,0,0],
                      [0,0,0,0,1,0,0],
                      [0,0,0,0,0,1,1],
                      [0,0,1,0,0,0,0],
                      [0,0,1,0,0,0,0],
                      [1,0,0,0,0,1,0]]

• 노드가 n개면 n by n 행렬을 만들게 된다.

인접리스트(Adjacency List)

• 인접리스트에서 그래프는 전체 노드 목록을 저장한다.

  

  노드와 인접한 노드들을 연결리스트로 쭉 나열하여 저장하는 것

# 위 그림에 대해 딕셔너리를 사용한 인접리스트 예시
# 노드가 키가 되고, 인접노드가 값이 되는 딕셔너리이다.
# 가장자리 노드들은 set으로 구현되어 있다.
class Graph:
    def __init__(self):
        self.vertices = {
                            "A": {"B"},      # 여기서 {"B"}가 set의 형태이다.
                            "B": {"C", "D"}, # {"B" : {}}의 형태는 딕셔너리
                            "C": {"E"},      # 즉, 딕셔너리 안에 set이 있는 것이다.
                            "D": {"F", "G"},
                            "E": {"C"},
                            "F": {"C"},
                            "G": {"A", "F"}
                        }

• 메모리 측면에서 보자면 인접 행렬 방식은 모든 관계를 저장하므로 노드 개수가 많을수록 메모리가 불필요하게 낭비된다.
• 반면에 인접리스트 방식은 연결된 정보만을 저장하기 때문에 메모리를 효율적으로 사용한다.
• 하지만 인접 리스트 방식은 연결된 데이터를 하나씩 확인해야 하기 때문에, 인접 행렬 방식에 비해 특정한 두 노드가 연결되어 있는지에 대한 정보를 얻는 속도가 느리다.

예시 퀴즈 (1)

위 사진의 그래프를 인접행렬과 인접 리스트로 나타내어보아라.

# 무방향 그래프

# 인접 행렬
graph = [#0 1 2 3 4 5 6
         [0,0,0,0,0,0,0], # 0
         [0,0,0,0,0,0,0], # 1
         [0,0,0,0,0,0,0], # 2
         [0,0,0,0,0,0,0], # 3
         [0,0,0,0,0,0,0], # 4
         [0,0,0,0,0,0,0], # 5
         [0,0,0,0,0,0,0]  # 6
        ]

# 인접 리스트
graph = {
    0: {},
    1: {},
    2: {},
    3: {},
    4: {},
    5: {},
    6: {}
}

• 정답

    graph = [# 0 1 2 3 4 5 6
               [0,1,1,0,0,0,0], #0
               [1,0,1,1,0,0,0], #1
               [1,1,0,0,1,0,0], #2
               [0,1,0,0,1,0,0], #3
               [0,0,1,1,0,1,0], #4
               [0,0,0,0,1,0,1], #5
               [0,0,0,0,0,1,0]  #6
            ]
  
    graph = {
        0: {1, 2},
        1: {0, 2, 3},
        2: {0, 1, 4},
        3: {1, 4},
        4: {2, 3, 5},
        5: {4, 6},
        6: {5}
    }

예시 퀴즈 (2)

# 단방향 그래프

# 인접행렬
graph = [#0 1 2 3 4 5
         [0,0,0,0,0,0], # 0
         [0,0,0,0,0,0], # 1
         [0,0,0,0,0,0], # 2
         [0,0,0,0,0,0], # 3
         [0,0,0,0,0,0], # 4
         [0,0,0,0,0,0]  # 5
        ]

# 인접리스트
graph = {
    0: {},
    1: {},
    2: {},
    3: {},
    4: {},
    5: {}
}

• 정답

    graph = [#0 1 2 3 4 5
             [0,1,0,1,0,0], # 0
             [0,0,1,0,0,0], # 1
             [0,0,0,0,1,1], # 2
             [0,0,0,0,1,0], # 3
             [0,0,0,0,0,1], # 4
             [0,0,0,0,0,0]  # 5
            ]
  
    # 인접리스트
    graph = {
        0: {1, 3},
        1: {2},
        2: {4,5},
        3: {4},
        4: {5},
        5: {}
    }

순회(Traversal)

순회 화살표를 잘 보자.

순회 기본개념

• 순회는 Traversal로 명명되며, 그래프 또는 트리처럼 연결된 구조에서 노드를 한 번씩 탐색하는 개념이다.
  • 순회의 목적은 모든 노드 또는 특정 노드를 방문하는 방법을 찾는 것이다.
  • BST(이진검색트리)와 다른 규칙이 적용되며 방향에 따라 탐색방법이 달라질 수 있다.

그래프와 트리의 순회구분

트리의 순회(전위, 중위, 후위)

• 그래프의 순회는 DFS(깊이우선탐색), BFS(너비우선탐색) 방법이 있다.
  • DFS, BFS는 탐색 알고리즘이다.
    • 그래프는 루트, 부모, 자식노드 개념이 없지만 전위, 중위, 후위 순회의 순회개념을 활용하여 DFS, BFS를 구현할 수 있다.
• 트리의 순회는 전위, 중위, 후위순회이다.
  • 전위순회(preorder traverse): 루트를 먼저 방문 , root node → left node → right node
  • 중위순회(inorder traverse): 왼쪽 서브트리를 방문 후 루트 방문, left → root → right
  • 후위순회(postorder traverse): 왼쪽 서브트리, 오른쪽 서브트리, 루트 방문, left → right → root

순회 실습 해보기

# 이진 트리의 노드 클래스
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 전위 순회(pre-order) 함수
def preOrder(root):
    if root:
        print(root.val, end=" ")
        preOrder(root.left)
        preOrder(root.right)

# 중위 순회(in-order) 함수
def inOrder(root):
    if root:
        inOrder(root.left)
        print(root.val, end=" ")
        inOrder(root.right)

# 후위 순회(post-order) 함수
def postOrder(root):
    if root:
        postOrder(root.left)
        postOrder(root.right)
        print(root.val, end=" ")

root = TreeNode(10)
root.left = TreeNode(8)
root.right = TreeNode(9)
root.left.left = TreeNode(7)
root.left.right = TreeNode(1)
root.right.left = TreeNode(11)
root.right.right = TreeNode(12)
root.left.right.left = TreeNode(3)
root.left.right.right = TreeNode(2)
root.right.right.left = TreeNode(13)

preOrder(root) # 전위 순회
print(" ")
inOrder(root)  # 중위 순회
print(" ")
postOrder(root) # 후위 순회

결과가 아래와 같은지 확인해 봅시다.

전위순회 결과: 10 8 7 1 3 2 9 11 12 13

중위순회 결과: 7 8 3 1 2 10 11 9 13 12

후위순회 결과: 7 3 2 1 8 11 13 12 9 10

인접행렬, 인접리스트 구현하기

# 인접 행렬
input_list = [
[4, 1, 10], # 노드4번에서 노드1번으로 연결되는 가중치가 10입니다.
[3, 5, 24],
[5, 6, 2],
[3, 1, 41],
[5, 1, 24],
[4, 6, 50],
[2, 4, 66],
[2, 3, 22],
[1, 6, 25]
]

arr = [[0 for col in range(6)] for row in range(6)]

for a, b, c in input_list:
        arr[a-1][b-1] = c

arr

# 인접 리스트

adj_dict = {}

for a,b,c in input_list:
        if a in adj_dict:
            adj_dict[a].update({b:c})
        else:
            adj_dict.update({a: {b:c}})

회고

사실 정리도 되게 오랜만에 하는 것 같다. 그간 다양한 일이 있었는데 일단 Section4 Project를 진행했고 Section5가 종료되었다. Section5는 CS파트로 자료구조와 알고리즘을 학습했다. 앞으로 프로젝트까지 약 3일?에서 4일 정도 남았는데 그간 정리 못한 파트들을 몰아서 정리할 계획이다.

참고로 N532부터 N534는 내가 정리한 내용이 아닌 코치님께서 정리해주신 내용을 사실상 싸악 긁어서 Velog에서 정상적으로 보이게 편집만 한 것이다.

이야기가 잠깐 딴 길로 갔는데, 일단 3일동안 배운 내용 복습하는 겸 정리할 계획이다. 최종적으로는 이 글이 N531뒤에 오겠지만, 작성은 Section5에서 어떤 글보다 먼저했다...

그리고 오늘 빅데이터분석기사 필기접수로 디스코드에서 동기분들이 이야기하시던데 나는 일단 일반기계기사를 공부하면서 고민을 좀 해봐야겠다. 원래는 전공을 아예 내팽겨치고 분야를 갈아타려했는데, 그것보다는 내 전공을 살리면서 인공지능을 다루면 보다 더 좋을 것 같아서 일단 병행하면서 공부할 계획이다.

영어 공부도 하려고 시원스쿨 학습지도 샀는데... 공부할 것들은 쌓아놓고 해결하지 못하는 것 같다. 진짜 다시 정신차리고 열심히 살아보자...

❗️참고자료

1. 코드스테이츠 교육자료

ADsP자격증 시험도 신청했는데 허허허...그것도 지난주 목요일에 하루 공부하고 미루고 있다. 인터넷에 2주만에 따기 3일 공부하기 취득하기 이런 블로그 글들이 즐비하니까 뭔가 나도 할 수 있지 않을까 하는 생각에 마음이 느슨해지는 것 같다.

이번주 목요일부터는 다시 프로젝트 기간인데 그 전에는 컴퓨터 비전 쪽 노트는 다 정리해야지...

0. 학습목표

• Segmentation의 동작 방식 및 Semantic Segmentation/Instance Segmentation 을 구분하여 설명할 수 있다.
• Transpose Convolution의 필요성과 동작 방식에 대해 설명할 수 있다.
• 기존 모델을 사용하여 U-net 모델을 만든 코드를 이해하고 참고하여 다시 작성할 수 있다.
• Object Detection 의 2가지 방식과 지표에 대해 설명할 수 있다.
• Objection Detection 모델을 직접 구현한 코드를 보고 이해할 수 있다.
• U-net 을 직접 구현한 코드를 보고 이해할 수 있다.
• 여러 Object Detection 모델에 대해 알아보고 어떤 방식에 해당되는지 구분할 수 있으며 특정 모델의 적절한 예제를 선택하여 다른 데이터셋에 적용해 볼 수 있다.

  1. Segmentation(분할)

  

분할(Segmentation)은 위 이미지와 같이 하나의 이미지에서 같은 의미를 가지고 있는 부분을 구분해내는 Task이다.

이미지 분류에서는 이미지를 하나의 단위로 레이블을 예측하였다면 Segmentation은 더 낮은 단위로 분류한다. 위의 이미지에서 볼 수 있듯이 동일한 의미마다 해당되는 픽셀이 모두 레이블링 되어있는 데이터셋을 픽셀 단위에서 레이블을 예측하게 된다.

이런 Segmentation에서 같은 의미를 가지는 개체들을 동일하게 라벨링을 하는지, 아니면 각 개체마다 다르게 라벨링을 하는지에 따라서 2가지로 나눌 수 있다. 바로 Semantic Segmentation과 Instance Segmentation이다.

Semantic Segmentation & Instance Segmentation

Semantic Segmentation에서 각 픽셀은 위의 그림에서 보는 것처럼 픽셀이 속한 객체의 클래스로 분류된다. 그리고 클래스가 같은 물체는 따로 구별하지 않는다. 예를 들자면 차종이 다 다르더라도 모든 자동차는 "자동차"라는 클래스로 분류되는 것이다.

이 픽셀을 분류하는 작업에 있어서 어려운 점은 이미지가 일반적인 CNN을 통과할 때 점진적으로 위치 정보를 잃는다는 것이다. 따라서 보통의 CNN은 이미지 왼쪽 아래 어딘가에 사람이 있다고 알 수 있지만 그보다 더 정확히 알지 못한다.

이 문제를 해결하기 위한 다양한 접근 방법이 있고 어떤 솔루션은 매우 복잡하다. 하지만 조너선 롱 등이 2015년 발표한 논문에서 매우 단순한 해결책을 제시하였다. 바로 Fully Convolutional Networks(FCN)이다. 이는 따로 아래에서 더욱 자세히 다루도록 하겠다.

Instance Segmentation은 Semantic Segmentation과 비슷하지만 동일한 클래스 물체를 하나의 덩어리로 합치는 것이 아닌 각 물체를 구분하여 표시한다.

현재 텐서플로 모델 프로젝트에 포함된 인스턴스 분할 모델은 2017년 한 논문에서 제안된 Mask R-CNN이다. 이 모델은 Faster R-CNN모델을 확장하여 각 바운딩 박스에 대해 픽셀 마스크를 추가로 생성했다. 따라서 물체마다 클래스 추정 확률과 바운딩 박스를 얻는 것뿐만 아니라 바운딩 박스 안에 들어 있는 물체의 픽셀을 구분하는 픽셀 마스크도 얻을 수 있다.

2. Fully Convolutional Networks(FCN)

Fully Convolutional Networks(FCN)은 2015년 조너선 롱 등이 작성한 논문에서 처음 등장한 모델이다.

이 모델은 이미지 분류를 위한 신경망에 사용되었던 CNN의 분류기 부분, 즉 완전 연결 신경망(Fully Connected Layer)부분을 합성곱 층(Convolution Layer)로 대체한 모델이다.

앞서 말했듯이 Segmentation 은 픽셀 단위로 분류가 이루어지기 때문에 픽셀의 위치 정보를 끝까지 보존해주어야 한다. 하지만 CNN은 합성곱 층(Convolution Layer)을 통과할 때마다 이런 위치 정보를 잃게 된다. 이를 해결 하기 위해서 완전 연결 신경망(Fully Connected Layer)부분을 합성곱 층(Convolution Layer)로 대체한 것이다.

위 그림은 FCN의 구조를 도식화한 그림이다. 그림을 보면 이미지의 크기가 커지는 부분이 존재한다. 이는 Segmantation은 픽셀렬로 분류를 진행하기 때문에 마지막 층이 입력 이미지보다 작은 특성 맵을 출력한다. 이는 정보의 손실을 의미하기 때문에 원래 이미지와 비슷하게 크기를 키워주는(해상도를 늘리는) Upsampling을 해주어야 한다. 그리고 이런 Upsampling을 진행해주는 층을 Upsampling Layer라고 한다.

Upsampling

CNN에서 사용되는 것처럼 Convolution과 Pooling을 사용하여 이미지의 특징을 추출하는 과정을 Downsampling이라고 한다.

이와 반대로 원래 이미지 크기로 키우는 과정을 Upsampling(업샘플링)이라고 한다.

Upsampling에는 기존 Convolution과는 다른 Transpose Convolution이 적용된다. Transpose Convolution에서는 각 픽셀에 커널을 곱한 값에 Stride를 주어 나타냄으로써 이미지 크기를 키워나간다.

위는 2X2이미지가 입력되었을 때 3X3필터에 의하여 Transpose Convolution되는 과정을 나타낸 것이다.

❗ FCN 논문리뷰 https://medium.com/@msmapark2/fcn-%EB%85%BC%EB%AC%B8-%EB%A6%AC%EB%B7%B0-fully-convolutional-networks-for-semantic-segmentation-81f016d76204

3. U-Net

U-Net은 Biomedical분야에서 이미지 분할(Image Segmentation)을 목적으로 제안된 End-to-End방식의 FCN(Fully-Convolutional Network)기반 모델이다. 위의 이미지에서 볼 수 있듯이 네트워크의 구성 형태가 "U"자형 이라서 U-Net이라는 이름이 붙여졌다.

U-Net은 이미지의 전반적인 컨텍스트 정보를 얻기 위한 네트워크와 정확한 지역화(Localization)을 위한 네트워크가 대칭 형태로 구성되어 있다.

전반적인 컨텍스트 정보를 얻기 위한 네트워크는 Downsampling을 진행한다. 그리고 정확한 지역화를 위한 네트워크인 Expanding Path의 경우 Upsampling을 진행한다. Upsampling에서는 Convolution 과 Transpose Convolution을 거치면서 원본 이미지와 비슷한 크기로 복원한다.

다시 말하자면, Coarse Map(=Feature Map)에서 Dense Prediction을 얻기 위한 구조인 것이다. U-Net은 FCN(Fully convolutional network)을 토대로 확장한 개념이기 때문에 명확한 이해를 돕기 위해 우선적으로 FCN을 이해하는 것이 좋다.

또한 Coarse Map to Dense Map 개념 뿐만 아니라 U-Net은 FCN의 Skip Architecture 개념도 활용하여 얕은 층의 특징맵을 깊은 층의 특징맵과 결합하는 방식을 제안하였다. 위의 U-Net이미지의 사진을 보면 Copy and Crop이라고 색인되어 있는 회색 선을 볼 수 있다. 바로 이 부분이 Skip Architecture이다.

이러한 CNN 네트워크의 특성 계층의 결합을 통해 Segmentation이 내제하는 Localization과 Context(Semantic Information) 사이의 트레이드 오프를 해결할 수 있다.

이제 Contracting Path(Downsampling)과 Expanding Path에 대해서 더 자세히 알아보자.

Contracting Path

• 3X3 Convolutions을 두 차례씩 반복(패딩 없음)
• 활성화 함수는 ReLU 이용
• 2X2 max-pooling, 이때 stride는 2
• Down-sampling 마다 채널의 수를 2배로 늘림

Expanding Path

Expanding Path는 Contracting Path와 반대의 연산으로 특징맵을 확장한다.

• 2x2 convolution (“up-convolution”)
• 3x3 convolutions을 두 차례씩 반복 (패딩 없음)
• Up-Conv를 통한 Up-sampling 마다 채널의 수를 반으로 줄임
• 활성화 함수는 ReLU
• Up-Conv 된 특징맵은 Contracting path의 테두리가 Cropped된 특징맵과 concatenation 함
• 마지막 레이어에 1x1 convolution 연산

위와 같은 구성으로 총 23-Layers Fully Convolutional Networks구조이다. 주목해야하는 점은 최종출력인 Segmentation Map의 크기는 Input Image크기보다 작다는 것이다. Convolution연산에서 패딩을 사용하지 않았기 때문이다.

U-Net 정리에 있어서 이미지와 많은 글들을 아래 참고자료의 3번 블로그를 참조했다. 더 자세한 사항은 참고자료에서 링크를 통해 볼 수 있다.

💡 용어설명

• End-to-End 종단간 기계학습이라고도 불리며, 입력에서 출력까지 "파이프라인 네트워크"없이 신경망으로 한 번에 처리하는 방식을 의미한다.

  
  

• Dense Prediction Semantic Segmentation과 같은 의미로, 이미지의 각 픽셀이 어느 클래스에 속하는에 대해서 이미지 내의 모든 픽셀에 대해 예측을 진행하기 때문에 Segmentation을 Dense Prediction이라고 부르기도 한다.

• Localization과 Context(Semantic Information) 사이의 트레이드 오프를 해결할 수 있다? 일반적으로 이미지를 볼 때 패치를 슬라이딩 하면서 보게 된다. 이런 방식의 단점 중 하나가 바로 Localization 정확도와 Context정보간에 Trade-off가 발생한다는 것이다. 큰 패치를 사용하면 더 큰 Max-Pooling layer를 요구하는데 이는 localization accuracy를 감소시키게 되고, 그렇다고 패치를 작게하면 Context를 거의 활용하지 못하게 되는 것이다.
  

  쉽게 말하자면 작은 창으로 작은 부분까지 보면 그 픽셀의 위치정보를 정확히 알 수는 있지만, 그 옆에 뭐가있는지 큰 맥락은 알지 못하게 되는 것이다. 크게 보면 대충 이런 것들이 여기 있는지는 알지만 정확이 그 큰 창 안 어디에 있는지 알지 못하게 된다고 할 수 있다.

U-Net 예제 1.(수정된 U-Net)

TensorFlow의 공식문서를 참조하여 작성된 예제이다. 따라서 더 상세한 설명은 공식문서를 참고하면 볼 수 있다.

!pip install git+https://github.com/tensorflow/examples.git

import tensorflow as tf

import tensorflow_datasets as tfds

pip으로 설치해주는 것은 pix2pix라는 예제에서 구현된 업샘플 블록을 사용하기 위하여 설치해주는 것이다. 그 후 우선 텐서플로우와 데이터를 import해준다.

다음으로는 pix2pix와 시각화에 필요한 라이브러리를 import한다.

from tensorflow_examples.models.pix2pix import pix2pix

from IPython.display import clear_output
import matplotlib.pyplot as plt

이제 tfds를 통해서 Oxford-IIIT Pets데이터를 다운로드 하여 준다. 세분화 마스크는 버전 3+에 포함되어 있기 때문에 버전 3이상의 데이터를 다운로드한다.

이 데이터세트는 37개의 애완동물 품종의 이미지로 구성되어 있으며 품종당 200개의 이미지가 있다(훈련 및 테스트 분할에 각각 ~100개). 각 이미지에는 해당 레이블과 픽셀 단위 마스크가 포함된다. 여기서 마스크는 각 픽셀에 대한 클래스 레이블을 의미한다. 그리고 각 픽셀에는 세 가지 범주 중 하나가 지정된다.

• 클래스 1: 애완 동물에 속하는 픽셀
• 클래스 2: 애완동물과 접하는 픽셀
• 클래스 3: 위에 속하지 않음/주변 픽셀

이미지 색상 값은 [0,1] 범위로 정규화된다. 편의를 위해 세분화 마스크에서 1을 빼면 {0, 1, 2}와 같은 레이블이 생성된다.

dataset, info = tfds.load('oxford_iiit_pet:3.*.*', with_info=True)

def normalize(input_image, input_mask):
  input_image = tf.cast(input_image, tf.float32) / 255.0
  input_mask -= 1
  return input_image, input_mask

def load_image(datapoint):
  input_image = tf.image.resize(datapoint['image'], (128, 128))
  input_mask = tf.image.resize(datapoint['segmentation_mask'], (128, 128))

  input_image, input_mask = normalize(input_image, input_mask)

  return input_image, input_mask

데이터세트에는 이미 필요한 훈련 및 테스트 분할이 포함되어 있으므로 동일한 분할을 계속 사용하면 된다.

TRAIN_LENGTH = info.splits['train'].num_examples
BATCH_SIZE = 64
BUFFER_SIZE = 1000
STEPS_PER_EPOCH = TRAIN_LENGTH // BATCH_SIZE

train_images = dataset['train'].map(load_image, num_parallel_calls=tf.data.AUTOTUNE)
test_images = dataset['test'].map(load_image, num_parallel_calls=tf.data.AUTOTUNE)

그 후 이미지를 무작위로 뒤집어 간단한 이미지 증강을 수행한다.

class Augment(tf.keras.layers.Layer):
  def __init__(self, seed=42):
    super().__init__()
    # both use the same seed, so they'll make the same random changes.
    self.augment_inputs = tf.keras.layers.RandomFlip(mode="horizontal", seed=seed)
    self.augment_labels = tf.keras.layers.RandomFlip(mode="horizontal", seed=seed)

  def call(self, inputs, labels):
    inputs = self.augment_inputs(inputs)
    labels = self.augment_labels(labels)
    return inputs, labels

입력을 일괄 처리한 후에 증강을 적용하여 입력 파이프라인을 빌드한다. 이때 테스트 이미지에는 증강을 적용하지 않는다.

train_batches = (
    train_images
    .cache()
    .shuffle(BUFFER_SIZE)
    .batch(BATCH_SIZE)
    .repeat()
    .map(Augment())
    .prefetch(buffer_size=tf.data.AUTOTUNE))

test_batches = test_images.batch(BATCH_SIZE)

이미지 예제와 해당 이미지의 실제 마스크를 시각화 한다.

def display(display_list):
  plt.figure(figsize=(15, 15))

  title = ['Input Image', 'True Mask', 'Predicted Mask']

  for i in range(len(display_list)):
    plt.subplot(1, len(display_list), i+1)
    plt.title(title[i])
    plt.imshow(tf.keras.utils.array_to_img(display_list[i]))
    plt.axis('off')
  plt.show()

for images, masks in train_batches.take(2):
  sample_image, sample_mask = images[0], masks[0]
  display([sample_image, sample_mask])

이제 모델을 정의하여 준다. U-Net은 인코더(다운 샘플러)와 디코더(업샘플러)로 구성된다.

모델을 구성함에 있어서 사전학습 모델은 MobileNetV2를 인코더로 사용한다. 디코더의 경우에는 앞서 언급한 TensorFlow 예제 레포지토리의 Pix2Pix예제에서 이미 구현된 업샘플 블록을 사용한다.

인코더는 모델 중간 레이어에서 얻어지는 특정 출력으로 구성되며, 학습 과정에서 훈련하지 않고 사전 훈련된 가중치를 그대로 사용한다.

base_model = tf.keras.applications.MobileNetV2(input_shape=[128, 128, 3], include_top=False)

# Use the activations of these layers
layer_names = [
    'block_1_expand_relu',   # 64x64
    'block_3_expand_relu',   # 32x32
    'block_6_expand_relu',   # 16x16
    'block_13_expand_relu',  # 8x8
    'block_16_project',      # 4x4
]
base_model_outputs = [base_model.get_layer(name).output for name in layer_names]

# Create the feature extraction model
down_stack = tf.keras.Model(inputs=base_model.input, outputs=base_model_outputs)

down_stack.trainable = False

다음은 디코더(다운샘플러)의 코드이다.

up_stack = [
    pix2pix.upsample(512, 3),  # 4x4 -> 8x8
    pix2pix.upsample(256, 3),  # 8x8 -> 16x16
    pix2pix.upsample(128, 3),  # 16x16 -> 32x32
    pix2pix.upsample(64, 3),   # 32x32 -> 64x64
]

이제 앞에서 정의한 인코더와 디코더를 이용하여 U-Net모델을 생성한다. 이때 마지막 레이어의 필터 수는 Output_channels수로 설정된다. 이것은 클래스당 하나의 출력 채널이 된다.

def unet_model(output_channels:int):
  inputs = tf.keras.layers.Input(shape=[128, 128, 3])

  # Downsampling through the model
  skips = down_stack(inputs)
  x = skips[-1]
  skips = reversed(skips[:-1])

  # Upsampling and establishing the skip connections
  for up, skip in zip(up_stack, skips):
    x = up(x)
    concat = tf.keras.layers.Concatenate()
    x = concat([x, skip])

  # This is the last layer of the model
  last = tf.keras.layers.Conv2DTranspose(
      filters=output_channels, kernel_size=3, strides=2,
      padding='same')  #64x64 -> 128x128

  x = last(x)

  return tf.keras.Model(inputs=inputs, outputs=x)

이제 모델을 컴파일하고 훈련한다. 이때 이번 예제는 다중 클래스 분류 문제이기 때문에 from_logits인수가 True로 설정된 tf.keras.losses.CategoricalCrossentropy손실 함수를 사용한다. 레이블은 모든 클래스의 각 픽셀에 대한 점수 벡터가 아닌 정수 스칼라이기 때문이다.

OUTPUT_CLASSES = 3

model = unet_model(output_channels=OUTPUT_CLASSES)
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

tf.keras.utils.plot_model을 사용하면 모델 아키텍처를 볼 수 있다.

tf.keras.utils.plot_model(model, show_shapes=True)

다음으로 각 픽셀에 값이 가장 높은 채널을 할당하는 Create_mask함수를 생성한다.

def create_mask(pred_mask):
  pred_mask = tf.math.argmax(pred_mask, axis=-1)
  pred_mask = pred_mask[..., tf.newaxis]
  return pred_mask[0]

모델을 훈련하기 전에 기본적인 모델이 어떻게 예측하는지 확인해보기 위해서 다음 코드를 실행해 볼 수 있다.

def show_predictions(dataset=None, num=1):
  if dataset:
    for image, mask in dataset.take(num):
      pred_mask = model.predict(image)
      display([image[0], mask[0], create_mask(pred_mask)])
  else:
    display([sample_image, sample_mask,
             create_mask(model.predict(sample_image[tf.newaxis, ...]))])

show_predictions()

다음으로 모델이 훈련되는 동안 어떻게 개선되는지 관찰하기 위하여 콜백함수를 선언하여 준다.

class DisplayCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs=None):
    clear_output(wait=True)
    show_predictions()
    print ('\nSample Prediction after epoch {}\n'.format(epoch+1))

EPOCHS = 20
VAL_SUBSPLITS = 5
VALIDATION_STEPS = info.splits['test'].num_examples//BATCH_SIZE//VAL_SUBSPLITS

model_history = model.fit(train_batches, epochs=EPOCHS,
                          steps_per_epoch=STEPS_PER_EPOCH,
                          validation_steps=VALIDATION_STEPS,
                          validation_data=test_batches,
                          callbacks=[DisplayCallback()])

실제로 코드를 구동시켜보면 각 에포크에 따라서 점점 Predicted Mask가 변하는 것을 확인할 수 있다.

다음으로 Train세트의 Loss와 Validation세트의 Loss를 확인하는 그래프를 출력하는 함수를 생성하여 준다.

loss = model_history.history['loss']
val_loss = model_history.history['val_loss']

plt.figure()
plt.plot(model_history.epoch, loss, 'r', label='Training loss')
plt.plot(model_history.epoch, val_loss, 'bo', label='Validation loss')
plt.title('Training and Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss Value')
plt.ylim([0, 1])
plt.legend()
plt.show()

이제 훈련이 끝났기 때문에 다음과 같이 예측을 진행할 수 있다.

show_predictions(test_batches, 3)

위에 작성한 코드는 살짝 수정된 U-Net으로 실제 U-Net의 구조와는 약간의 차이가 존재한다.

좌측은 위의 코드로 만든 모델이고, 우측이 실제 U-Net의 구조이다. 따라서 실제 U-Net과 같은 구조로 만들기 위해서는 다음과 같은 코드로 U-Net을 구축할 수 있다.

먼저 Conv2D-ReLU-Conv2D-ReLU로 구성된 층을 만드는 함수를 생성하여 준다. 이 함수는 인코더와 bottleneck에 사용된다.

def double_conv_block(x, n_filters):

   # Conv2D then ReLU activation
   x = layers.Conv2D(n_filters, 3, padding = "same", activation = "relu",
   kernel_initializer = "he_normal")(x)
   # Conv2D then ReLU activation
   x = layers.Conv2D(n_filters, 3, padding = "same", activation = "relu",
   kernel_initializer = "he_normal")(x)

   return x

다음으로는 특징 추출을 위한 다운샘플러를 만들어 주는 함수를 생성한다.

def downsample_block(x, n_filters):
   f = double_conv_block(x, n_filters)
   p = layers.MaxPool2D(2)(f)
   p = layers.Dropout(0.3)(p)

   return f, p

마지막으로 디코더에 사용되는 업샘플링 함수를 생성하여 준다.

def upsample_block(x, conv_features, n_filters):
   # upsample
   x = layers.Conv2DTranspose(n_filters, 3, 2, padding="same")(x)
   # concatenate
   x = layers.concatenate([x, conv_features])
   # dropout
   x = layers.Dropout(0.3)(x)
   # Conv2D twice with ReLU activation
   x = double_conv_block(x, n_filters)

   return x

이제 위에서 만든 함수들을 이용하여 U-Net의 구조를 생성하여 준다.

def bulid_unet_model():
 # inputs
   inputs = layers.Input(shape=(128,128,3))

   # encoder: contracting path - downsample
   # 1 - downsample
   f1, p1 = downsample_block(inputs, 64)
   # 2 - downsample
   f2, p2 = downsample_block(p1, 128)
   # 3 - downsample
   f3, p3 = downsample_block(p2, 256)
   # 4 - downsample
   f4, p4 = downsample_block(p3, 512)

   # 5 - bottleneck
   bottleneck = double_conv_block(p4, 1024)

   # decoder: expanding path - upsample
   # 6 - upsample
   u6 = upsample_block(bottleneck, f4, 512)
   # 7 - upsample
   u7 = upsample_block(u6, f3, 256)
   # 8 - upsample
   u8 = upsample_block(u7, f2, 128)
   # 9 - upsample
   u9 = upsample_block(u8, f1, 64)

   # outputs
   outputs = layers.Conv2D(3, 1, padding="same", activation = "softmax")(u9)

   # unet model with Keras Functional API
   unet_model = tf.keras.Model(inputs, outputs, name="U-Net")

   return unet_model

위와 같이 작성하면 실제 U-Net모델을 구현할 수 있다. 이때 자세한 사항은 코드를 긁어온 사이트를 참고하자.

💡 코드사이트 주소 https://pyimagesearch.com/2022/02/21/u-net-image-segmentation-in-keras/

4. Obejct Detection(객체 탐지/인식)

하나의 이미지에서 여러 물체를 분류하고 위치를 추정하는 작업을 Object Detection(객체 탐지)라고 한다.

과거에 널리 사용되던 방식은 하나의 물체를 분류하고 위치를 찾는 분류기를 훈련한 다음에 이미지 전체를 훑는 방식을 주로 사용했다. 이 방식은 매구 간단하지만 조금씩 다른 위치에서 동일한 물체를 여러번 감지하기 때문에 불필요한 바운딩 박스를 제거하기 위한 사후 처리가 필요하다. 흔히 사용하는 방법으로는 NMS^{non-max suppression}이 있다.

이런 간단한 객체 탐지 방식은 상당히 잘 동작하지만 CNN을 여러 번 실행시켜야 해서 많이 느리다는 단점이 있다. 다행히 앞에서 다룬 FCN(완전 합성곱 신경망)을 사용하면 CNN을 훨씬 빠르게 이미지에 슬라이딩 시킬 수 있다.

대표적인 객체 탐지 모델은 아래와 같이 발전하여 왔다.

객체 탐지 모델들은 어떤 단계를 거쳐 분류가 진행되는지에 따라서 Two Stage방식과 One Stage방식으로 나눌 수 있다.

One Stage Dector

One Stage Detector는 특정 지역을 추천받지 않고 입력 이미지를 Gride등의 같은 작은 공간으로 나눈 뒤에 해당 공간을 탐색하며 분류를 수행하는 방식이다. 즉, Regional Proposal과 Classification이 동시에 이루어지는 것이다.

그림으로는 아래와 같이 나타낼 수 있다.

지역 추천을 먼저 받지 않고 동시에 이루어지기 때문에 Two stage방식보다는 빠르다는 장점이 있다. 하지만 빠른만큼 정확도가 낮다는 단점이 존재한다.

대표적인 모델로는 SSD(Single Shot multibox Detector)계열과 최근 자율주행 등에서 각광을 받고있는 YOLO(You Only Look Once)계열의 모델이 있다.

Two Stage Dector

Two Stage Detector는 일련의 알고리즘을 통해서 객체가 있을 만함 곳을 추천받은(Regional Proposal) 뒤에 추천받은 Region, 즉 RoI(Region of Interest)에 대해 분류를 수행하는 방식이다.

앞에서도 언급하였지만 Regional Proposal 이란 기존에 이미지를 탐색하는 방식의 비효율성을 개선하기 위하여 등장한 것이다. 기존에는 이미지에서 object detection을 위해 sliding window방식을 이용했었다. Sliding window 방식은 이미지에서 모든 영역을 다양한 크기의 window (differenct scale & ratio)로 탐색하는 것이다. 말 그대로 모든 영역을 탐색하기 때문에 물체가 없는 부분까지 탐색하여 비효율적이다.

이런 비효율성을 개선하기 위해서 "물체가 있을만한"영역을 빠르게 찾아내는 알고리즘들을 Region proposal이라고 하며, 대표적으로 Selective search, Edge boxes들이 있다.

Two Stage Dector를 그림으로 나타내면 다음과 같이 나타낼 수 있다.

대표적인 Two stage모델로는 R-CNN계열(R-CNN,Fast R-CNN, Faster R-CNN 등)의 모델이 있다.

객체 탐지 성능지표(IoU, mAP)

객체 탐지의 결과는 우리가 지금까지 사용한 지표와는 다른 지표를 사용한다. IoU(Intersection over Union)과 mAP(mean Average precision)이 그 예이다.

IoU

위 그림의 초록색 박스처럼 정답에 해당하는 Bounding Box를 Ground-truth라고 한다. 모델이 빨간색 박스처럼 예측했을 때 IoU는 다음과 같은 식을 사용하여 구할 수 있다.

IoU 를 사용하면 객체가 포함되어 있지만 너무 큰 범위를 잡는 문제를 해결할 수 있다. 아래 그림은 Ground-truth/Prediction에 해당하는 Bounding Box 에 따라 IoU가 구해지는 예시를 나타내고 있다.

mAP

객체 탐지에서 널리사용되는 성능지표이다. "Mean Average"라는 표현은 의미가 중복된 것처럼 보인다.

이 지표를 이해하기 위해서는 정밀도와 재현율을 이해하고 있어야 한다. 이 두 지표는 Trade-off관계에 있다. 따라서 이 두 값을 정밀도/재현율 곡선으로 그려볼 수 있다. 이 곡선을 하나의 숫자로 요약하려면 곡선의 아래 면적(AUC)를 계산한다.

하지만 정밀도/재현율 곡선에서 재현율이 증가할 때 정밀도도 상승하는 영역이 포함될 수 있다. 특히 재현율 값이 낮을 때 그러하다. 이것이 바로 mAP지표가 만들어진 이유 중 하나이다.

한 분류기가 10%재현율에서 90% 정밀도를 달성하고 20% 재현율에서는 96%의 정밀도를 달성한다고 가정해보자. 여기서는 Trade-off가 없다. 재현율과 정밀도가 모두 상승하기 때문에 10%재현율보다는 20%재현율의 분류기를 사용하는 것이 당연하다. 따라서 10% 재현율에서 정밀도를 보는 것이 아니라 최소 10%재현율에서 분류기가 제공할 수 있는 최대 정밀도를 찾아야 한다. 이값은 90%가 아니라 96%이다. 따라서 공정한 모델의 성능을 측정하는 한 가지 방법은 최소 0% 재현율에서 얻을 수 있는 최대 정밀도, 그 다음 10%, 20%에서 100%까지 재현율에서의 최대 정밀도를 계산한다. 그 다음 이 최대 정밀도를 평균한다. 이를 평균 정밀도^{average precision}(AP)라고 부른다. 만일 두 개 이상의 클래스가 있다면 각 클래스에 대해 AP를 계산단 다음 평균 AP를 계산한다. 이것이 바로 mAP이다.

객체 탐지의 경우 조금 더 복잡해진다. 시스템에 정확한 클래스를 탐지했지만 위치가 잘못됐다면 이는 올바른 예측으로 볼 수 없다. 이를 위한 한 가지 방법은 IOU임계점을 정의하는 것이다. 예를 들어 IoU가 0.5보다 크고 예측 클래스가 맞다면 올바른 예측으로 간주한다. 이에 해당하는 mAP는 일반적으로 mAP@0.5라고 쓴다.

❗ 참고자료

1. 오렐리앙 제옹, 핸즈온 머신러닝(2판), 서울:한빛미디어,O⋅REILLY, 2020
2. CodeStates Lecture Note - N432
3. U-Net논문 리뷰
4. Semantic Segmentation
5. mAP

Level 1.

• CNN(Convolutional Neural Network)의 기본 구조에 대해 설명할 수 있다.
• Convolution & Pooling Layer 의 동작 방식과 조정할 수 있는 값(Stride, Padding 등)에 대해 설명할 수 있다.
• 전이 학습(Transfer Learning)을 설명할 수 있으며 이미지 처리를 위한 대표적인 사전 학습 모델을 2개 이상 설명할 수 있다.
• 직접 CNN 모델을 구축하거나 사전 학습 모델을 사용하여 이미지 분류를 하는 코드를 작성할 수 있다.

  Level 2.

• CNN 층이 깊어졌을 때의 장점에 대해 설명할 수 있다.
• 이미지 데이터 증강(Image Data Augmentation)의 개념에 대해 이해하고 실제 학습에 적용하는 코드를 작성할 수 있다.

  Level 3.

• 최근 발표되고 있는 이미지 분류를 위한 사전 학습 모델에는 어떤 것이 있는지 나열하고 각 모델의 특징에 대해 설명할 수 있다.

1. CNN(Convolution Neural Network)

합성곱 신경망^{Convolution Neural Network}(CNN)은 대뇌의 시각피질 연구에서 시작되었고 1980년대부터 이미지 인식 분야에 사용되었다. 본격적으로 주목받은 시기는 2012년으로, 2012년 이미지넷(ImageNet) 데이터셋 분류 경진대회인 ILSVRC에서 AlexNet이라는 알고리즘이 우승하였기 때문이다.

이미지는 위치에 맞는 공간적인 특성이 존재한다. 하지만 앞 서 N41~에서 배운 다층 퍼셉트론 신경망(MLP)은 모든 입력 값을 Flatten으로 펴준 뒤에 연산하기 때문에 이런 공간적인 특성을 살려내지 못한다. MNIST 데이터 처럼 간단한 이미지 데이터는 MLP로도 분류가 가능하지만 패턴이 복잡한 컬러 이미지를 이런 방식으로 분류하는 것은 쉽지 않다.

반면 CNN은 학습 과정에서 이런 공간적 특성을 보존하면서 학습할 수 있기 때문에 층이 깊어지더라도 공간적인 특성을 보존할 수 있다는 장점 때문에 이미지 분류에서 주목받기 시작하였다.

본격적인 CNN의 구조를 알아보기 전에 CNN이 시작된 근본인 시각 피질 구조에 대해 먼저 알아보겠다.

시각 피질 구조

시각 피질 안의 많은 뉴런이 작은 국부 수용장^{local receptive field}을 가진다는 것을 데이비드 허블과 토르스텐 비셀이 1958~1959년 사이에 진행한 고양이 실험과 원숭이 실험을 통해서 밝혀냈다. 다시 말하자면 뉴런들이 시야의 일부 범위 안에 있는 시각 자극에만 반응한다는 것이다.

뉴런의 수용장들은 서로 겹칠 수 있어서, 합치면 전체 시야를 감싸게 된다. 또한 두 뉴런이 동일한 수용장을 가진다 하더라도 어떤 뉴런은 수평선의 이미지에만 반응하고 반면 다른 뉴런은 다른 각도의 선분에 반응한다는 점을 보였다. 또한 어떤 뉴런은 큰 수용장을 가져서 저수준 패턴이 조합된 더 복잡한 패턴에 반응한다는 것을 밝혔다. 이를 통해서 고수준 뉴런이 이웃한 저수준 뉴런의 출력에 기반한다는 아이디어를 이끌어냈다. 즉, 각 뉴런은 이전 층에 있는 몇 개의(이웃한) 뉴런에만 연결된다는 것이다. 이러한 강력한 구조가 전체 시야 영역에 포함된 모든 종류의 복잡한 패턴을 감지할 수 있게 한다.

시각 피질에 대한 이런 연구를 통해 얻은 아이디어가 지금의 CNN으로 점진적으로 진화되었다. 그로다 1998년에 발표된 얀 르쿤 등의 논문 "Gradien-Based Learning Applied to Document Recognition"이 이미지 분류의 중요한 전환점이 되었다. 이 논문에서는 수표에 쓰인 손글씨 숫자를 인식하는데 널리 사용된 유명한 LeNet-5 구조를 소개했다. 이 구조에서 안 르쿤 교수는 위에서 말한 고수준 뉴런이 이웃한 저수준 뉴런의 출력에 기반한다는 아이디어를 통해서 획기적인 인공신경망을 고안해냈고, 이것이 바로 합성곱 신경망^{Convolution Neural Network}(CNN)이다.

CNN 구조

기본적인 CNN의 구조는 위의 그림과 같이 특징 추출 부분(Conv-Pooling)과 분류를 위한 신경망, 2단계로 나눌 수 있다. 먼저 특징이 추출되는 합성곱 층(Covolution Layer)과 풀링 층(Pooling Layer)에 대해서 알아보자.

합성곱 층^{convolution Layer}

합성곱 층에서는 합성곱 필터(Convolution Filter)가 **슬라이딩(Sliding)하며 이미지 부분부분의 특징을 읽어나간다. 한 번에 여러개가 보이니, 보기 어려울 수 있으니 정지돈 상황에서의 예시를 살펴보겠다.

Gif를 통해서 같은 방식으로 9번의 연산이 이뤄지며, 9칸이 모두 채워지는 것을 확인할 수 있다. 그리고 바로 위의 그림을 통해서 각 Patch단위로 어떠한 방식으로 합성곱이 연산되는지를 확인할 수 있다.

위 두 그림을 잘 살펴보면 입력 이미지의 모든 픽셀에 한 번에 연결하는 것이 아니라 합성곱 층 뉴런의 수용장(=Filter)안에 있는 픽셀에만 연결되고, 이를 합성곱을 통해서 다시 전체 이미지의 Convoluted Feature를 구성하는 것을 볼 수 있다. 이런 구조는 네트워크가 이미지의 작은 저수준 특성에 집중하고, 그 후 더 큰 고수준 특성으로 조합해나가도록 도와준다. 이런 계층적 구조는 실제 이미지에서 흔히 볼 수 있으며, 이는 CNN이 이미지 인식에서 잘 작동하는 이유 중 하나이다.

뉴런의 수용장. 즉, Filter는 하나의 특성 맵을 만들고, 이 맵은 필터를 가장 크게 활성화시키는 이미지의 영역을 강조한다. 물론 수동으로 필터를 정의할 필요는 없다. 필터의 크기와 필터의 수만 정의하면 훈련하는 동안 합성곱 층이 자동으로 해당 문제에 가장 유용한 필터를 찾고 상위층은 이들을 연결하여 더 복잡한 패턴을 학습하게 된다.

다음으로는 합성곱 층에 적용할 수 있는 패딩(Padding)과 스트라이드(Stride)에 대해서 알아보도록 하겠다.

패딩^Padding

패딩은 이미지 외부를 특정한 값으로 둘러싸서 처리해주는 방식이다. 보통 0으로 둘러싸주는 Zero-Padding이 가장 많이 사용된다. Padding을 사용하는 이유는 연산되어 나오는 Output, 즉 Feature map의 크기를 조절하고 실제 이미지 값을 충분히 활용하기 위해서이다.

만약 Padding이 되어있지 않다면 가장 첫번째 칸에 들어있는 값은 1번만 사용된다. 마지막 칸도 마찬가지이다. 이는 담고있는 정보가 충분히 활용되지 못한 것이다. 하지만 Padding을 한 후에 합성곱을 진행하면 정보를 충분히 활용할 수 있게 된다.

Padding의 형식은 3가지가 있다. 하지만 사실상 Vaild의 경우에는 패딩을 진행하지 않는 것이다. Same의 경우에는 상하좌우에 행과 열을 1줄씩 추가하는 것이다. 이렇게 하면 입력값과 출력값의 크기가 동일하게 출력된다. Full의 경우에는 필터의 크기만큼 상하좌우에 행과 열을 추가하는 것이다. 이 경우 정보가 더 많이 활용되며, 입력보다 출력의 크기가 더 커지게 된다.

Keras에서는 Valid또는 same 두가지 방식만 지원한다.

스트라이드^Stride

스트라이드(Stride)는 "보폭"이라는 뜻을 가진 단어이다. Stride를 조절하면 슬라이딩(Sliding)시에 몇 칸 씩 건너뛸지를 나타낸다. 위에서 본 gif파일은 스트라이드가 1인 경우이다.

Keras에서는 튜플 형태로 이를 전달하며 기본 Default값은 (1,1)이다. 즉 가로로 1칸씩 이동하면서, 끝에 도달하면 그 다음 1줄 내려간 후에 다시 가로로 이동하게된다.

위의 그림의 경우로 말하자면 첫 번째는 Stride=(1,1)인 경우이고, 두 번째는 Stride=(2,2)라고 할 수 있다.

위에서 다룬 Padding과 Stride 그리고 Filter Size에 따라서 Feature map의 크기가 달라진다. 여기서 Feature Map은 Convoluted Feature와 같은 의미로 합성곱에 의한 출력을 의미한다. 그리고 이 Feature map의 크기 공식은 다음과 같다. $$$ N_{\text{out}} = \bigg[\frac{N_{\text{in}} + 2p - k}{s}\bigg] + 1 $$$

• $N_{\text{in}}$: 입력되는 이미지의 크기(=피처 수)

• $N_{\text{out}}$: 출력되는 이미지의 크기(=피처 수)
• $k$: 합성곱에 사용되는 커널(=필터)의 크기
• $p$: 합성곱에 적용한 패딩 값
• $s$: 합성곱에 적용한 스트라이드 값

풀링^Pooling

어떻게 합성곱 층이 작동하는지 이해했다면 풀링 층^{Pooling layer}은 매우 쉽게 이해할 수 있다. 이 층의 목적은 계산량과 메모리 사용량, (결과적으로 과대적합의 위험을 줄여주는) 파라미터 수를 줄이기 위해 입력 이미지의 부표본(Subsample), 즉, 축소본을 만드는 것이다.

풀링 방법에는 최대 풀링(Max Pooling)과 평균 풀링(Average Pooling)이 있다. 최대 풀링은 정해진 범위 내에서 가장 큰 값을 꺼내오는 방식이며, 평균 풀링은 정해진 범위 내에 있는 모든 요소의 평균을 가져오는 방식이다. 풀링의 방식을 살펴보면 가중치가 존재하지 않는다는 것을 알 수 있다. 단순히 값을 꺼내올 뿐인 것이다. 또한 채널 수 역시 변하지 않는다. 보통 최대 풀링이 평균 풀링보다 성능이 더 좋기 때문에 최대 풀링을 주로 사용한다.

합성곱 층에서와 마찬가지로 풀링 층의 각 뉴련은 이전 층의 작은 사각 영역의 수용장 안에 있는 뉴런의 출력과 연결되어 있다. 이전과 동일하게 크기, 스트라이드, 패딩 유형을 지정해야 한다. 이때 보통 크기와 스트라이드를 동일하게 설정한다.

아래 그림은 2X2크기의 최대 풀링과 평균 풀링을 처리하는 과정을 비교하여 나태낸 것이다.

위 그림에서 왼쪽은 최대 풀링으로 각각의 2×2의 범위 내에서 가장 큰 요소인 100,184,12,45 출력 데이터로 가져온다. 오른쪽은 평균 풀링으로 각각의 2×2의 범위 내 요소의 평균값인 36,80,12,15 를 출력 데이터로 가져온다.

계산량, 메모리 사용량, 파라미터 수를 감소하는 것 외에도 최대 풀링의 경우 작은 변화에도 일정 수준의 불변성을 만들어 준다.

위 그림에서 볼 수 있듯이 8이라는 형태가 전체 픽셀에서 어느 정도 이동하더라도 풀링 층을 거친 결과는 동일하다는 것을 볼 수 있다. 이를 이동 불변성이라고 한다. CNN에서 몇 개 층마다 최대 풀링 층을 추가하면 전체적으로 일정 수준의 이동 불변성을 얻을 수 있다. 또한 최대 풀링은 회전과 확대, 축소에 대해서 약간의 불변성을 제공한다. 이와 같은 불변성은 제한적이긴 하지만 분류 작업처럼 예측이 이런 작은 부분에서 영향을 받지 않는 경우 유용할 수 있다.

하지만 이 풀링은 단점 역시 가지고 있다. 풀링을 진행하게 되면 입력값의 정보가 일부 사라지게 된다. 대체로 최대 풀링이 평균 풀링보다 더 많은 정보 손실을 가져온다. 그리고 최대 풀링의 불변성의 경우에는 어떤 어플리케이션에서는 불필요하기 때문에 목표하는 어플리케이션의 기능이나 Task에 맞게 풀링을 사용할지 안할지 결정해야 한다.

💡 추가 내용 위에서 말한 2가지의 풀링 층 외에도 현대적인 신경망 구조에서 볼 수 있는 전역 평균 풀링 층(GAP)이라는 풀링 층이라는 것도 존재한다. 이 층은 동작 방식이 매우 독특하다. 각 Feature map의 평균을 계산한다. 위 그림에서 볼 수 있듯이, 각 샘플의 Feature map마다 하나의 숫자를 출력한다는 것이다. 이 방식은 엄청난 정보 손실을 가져오지만 출력층에서는 유용할 수 있다.
이런 출력 층을 만들려면 keras.layers.GlobalAvgPool2D클래스를 사용하면 된다.

완전 연결 신경망(Fully Connected Layer)

합성곱 층(Convolutional Layer)와 풀링 층(Pooling Layer)에서 충분히 특징을 추출했다면, 다음은 분류를 위한 완전 연결 신경망을 구축할 차례이다.

완전 연결 신경망은 여러분이 이전에 구축했던 다층 퍼셉트론 신경망으로 구성되어 있으며 풀어야 하는 문제에 따라서 출력층을 잘 설계해주는 것이 중요하다.

2. CNN의 학습

CNN에서 학습되는 부분은 바로 Convolution 층에 있는 Filter의 가중치와 편향, 완전 연결 신경망을 구성하는 다층 퍼셉트론 신경망의 가중치와 평향이다.

학습된 필터를 시각화하면 아래의 그림과 같은 형태로 나타난다. 참고로 아래의 그림은 ImageNet 데이터를 학습한 CNN의 Convolution층의 Filter의 가중치를 시각화한 것이다.

층이 깊어지면 Convolution 층과 Pooling 층을 거치면서 이미지가 작아지고 Convolution 층의 Filter는 더 큰 특징을 포착하게 된다.

위 그림을 보면 낮은 층에서는 단순하게 가로, 세로, 대각선 등의 특징을 학습하는 것을 볼 수 있고, 층을 지날수록 물체의 일부분을 포착하면서 결국 물체 전체의 윤곽에 해당하는 특징을 학습하는 것을 알 수 있다.

CNN 학습 example

일반적인 이미지를 10개의 클래스로 분류하는 데이터셋인 Cifal 10 데이터셋을 직접 구축한 CNN을 통하여 분류하는 예제를 풀어보겠다.

먼저 필요한 패키지와 라이브러리를 불러오고, 시드를 고정한다.

from tensorflow.keras.datasets import cifar10
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.models import Sequential
from tensorflow.keras.datasets import cifar10

from sklearn.model_selection import train_test_split

import numpy as np
import tensorflow as tf

np.random.seed(42)
tf.random.set_seed(42)

그 후 데이터셋을 불러온 후 학습 데이터셋(Train Dataset)과 시험 데이터셋(Test Dataset)으로 나누어(Split)주고 픽셀값을 정규화 하여준다.

# 데이터 불러오기
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# 픽셀값 정규화
X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.

# 데이터셋 Split
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=.2)

이제 본격적으로 신경망 모델을 구축해 보겠다. 3개의 Convolution 층 사이에 Pooling 층을 끼워넣어 특징 추출 부분을 구성하고, 1개의 은닉층과 출력층으로 구성된 완전 연결 신경망으로 분류기를 구축하여 보겠다.

# 모델 구축
model = Sequential()

# Conv-Pool layer 특징을 추출하는 부분
model.add(Conv2D(32, (3,3), padding='same', activation='relu'))
model.add(MaxPooling2D(2,2))
model.add(Conv2D(64, (3,3), padding='same', activation='relu'))
model.add(MaxPooling2D(2,2))
model.add(Conv2D(64, (3,3), padding='same', activation='relu'))

# Dense layer에 입력 가능하도록 Data 펼치기
model.add(Flatten())

# 분류를 위한 신경망 구성
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))

Conv2D에 대해서 조금 더 자세히 살펴보면 다음과 같다.

tf.keras.layers.Conv2D(
    filters,
    kernel_size,
    strides=(1, 1),
    padding='valid',
    data_format=None,
    dilation_rate=(1, 1),
    groups=1,
    activation=None,
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='zeros',
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    **kwargs
)

• filters: 정수로 Output shape의 차원을 결정한다. 더 쉽게 말하면 filter의 수를 의미한다.

• kernel_size: 필터의 크기를 지정

  위 두가지 파라미터에 대해서 조금 더 자세히 다루어 보겠다. Conv2D Layer를 지나게 되면 기본적으로 Chanel의 수가 filters에 입력된 수로 변하게 된다. 그 과정은 다음과 같다고 할 수 있다.

  

  1개의 feature map은 다음과 같이 계산됩니다.

  1. 각각의 channel에 대응되는 kernel을 통해 슬라이딩

2. 각 channel의 결과를 모두 더한다 → 하나의 feature map 생성
3. 헤딩 과정을 생성하려는 feature map의 수만큼 반복

   그림에서 볼 수 있듯이 각 필터에는 입력된 채널에 대응하는 커널이 존재하고, 이 커널의 합으로 결국에 하나의 Ouput을 만들어 낸다. 그리고 이 Output을 결국 필터의 수 만큼 반복하기 때문에 Filters의 값이 출력값의 차원, 즉 Channel수가 된다.

• Padding: padding 방식 지정, vaild와 same을 사용할 수 있다.

이제 모델을 컴파일하고 훈련 시켜 준다.

# 모델 컴파일
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
# 모델 훈련
model.fit(X_train, y_train,
          batch_size=128,
          validation_data=(X_val, y_val),
          epochs=10)

이 학습한 신경망 모델을 사용하여 성능을 평가한다.

model.evaluate(X_test, y_test, verbose=2)

3. 전이학습(Transfer Learning)

신경망의 계층 구조는 심층 신경망이 좋은 솔루션으로 빠르게 수렴하게끔 도와줄 뿐만 아니라 새로운 데이터에 일반화되는 능력도 향상시켜준다.

이런 계층 구조를 가진 새로운 신경망을 구축 할 때 처음에 가중치와 편향을 난수로 초기화 하는 대신에 사전 학습 모델(Pre-Trained Model)의 가중치를 그대로 가져와 사용하면 대부분의 사진과 같은 데이터에 나타나는 저수준 구조를 학습할 필요가 없게 된다. 즉, 고수준 구조만 학습하면 된다. 이를 전이 학습^{Transfer Learning}이라고 한다.

사전 학습 모델의 가중치는 대량의 데이터를 학습하여 얻어진다. 여러 데이터의 일반적인 특징을 많이 학습하였기 때문에 어떠한 데이터를 넣더라도 준수한 성능을 보인다. 일반적으로 사전 학습 가중치는 학습되지 않도록 고정(freeze)한 채로 진행되기 때문에 빠르게 좋은 결과를 얻을 수 있다는 장점이 있다.

이미지 분류를 위한 주요 사전 학습 모델로는 다음과 같은 것들이 있다. 블로그 정리 글을 링크로 남겨두었으니 나중에 복습할 때 참고하자.

❗ 사전 학습 모델

1. VGG - VGG 논문
2. GoogLeNet(Inception) - GoogLeNet 논문 _{Inception에 대해서 다시 또 고찰한 _"Rethinking the Inception Architecture for Computer Vision"_라는 논문도 있다. Inception은 가로 방향으로 층을 넓게 구성한 구조를 의미한다.}
3. ResNet - Resnet 논문 _{ResNet에서는 Residual Connection(=Skipped Connection)라는 중요한 특징이 있으니 추후 복습 시에 이 부분을 찾아보자.}

전이학습 예제

# 패키지 및 라이브러리 불러오기
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Sequential
from tensorflow.keras.datasets import cifar10

from sklearn.model_selection import train_test_split

import numpy as np
import tensorflow as tf

# Seed 고정
np.random.seed(42)
tf.random.set_seed(42)

# 데이터셋 불러오기
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# 픽셀값 정규화
X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.

# 데이터셋 Split
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=.2)

이제 다음 코드로 사전 학습된 모델(VGG16)을 불러온다.

pretrained_model = VGG16(weights='imagenet', include_top=False)

이제 사전 학습 모델 위에 완전 연결 신경망을 추가한다. 이때 GlobalAveragePooling2d()층은 Flatten과 비슷한 역할을 수행하는 층으로 데이터의 Shape을 (None, None, None, 512)에서 (None, 512)로 변화시켜주는 역할을 한다.

# 완전 연결 신경망 추가하여 모델 생성
model = Sequential()
model.add(pretrained_model)
model.add(GlobalAveragePooling2D())
model.add(Dense(128,activation='relu'))
model.add(Dense(10,activation='softmax'))

# 모델 컴파일
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 모델 훈련
model.fit(X_train, y_train,
          batch_size=128,
          validation_data=(X_val, y_val),
          epochs=10)

# 신경망 모델을 사용하여 평가
model.evaluate(X_test, y_test, verbose=2)

4. 이미지 증강

이미지 증강이란 회전, 반전, 자르기 ,밝기 혹은 채도 변화 등을 통하여 데이터를 늘리는 방법이다.

인간은 쉽지 않게 위 두 이미지를 고양이라고 판단할 수 있다. 하지만 컴퓨터의 경우 학습 시에 대부분 정면의 고양이 사진을 가지고 학습을 하고, 그렇기 때문에 모델이 기울어져 있거나 뒤집어진 이미지에서 잘 예측하지 못한다는 취약점을 가지고 있다.

따라서 사진을 일부로 회전, 반전, 자르기, 밝기 혹은 채도 변화, 늘리기 등의 가공을 하여 더 강건한 모델을 만들기 위해 진행한다.

다음과 같은 코드로 이미지 증강을 할 수 있으며 상하 반전과 회전을 준 경우의 코드이다.

data_augmentation = tf.keras.Sequential([
  layers.experimental.preprocessing.RandomFlip("vertical"),
  layers.experimental.preprocessing.RandomRotation(0.2),
])
augmented_image = data_augmentation(image)

이 방법 외에도 ImageDataGenerator를 사용하여 이미지 증강을 할 수 있다.

ImageDataGenerator(horizontal_filp=True, vertical_flip=True,
rescale=1/255.0, rotation=0.45, zoom_range=[0.5, 1.5]) 

더 자세한 내용은 공식문서를 확인하자

5. 1X1 Convolution

1X1 convolution은 GoogeLeNet에서 많이 사용되는 방법으로 계산량 감소, 차원축소, 비선형성 증가, Overfitting 방지등의 장점을 가지고 있어서 많이 사용된다. 자세한 설명은 다음 블로그를 참고하자.

💡 1X1 Convolution

6. 회고

확실히 NLP보다 CV가 더 재미있는 것 같다. 그리고 오늘 ADsP시험을 신청했는데 열심히 준비해야겠다. 오늘 원래 대충 정리하고 21:30부터 ADsP공부 좀 하려 했는데...결국 11시까지 못 그만두고 다 해버렸다. 내일부터는 좀 계획된 시간대로 움직이고 더 부지런하게 움직여야 할 것 같다. 4일 연휴 연장 푹 쉬었으니까 다시 열심히 해겠다. 아 근데 아직 정리 안한 N33x들과 N42x들은 언제 정리하지....

❗ 참고자료

1. 합성곱 신경망(CNN)/고양이 눈에서 답을 얻다.
2. 오렐리앙 제옹, 핸즈온 머신러닝(2판), 서울:한빛미디어,O^$\cdot$REILLY, 2020
3. CodeStates Lecture Note - N431

Level 1.

• 임베딩(Embedding)의 개념과 One-Hot Encoding과 비교되는 장점에 대해 설명할 수 있다.
• Word2Vec의 두 방법(CBoW, Skip-gram)의 차이와 Word2Vec으로 임베딩한 단어 벡터의 특징에 대해 설명할 수 있다.

  Level 2.

• FastText에서 적용된 철자 단위 임베딩(Character-Level Embedding)방법의 장점에 대해 설명할 수 있다.

  Level 3.

• 임베딩(Embedding)이 다른 도메인에서는 어떻게 사용되는지 폭넓게 이해하며 예시를 들어 설명할 수 있다.

1. 분산 기반 표현(Distributed Representation)

지난 노트에서 등장 횟수 기반 표현(Count-based Representation)에 대해서 학습하였다.

이번 노트에서는 단어 자체를 벡터화하는 방법에 대해서 다룬다. Word2Vec에서는 벡터화하고자 하는 타겟 단어(Target word)의 표현이 해당 단어 주변 단어에 의해 결정된다. 단어 벡터를 이렇게 정의하는 이유는 분포 가설(Distribution hypothesis)때문이다.

💡 분포 가설 "비슷한 위치에서 등장하는 단어들은 비슷한 의미를 가진다" 즉, 다시 정리하면 비슷한 의미를 지닌 단어는 주변 단어 분포 역시 비슷하다고 가정하는 것이 분포 가설의 핵심이다.

이 분포 가설에 기반하여 주변 단어 분포를 기준으로 단어의 벡터 표현이 결정되기 때문에 분산 표현(Distributed Representation)이라고 부른다. 이렇게 표현된 벡터들은 원-핫 벡터처럼 벡터의 차원이 단어 집합(vocabulary)의 크기일 필요가 없으므로, 벡터의 차원이 상대적으로 저차원으로 줄어든다.

본격적인 분산 표현을 학습하기에 앞 서 원-핫 인코딩(One-Hot Encoding)을 다시 한 번 읽고오자. 원-핫 인코딩은 범주형 변수를 벡터로 나타내는 방법 중 하나로, 쉽게 이해할 수 있는 직관적인 방법이지만 단어 간 유사도를 구할 수 없다는 치명적인 단점이 있다. 단어 간 유사도를 구할 때에는 코사인 유사도(Cosine Similarity)가 자주 사용된다. 그 식은 다음과 같다. $$$ Cosine,,similarity={\vec a\cdot\vec b\over\vert\vec a\vert\vert\vec b\vert} $$$ 위 식에 원-핫 인코딩을 적용한 서로 다른 두 벡터를 대입하면 항상 0이 된다. 따라서 두 단어 사이의 유사도를 계산할 수 없게 된다. 다음과 같은 코드로 간단하게 구현도 가능하다.

import numpy as np

def cos_sim(a, b):
    """
    코사인 유사도를 구하는 함수입니다.

    Args:
        a, b : 토큰 벡터입니다 -> array
    """
    arr_a = np.array(a)
    arr_b = np.array(b)

    result = np.dot(arr_a, arr_b)/(np.linalg.norm(arr_a)*np.linalg.norm(arr_b))
    return result

print(f"I 와 am 의 코사인 유사도 : {cos_sim(word_dict['I'], word_dict['am'])}")
print(f"I 와 student 의 코사인 유사도 : {cos_sim(word_dict['I'], word_dict['student'])}")
------------------------------------------------------------------------------
I 와 am 의 코사인 유사도 : 0.0
I 와 student 의 코사인 유사도 : 0.0

Embedding(임베딩)

단어 사이의 관계를 나타낼 수 없다는 원-핫 인코딩의 단점을 해결하기 위해 등장한 것이 바로 임베딩(Embedding)이다. 단어를 고정 길이의 벡터, 즉 차원이 일정한 벡터로 나타내기 때문에 "Embedding(=박다, 끼워넣다)"이라는 이름이 붙었다.

임베딩을 거친 단어는 One-Hot Encoding을 거친 단어와는 다른 형태의 값을 가진다.

[0.04227, -0.0033, 0.1607, -0.0236, ...]

위와 같이 벡터 내의 각 요소가 연속적인 값을 가지게 된다. 이런 벡터를 만드는 방법 중 가장 널리 알려진 임베딩 방법으로 Word2Vec이 있다.

2. Word2Vec

2013년에 고안된 Word2Vec은 말 그대로 단어를 벡터로(Word to vector) 나타내는 방법으로 가장 널리 사용되는 임베딩 방법 중 하나이다.

Word2Vec은 특정 단어 양 옆에 있는 두 단어(Window size = 2)의 관계를 활용하기 때문에 분포 가설을 잘 반영하고 있다.

Word2Vec에는 CBoW와 Skip-gram의 2가지 방법이 있다. 두 가지 방법에 대해 알아보자.

CBoW와 Skip-gram

CBoW와 Skip-gram의 차이는 다음과 같다.

1. **주변 단어에 대한 정보를 기반으로 중심 단어의 정보를 예측하는 모델 -> CBoW(Continuous Bag-of-Words) *2. *중심 단어의 정보를 기반으로 주변 단어의 정보를 예측하는 모델 -> Skip-gram**

아래 그림과 예시를 통하여 두 방식의 차이를 좀 더 잘 이해해 보겠다.

다음 예시는 <별 헤는 밤>의 일부분에 형태소 분석기를 적용하여 토큰화한 것이다.

표시된 언어 정보를 바탕으로 아래의 [---]에 들어갈 단어를 예측하는 과정으로 학습이 진행된다.

👉 CBoW “… 나 는 [ -- ] 하나 에 … “ “… 는 별 [ ---- ] 에 아름다운 …” “… 별 하나 [ -- ] 아름다운 말 …” “… 하나 에 [ -------- ] 말 한마디 …”

👉 Skip-gram “… [ -- ] [ -- ] 별 [ ---- ] [ -- ] …” “… [ -- ] [ -- ] 하나 [ -- ] [ -------- ] …” “… [ -- ] [ ---- ] 에 [ -------- ] [ -- ] …” “… [ ---- ] [ -- ] 아름다운 [ -- ] [ ------ ] …”

더 많은 정보를 바탕으로 특정 단어를 예측하기 때문에 CBoW의 성능이 더 좋을 것으로 생각하기 쉽지만, 역전파 관점에서 보면 Skip-gram에서 훨씬 더 많은 학습이 일어나기 때문에 Skip-gram의 성능이 조금 더 좋게 나타난다.

물론 계산량이 많기 때문에 Skip-gram에 드는 리소스가 더 큰 것도 사실이다.

Word2Vec 모델의 구조

성능 덕분에 조금 더 자주 사용되는 Skip-gram을 기준으로 Word2Vec의 구조에 대하여 알아보겠다.

• 입력: Word2Vec의 입력은 One-Hot Encoding된 단어 벡터이다.
• 은닉층: 임베딩 벡터의 차원수 만큼의 노드로 구성된 은닉층이 1개인 신경망이다.
• 출력층: 단어 개수 만큼의 노드로 이루어져 있으며 활성화 함수로 소프트맥스를 사용한다.

해당 그림은 논문에서 구성한 Word2Vec모델의 개략적인 구조로, 총 10,000개의 단어에 대해서 300차원의 임베딩 벡터를 구했기 때문에 신경망 구조가 위와 같이 구성된다.

Word2Vec 학습을 위한 학습 데이터 디자인

효율적인 Word2Vec학습을 위해서는 학습 데이터를 잘 구성해야 한다. Window사이즈가 2인 Word2Vec이므로 중심 단어 옆에 있는 2개 단어에 대해 단어쌍을 구성한다.

예를 들어,"The tortoise jumped into the lake"라는 문장에 대해 단어쌍을 구성해보겠다. 윈도우 크기가 2인 경우 다음과 같이 Skip-gram을 학습하기 위한 데이터 쌍을 구축할 수 있다.

• 중심 단어 : The, 주변 문맥 단어 : tortoise, jumped
  • 학습 샘플: (the, tortoise), (the, jumped)
    
    

• 중심 단어 : tortoise, 주변 문맥 단어 : the, jumped, into
  • 학습 샘플: (tortoise, the), (tortoise, jumped), (tortoise, into)
    
    
• 중심 단어 : jumped, 주변 문맥 단어 : the, tortoise, into, the
  • 학습 샘플: (jumped, the), (jumped, tortoise), (jumped, into), (jumped, the)
    
    
• 중심 단어 : into, 주변 문맥 단어 : tortoise, jumped, the, lake
  • 학습 샘플: (into, tortoise), (into, jumped), (into, the), (into, lake)

이를 DataFrame 형태로 정리하면 다음과 같은 데이터쌍이 만들어 진다.

Skip-gram에서는 중심단어를 입력으로, 문맥단어를 레이블로 하는 분류(Classification)를 통해 학습한다고 생각하면 된다.

Word2Vec의 결과

학습이 모두 끝나면 10000개의 단어에 대해 300차원의 임베딩 벡터가 생성된다. 만약에 임베딩 벡터의 차원을 조절하고 싶다면 은닉층의 노드 수를 줄이거나 늘릴 수 있다.

아래 그림은 신경망 내부에 있는 $10000\times300$크기의 가중치 행렬에 의해서 10000개 단어에 대한 300차원의 벡터가 생성되는 모습을 나타낸 이미지이다.

학습과정에서 Word2Vec의 계산량을 줄이기 위해 사용하는 기법들이 있지만 이 Sprint에서는 다루지 않는다. 추후 추가적인 학습을 원한다면 다음과 같은 키워드를 통해서 학습하면 된다고 한다.

• Sub-sampling
• Negative-sampling

결과적으로 Skip-gram 모델을 통하여 10000개 단어에 대한 임베딩 벡터를 얻을 수 있다. 이렇게 얻은 임베딩 벡터는 문장 간의 관련도 계산, 문서 분류같은 작업에 사용할 수 있다.

Word2Vec으로 임베딩한 벡터 시각화

Word2Vec을 통해 얻은 임베딩 벡터는 단어 간의 의미적, 문법적 관계를 잘 나타낸다. 이를 대표적으로 잘 보여주는 것이 아래 그림이다.

1. *man - woman 사이의 관계와 King-queen사이의 관계가 매우 유사하게 나타난다. 이를 통하여 생성된 임베딩 벡터가 단어의 *의미적(Semantic)관계를 잘 표현하는 것을 확인할 수 있다.

2. walking-walked 사이의 관계와 swimming - swam사이의 관계가 매우 유사하게 나타난다. 이를 통하여 생성된 임베딩 벡터가 단어의 문법적(혹은 구조적, Syntactic)인 관계도 잘 표현하는 것을 확인할 수 있다.

*3. *고유명사에 대해서도 나라-수도와 같은 관계를 잘 나타내고 있는 것을 확인할 수 있다.

gensim 패키지로 word2Vec 실습하기

gensim은 word2Vec으로 사전 학습된 임베딩 벡터를 쉽게 사용해볼 수 있는 패키지이다. gensim을 사용하여 Word2Vec의 결과가 어떻게 도출되는지 알아보겠다.

0. gensim패키지 업그레이드 --upgrade 셀을 실행하여 gensim 패키지를 업그레이드 한 후, Coloab의 메뉴 탭에서 "런타임 > 런타임 다시 시작"을 클릭하여 런타임을 재시작 해준다. 이후 아래 .__version__을 활용하여 업그레이드가 잘 되었는지 확인한다.

!pip install gensim --upgrade

import gensim

gensim.__version__

1. 구글 뉴스 말뭉치로 학습된 Word2Vec벡터를 다운받는다.

import gensim.downloader as api

wv = api.load('word2vec-google-news-300')

2. 0~9 인덱스에 위치한 단어가 무엇인지 확인해본다.

for idx, word in enumerate(wv.index_to_key):
    if idx == 10:
        break

    print(f"word #{idx}/{len(wv.index_to_key)} is '{word}'")
-----
word #0/3000000 is '</s>'
word #1/3000000 is 'in'
word #2/3000000 is 'for'
word #3/3000000 is 'that'
word #4/3000000 is 'is'
word #5/3000000 is 'on'
word #6/3000000 is '##'
word #7/3000000 is 'The'
word #8/3000000 is 'with'
word #9/3000000 is 'said'

3. 임베딩 벡터의 차원과 값을 눈으로 확인해보자. "king"이라는 단어의 벡터의 Shape를 출력하여 임베딩 벡터의 차원을 확인해본다. 그리고 결과를 통해 Word2Vec을 통해 학습된 임베딩 300차원이며, 벡터의 요소가 One-Hot Encoding과는 다르다는 것을 확인할 수 있다.

vec_king = wv['king']

print(f"임베딩 벡터의 차원 수 : {vec_king.shape}\n")
print(f"'king' 의 임베딩 벡터 \n\n {vec_king}")
-----
임베딩 벡터의 차원 수 : (300,)

'king' 의 임베딩 벡터 

 [ 1.25976562e-01  2.97851562e-02  8.60595703e-03  1.39648438e-01
 -2.56347656e-02 -3.61328125e-02  1.11816406e-01 -1.98242188e-01
  5.12695312e-02  3.63281250e-01 -2.42187500e-01 -3.02734375e-01
 -1.77734375e-01 -2.49023438e-02 -1.67968750e-01 -1.69921875e-01
 .
 .
 .
 .
 .]

4. 말뭉치에 등장하지 않는 단어의 임베딩 벡터를 확인해 본다. "cameroon"이라는 단어는 사전에 지정해 준 단어 집합(Vocabulary,vocab)에 등장하지 않는 단어(Unknown token)이다. 이 단어를 "King"같이 임베딩 벡터화 해보면 KeyError가 발생한다. 이처럼 Word2Vec은 단어 집합에 지정하지 않은 단어는 벡터화 할 수 없다는 단점이 있다.

unk = 'cameroon'

try:
    vec_unk = wv[unk]
except KeyError:
    print(f"""단어 "{unk}"은 해당 모델에는 등장하지 않는 단어입니다.""")
-----
단어 "cameroon"은 해당 모델에는 등장하지 않는 단어입니다.

5. 단어 간 유사도를 파악해보자. gensim 패키지가 제공하는 .similarity를 활용하면 단어 간 유사도를 파악할 수 있다.

One-Hot encoding과 다르게 임베딩 벡터는 단어 간 유사도를 구했을 때 0이 아닌 값이 나오게 된다. 아래는 'car'와 몇몇 단어의 유사도를 비교한 결과이다.

pairs = [
    ('car', 'minivan'),   
    ('car', 'bicycle'),  
    ('car', 'airplane'),
    ('car', 'cereal'),    
    ('car', 'democracy')
]

for w1, w2 in pairs:
    print(f'{w1} ======= {w2}\t  {wv.similarity(w1, w2):.2f}')
------------------------
car ======= minivan          0.69
car ======= bicycle          0.54
car ======= airplane      0.42
car ======= cereal          0.14
car ======= democracy     0.08

.most_similar 메서드를 사용하여 'car' 벡터에 'minivan' 벡터를 더한 벡터와 가장 유사한 5개의 단어를 뽑아보겠다.

for i, (word, similarity) in enumerate(wv.most_similar(positive=['car', 'minivan'], topn=5)):
    print(f"Top {i+1} : {word}, {similarity}")
-----------------------
Top 1 : SUV, 0.8532192707061768
Top 2 : vehicle, 0.8175783753395081
Top 3 : pickup_truck, 0.7763688564300537
Top 4 : Jeep, 0.7567334175109863
Top 5 : Ford_Explorer, 0.7565720081329346

시각화에서 확인한 것처럼 king벡터에 women벡터를 더한 뒤 men벡터를 빼준 벡터와 가장 유사한 벡터로 queen이 나오는 것과 walking벡터에 swam벡터를 더한 뒤 walked벡터를 빼준 벡터와 가장 유사한 벡터로 swimming이 나오는 것을 확인할 수 있다.

print(wv.most_similar(positive=['king', 'women'], negative=['men'], topn=1))
print(wv.most_similar(positive=['walking', 'swam'], negative=['walked'], topn=1))
------------------
[('queen', 0.6525818109512329)]
[('swimming', 0.7448815703392029)]

.doesnt_match메서드를 사용하면 가장 관계없는 단어를 뽑아낼 수 있다.

print(wv.doesnt_match(['fire', 'water', 'land', 'sea', 'air', 'car']))
----
car

임베딩 벡터를 활용한 문장분류

이번 예제에서는 이미 학습된 임베딩 벡터를 사용하여 문장 분류를 수행하는 코드에 대해 알아보겠다. 아래 코드에서는 문서에 있는 단어 벡터의 평균을 해당 문서의 벡터로 사용하여 분류 문제를 수행한다.

예를 들어, "I am a student"라는 문장을 구성하는 단어의 임베딩 벡터가 아래와 같다고 해보겠다.

$I = [0.0012,0.0345,...,-0.0048,-0.0425]\ am = [0.00232,-0.0141,...,-0.0542,0.0454]\ a = [0.0022,0.0905,...,-0.0241,0.0028]\ student = [-0.0110,0.0492,...,0.0008,-0.0420]$

이때, "I am a student"라는 문장을 분류하기 위해서 최종적으로 아래 벡터를 사용한다.

$[0.0039,0.0400,...,-0.0206,-0.0091]$

이게 되나? 의문이들 정도로 간단하지만, 간단한 문서 분류 문제에서는 꽤 좋은 성능을 보이기 때문에 Baseline모델로 많이 사용된다.

1. 필요한 모듈 imoport

import numpy as np
import tensorflow as tf

from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Embedding, GlobalAveragePooling1D
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.datasets import imdb

2. 시드를 정해준다.

tf.random.set_seed(42)

3. 데이터셋을 split 해준다.

(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=20000)
print(f"Train set shape : {X_train.shape}")
print(f"Test set shape : {X_test.shape}")
----------
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17465344/17464789 [==============================] - 0s 0us/step
17473536/17464789 [==============================] - 0s 0us/step
Train set shape : (25000,)
Test set shape : (25000,)

4. 데이터셋이 어떻게 생겼는지 눈으로 확인해본다.

print(X_train[0])
print(type(X_train[0]))

5. 인덱스로 된 데이터를 텍스트로 변경하는 함수를 구현한다. 첫 번째 데이터를 텍스트로 변경하고 확인하여 본다.

word_index = imdb.get_word_index()
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])

def decode_review(text):
    """
    word_index 를 받아서 text 를 sequence 형태로 반환하는 함수입니다.

    Args:
        text: 텍스트 시퀀스입니다 -> str
    """
    return ' '.join([reverse_word_index.get(i, '?') for i in text])

decode_review(X_train[0])
----
>
"the as you with out themselves powerful lets loves their becomes reaching had journalist of lot from anyone to have after out atmosphere never more room and it so heart shows to years of every never going and help moments or of every chest visual movie except her was several of enough more with is now current film as you of mine potentially unfortunately of you than him that with out themselves her get for was camp of you movie sometimes movie that with scary but pratfalls to story wonderful that in seeing in character to of 70s musicians with heart had shadows they of here that with her serious to have does when from why what have critics they is you that isn't one will very to as itself with other tricky in of seen over landed for anyone of and br show's to whether from than out themselves history he name half some br of 'n odd was two most of mean for 1 any an boat she he should is thought frog but of script you not while history he heart to real at barrel but when from one bit then have two of script their with her nobody most that with wasn't to with armed acting watch an for with heartfelt film want an"

6. keras의 tokenizer에 텍스트를 학습시킨다.

sentences = [decode_review(idx) for idx in X_train]

tokenizer = Tokenizer()
tokenizer.fit_on_texts(sentences)

# 단어 집합(vocab)의 크기를 입력합니다. 패딩()을 고려하여 tokenizer의 단어 수에서 +1 해줍니다.
vocab_size = len(tokenizer.word_index) + 1
print(vocab_size)
-----
19999

7. pad_sequence를 통해 패딩 처리해준다. 자연어 처리를 하다보면 각 문장(또는 문서)은 서로 길이가 다를 수 있다. 그런데 기계는 길이가 전부 동일한 문서들에 대해서는 하나의 행렬로 보고, 한꺼번에 묶어서 처리할 수 있다. 다시 말해서 병렬 연산을 위해 여러 문장의 길이를 임의로 동일하게 맞춰주는 작업이 필요할 때가 있다. 그리고 이러한 작업을 패딩(Padding)이라고 한다.

그리고 pad_sequence는 Keras에서 패딩을 위해서 제공하는 메서드이다.

X_encoded = tokenizer.texts_to_sequences(sentences)

max_len = max(len(sent) for sent in X_encoded)
print(max_len)
------
2494

print(f'학습 데이터에 있는 문서의 평균 토큰 수: {np.mean([len(sent) for sent in X_train], dtype=int)}')
----
학습 데이터에 있는 문서의 평균 토큰 수: 238

pad_sequences의 파라미터인 maxlen을 평균보다 조금 더 긴 400으로 설정해준다.

maxlen_pad = 400

X_train=pad_sequences(X_encoded, maxlen=maxlen_pad, padding='post')
y_train=np.array(y_train

8. word2vec의 임베딩 가중치 행렬을 만들어줍니다. 사전 학습된 모든 단어(300만개)에 대해 만들 경우 너무 행렬이 커지기 때문에 개인 로컬환경에서 실행하기에는 무리가 있으므로 Vocab에 속하는 단어에 대해서만 만들어지도록 한다.

embedding_matrix = np.zeros((vocab_size, 300))

print(np.shape(embedding_matrix))
----
(19999, 300)

def get_vector(word):
    """
    입력 단어가 vocab 에 있는 단어일 경우 임베딩 벡터를 반환

    Args:
        word: 입력 단어 -> str
    """
    if word in wv:
        return wv[word]
    else:
        return None

for word, i in tokenizer.word_index.items():
    temp = get_vector(word)
    if temp is not None:
        embedding_matrix[i] = temp

9. 신경망을 구성하기 위한 keras 모듈을 불러온 후 학습을 수행한다.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Embedding, Flatten

model = Sequential()
model.add(Embedding(vocab_size, 300, weights=[embedding_matrix], input_length=maxlen_pad, trainable=False))
model.add(GlobalAveragePooling1D()) # 입력되는 단어 벡터의 평균을 구하는 함수입니다.
model.add(Dense(1, activation='sigmoid'))

GlobalAveragePooling1D층은 입력되는 행렬의 평균을 구하는 층, 즉 입력되는 단어 벡터의 평균을 구하는 층으로 알아두면 된다.

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])
model.fit(X_train, y_train, batch_size=64, epochs=20, validation_split=0.2)
----
Epoch 1/20
313/313 [==============================] - 7s 18ms/step - loss: 0.6924 - acc: 0.5242 - val_loss: 0.6908 - val_acc: 0.5852
Epoch 2/20
313/313 [==============================] - 5s 17ms/step - loss: 0.6902 - acc: 0.5735 - val_loss: 0.6884 - val_acc: 0.5944
.
.
.
Epoch 19/20
313/313 [==============================] - 5s 17ms/step - loss: 0.6675 - acc: 0.6215 - val_loss: 0.6642 - val_acc: 0.6272
Epoch 20/20
313/313 [==============================] - 5s 18ms/step - loss: 0.6666 - acc: 0.6237 - val_loss: 0.6633 - val_acc: 0.6270
<keras.callbacks.History at 0x7f37c6967c50>

test_sentences = [decode_review(idx) for idx in X_test]

X_test_encoded = tokenizer.texts_to_sequences(test_sentences)

X_test=pad_sequences(X_test_encoded, maxlen=400, padding='post')
y_test=np.array(y_test)

model.evaluate(X_test, y_test)
-------------------------------
782/782 [==============================] - 6s 8ms/step - loss: 0.6679 - acc: 0.6102
[0.6679435968399048, 0.6101999878883362]

회고

NLP는 어렵고, 이걸 작성하는 지금 처음보는 것처럼 느껴진다. 정말 NLP공부 안했다는걸 다시금 느낀다.

❗️ 참고자료

1. 코드스테이츠 N422 Lecture Note

❗ 이번 포스트는 화이트모드로 읽을 것.

0. 학습목표

Level 1.

• 자연어처리를 통해 할 수 있는 Task에는 어떤 것이 있는지 설명할 수 있다.
• 토큰화(Tokenization)에 대해 설명할 수 있으며 SpaCy라이브러리를 활용하여 토큰화를 진행할 수 있다.
• 불용어(Stop words), 어간 추출(Stemming)과 표제어 추출(Lemmatization) 등에 대해 설명할 수 있고 이를 적용하는 코드를 작성할 수 있다.
• Bag-of-words에 대해서 설명할 수 있으며 Scikit-learn라이브러리에서 이를 적용할 수 있다.
• TF-IDF에서 TF, IDF에 대해서 설명하고 IDF를 적용하는 이유에 대해서 설명할 수있다.

  Level 2.

• N-gram의 개념에 대해 이해하고 Bag-of-words에 적용해 볼 수 있다.
• Spacy라이브러리의 다른 기능을 텍스트에 적용하여 분석할 수 있다.

  Level 3.

• LSA(잠재 의미 분석)에 대해 이해하고 코드로 적용해 볼 수 있다.

1. 자연어처리

자연어(Natural Language)혹은 자연 언어는 사람들이 일상적으로 쓰는 언어를 인공적으로 만들어진 언어인 인공어와 구분하여 부르는 개념이다. 쉽게 말해서 자연적으로 발생된 언어를 자연어라고 한다.

그리고 이런 자연어를 컴퓨터로 처리하는 기술을 자연어 처리(Natural Language Processing, NLP)라고 한다. 이는 넓은 의미로 음성 인식, 자연어 인식, 자연어 생성을 모두 의미한다. 하지만 일반적인 NLP는 다음과 같다.

• 토큰화(Tokenization)
• 구문 분석(Parsing)
• 정보 추출(Information extraction)
• 유사성(Similarity)
• 음성 인식(Speech recognition)
• 자연어와 음성 생성 등(Natural language and speech generations and many others)

자연어 처리를 비롯한 텍스트 마이닝의 중요한 요소들은 아래 그림과 같다.

이런 자연어 처리로 할 수 있는 일들은 다양하다.

1. 자연어 이해(NLU, Natural Language Understanding)

NLU란 자연어 표현을 기계가 이해할 수 있는 다른 표현으로 변환시키는 것을 뜻한다. 결국 가장 인간 같은 기계를 만드는 것이 목적이다. 이 자연어 이해를 통하여 구현할 수 있는 Task들은 다음과 같다.

• 분류(Classification) 뉴스 기사 분류, 감성 분석(Positive/Negative)

• 자연어 추론(NLI, Natural Language Inference) "A는 B에게 암살당했다", 가설 : "A는 죽었다" -> True or False?

• 기계 독해(MRC, Machine Reading Comprehension), 질의 응답(QA, Question&Answering) 비문학 문제 풀기

• 품사 태깅(POS tagging), 개체명 인식(Named Entity Recognition)

  2. 자연어 생성(NLG, Natural Language Generation)

  자연어 생성(NLG)과정은 자연어이해의 반대로써 생각하면 된다. 정보를 나타내는 구조를, 원하는 언어로 올바른 String으로 Mapping 시켜야 한다. 그러나 경우에 따라서는 전달할 정보가 어디로부터 얻어지는가를 생각하는 것도 중요한 문제이다. 자연어 생성에 대한 전체 과정은 다음과 같이 세 부분으로 나뉘어 질 수 있다.

1. 전달할 정보를 나타내는 구조의 구성: 무엇을 말할 것인가를 결정
2. 문장의 순서를 정하기 위한 대화 구조 및 문장에 대한 규칙을 적용
3. 실제 문장을 생성하기 위하여, 단어에 대한 정보 및 문장론적 규칙을 적용한다.

3. NLU & NLG

두 가지를 조합하여 사용하면 다음과 같은 다양한 Task를 처리할 수 있다.

• 기계 번역(Machine Translation)

• 요약(Summerization)

  • 생성 요약(Absractive Summerization) 해당 문서를 요약하는 요약문을 생성 👉 NLG에 가깝다.

  • 추출 요약(Extractive Summerization) 문서 내에서 해당 문서를 가장 잘 요악하는 부분을 찾아냄. 👉 NLU에 가깝다.

• Chatbot

  • Open Domain Dialog(ODD): 정해지지 않은 주제를 다루는 일반대화 챗봇
  • Task Oriented Dialog(TOD): 특정 Task를 처리하기 위한 챗봇

    4. 자연어 처리 용어 정리

    말뭉치(Corpus)

    자연어 연구를 위해 특정한 목적을 가지고 언어의 표본을 추출한 집합을 의미한다. 컴퓨터의 발달로 말뭉치 분석이 용이해졌으며 분석의 정확성을 위해 해당 자연언어를 형태소 분석하는 경우가 많다. 확률/통계적 기법과 시계열적인 접근으로 전체를 파악한다. 언어의 빈도와 분포를 확인할 수 있는 자료이며, 현대 언어학 연구에 필수적인 자료이다.

    문장(Setence)

    여러 개의 토큰(단어, 형태소 등)으로 구성된 문자열을 의미한다. 생각이나 감정을 말과 글로 표현할 때 완결된 내용을 나타내는 최소의 독립적인 형식단위이다. 마침표, 느낌표 등의 기호로 구분한다.

    문서(Document)

    문장(Sentences)들의 집합이다. 기승전결이 완성된 하나의 글을 뜻하는 것이 아니라 그냥 하나의 데이터 단위이며, 형태 상으로는 문단(paragraph)에 가깝다. 그러므로, 문장(Sentence)을 하나 또는 그 이상 포함한다면 문서로 볼 수 있다.

다시 정리하자면 우리가 일반적으로 생각하던 문서는 말뭉치에 가깝다. 믈론 말뭉치는 문서 다발인 경우가 대부분일 것이다. 그리고 문서 내의 문장들이 여기서 말하는 문서가 될 것이다. 예를 들어, 어떤 문서가 100문장으로 되어 있고 문장끼리 특별한 묶음이 없다면 그 문서는 100개의 문서로 구성된 말뭉치가 될 것이다.

어휘집합(Vocabulary)

말뭉치에 있는 모든 문서, 문장을 토큰화한 후 중복을 제거한 토큰의 집합을 의미한다.

2. 토큰화(Tokenization)

자연어처리에서 얻은 말뭉치(Corpus) 데이터가 필요에 맞게 전처리되지 않은 상태라면, 해당 데이터를 사용하고자하는 용도에 맞게 토큰화(tokenization) & 정제(cleaning) & 정규화(normalization)하는 일을 하게 된다.

주어진 코퍼스(corpus)에서 토큰(token)이라 불리는 단위로 나누는 작업을 토큰화(tokenization)라고한다. 토큰의 단위가 상황에 따라 다르지만, 보통 의미있는 단위로 토큰을 정의한다.

3. 벡터화(Vectorize)

컴퓨터는 자연어 자체를 받아들일 수 없다. 그래서 컴퓨터가 이해할 수 있도록 벡터로 만들어주어야 한다. 이 과정을 벡터화(Vectorize)라고 한다. 벡터화 방식은 자연어 처리 모델의 성능을 결정하는 중요한 역할을 한다.

자연어를 벡터화하는 방법은 크게 2가지로 나눌 수 있다.

Count-based Representation(횟수 기반 표현)

단어가 문서(혹은 문장)에 등장하는 횟수를 기반으로 벡터화하는 방법이다.

• Bag-of-Words(CounterVectorizer)
• TF-IDF(TfidfVectorizer)

  Distributed Representation(분산 기반 표현)

  타겟 단어 주변에 있는 단어를 기반으로 벡터화하는 방법이다. "비슷한 문맥에서 등장하는 단어들은 비슷한 의미를 가진다"라는 분포가설 가정 하에 만들어진 표현 방법이다.

이 방법으로 표현된 벡터들은 One-Hot Vector처럼 벡터의 차원이 단어 집합의 크기일 필요가 없으므로, 벡터의 차원이 상대적으로 저차원으로 줄어든다.

• Word2Vec
• GloVe
• fastText

4. Text Preprocessing(텍스트 전처리)

텍스트 데이터를 전처리하는 것은 자연어 처리의 시작이자 절반 이상을 차지하는 중요한 과정이다. 실제 텍스트 데이터를 다룰 때에는 데이터를 읽어보면서 어떤 특이사항이 있는지 파악해야 한다.

횟수 기반의 벡터 표현에서는 전체 말뭉치에 존재하는 단어의 종류가 데이터셋의 Feature, 즉 차원이 된다. 따라서, 단어의 종류(Feature)를 줄여주어야 차원의 저주를 어느 정도 해결할 수 있다. 차원의 저주에 대해서는 N132에서 다루었으니 확인하자. 정의만 간략하게 설명하면 다음과 같다.

차원의 저주를 해결할 전처리 방법은 다음과 같은 것들이 있다.

• 내장 메서드를 사용한 전처리(lower, replace,...)

• 정규 표현식(Regular expression Regex)
• 불용어(Stop words) 처리
• 통계적 트리밍(Trimming)
• 어간 추출(Stemming) 혹은 표제어 추출(Lemmatization)

간단한 예시를 통해 전처리가 어떻게 단어의 수를 줄일 수 있는지 알아보겠다.

내장 메서드, 정규표현식을 사용한 전처리

import pandas as pd
df = pd.read_csv('https://ds-lecture-data.s3.ap-northeast-2.amazonaws.com/amazon/Datafiniti_Amazon_Consumer_Reviews_of_Amazon_Products_May19_sample.csv')

df['brand'].value_counts()
-------------------------
Amazon          5977
Amazonbasics    4499
AmazonBasics       7
Name: brand, dtype: int64

데이터의 출력을 확인하여 보면 Amazonbasics와 AmazonBasics는 같은 것을 지칭하는 단어임에도 대소문자 차이로 다른 카테고리로 취급되었다. 대소문자를 통일하여 둘을 같은 범주로 만들어 줄 수 있다.

df['brand'] = df['brand'].apply(lambda x: x.lower()) # 대문자로 바꾸고 싶을 때는 upper()
df['brand'].value_counts()
-------------------------------------
amazon          5977
amazonbasics    4506
Name: brand, dtype: int64

다음으로는 정규표현식이다. 구두점이나 특수문자 등 필요없는 문자가 말뭉치 내에 있을 경우 토큰화가 제대로 이루어지지 않는다. 이를 제거하기 위해서 정규표현식을 사용한다.

a-z(소문자), A-Z(대문자), 0-9(숫자)를 ^제외한 나머지 문자를 regex에 할당한 후, .sub메서드를 통해서 공백 문자열 ""로 치환한다.

# 파이썬 정규표현식 패키지 이름은 re 입니다.
import re

# 정규식
# []: [] 사이 문자를 매치, ^: not
regex = r"[^a-zA-Z0-9 ]"
subst = ""

# 정규표현식을 통한 데이터 가공 후 대소문자 통일 -> 공백 문자 기준으로 분리
def tokenize(text):
    """text 문자열을 의미있는 단어 단위로 list에 저장합니다.
    Args:
        text (str): 토큰화 할 문자열
    Returns:
        list: 토큰이 저장된 리스트
    """
    # 정규식 적용
    tokens = re.sub(regex, subst, text)
    # 소문자로 치환 후 분리
    tokens = tokens.lower().split()
    return tokens

위에서 다룬 아마존 리뷰 데이터 중 reviews.text 열에 tokenize 함수를 적용하여 전처리 해보겠다. 각 리뷰텍스트를 토크나이즈 하여 tokens 칼럼으로 만든다.

df['tokens'] = df['reviews.text'].apply(tokenize)

이제 결과를 분석해보겠다.

from collections import Counter

# Counter 객체는 리스트요소의 값과 요소의 갯수를 카운트 하여 저장하고 있습니다.
# 카운터 객체는 .update 메소드로 계속 업데이트 가능합니다.
word_counts = Counter()

# 토큰화된 각 리뷰 리스트를 카운터 객체에 업데이트 합니다. 
df['tokens'].apply(lambda x: word_counts.update(x))

# 가장 많이 존재하는 단어 순으로 10개를 나열합니다
word_counts.most_common(10)
----------------------------------------------------------------------
[('the', 10514),
 ('and', 8137),
 ('i', 7465),
 ('to', 7150),
 ('for', 6617),
 ('a', 6421),
 ('it', 6096),
 ('my', 4119),
 ('is', 4111),
 ('this', 3752)]

이제 다시 위 코드를 변형하여 말뭉치의 전체 워드 카운트, 랭크 등 정보가 담긴 DataFrame을 반환하는 함수를 구현하고 적용해보겠다.

def word_count(docs):
    """ 토큰화된 문서들을 입력받아 토큰을 카운트 하고 관련된 속성을 가진 데이터프레임을 리턴합니다.
    Args:
        docs (series or list): 토큰화된 문서가 들어있는 list
    Returns:
        list: Dataframe
    """
    # 전체 코퍼스에서 단어 빈도 카운트
    word_counts = Counter()

    # 단어가 존재하는 문서의 빈도 카운트, 단어가 한 번 이상 존재하면 +1
    word_in_docs = Counter()

    # 전체 문서의 갯수
    total_docs = len(docs)

    for doc in docs:
        word_counts.update(doc)
        word_in_docs.update(set(doc))

    temp = zip(word_counts.keys(), word_counts.values())

    wc = pd.DataFrame(temp, columns = ['word', 'count'])

    # 단어의 순위
    # method='first': 같은 값의 경우 먼저나온 요소를 우선
    wc['rank'] = wc['count'].rank(method='first', ascending=False)
    total = wc['count'].sum()

    # 코퍼스 내 단어의 비율
    wc['percent'] = wc['count'].apply(lambda x: x / total)

    wc = wc.sort_values(by='rank')

    # 누적 비율
    # cumsum() : cumulative sum
    wc['cul_percent'] = wc['percent'].cumsum()

    temp2 = zip(word_in_docs.keys(), word_in_docs.values())
    ac = pd.DataFrame(temp2, columns=['word', 'word_in_docs'])
    wc = ac.merge(wc, on='word')

    # 전체 문서 중 존재하는 비율
    wc['word_in_docs_percent'] = wc['word_in_docs'].apply(lambda x: x / total_docs)

    return wc.sort_values(by='rank')

wc = word_count(df['tokens'])
wc.head()
-----
    word    word_in_docs    count    rank    percent     cul_percent    word_in_docs_percent
51    the                4909    10514    1.0        0.039353    0.039353                0.468282
1    and                5064    8137    2.0        0.030456    0.069809                0.483068
26    i                3781    7465    3.0        0.027941    0.097750                0.360679
123    to                4157    7150    4.0        0.026762    0.124512                0.396547
19    for                4477    6617    5.0        0.024767    0.149278                0.427072

cur_percent열을 활용하여 단어의 누적 분포 그래프를 그려보겠다.

import seaborn as sns

sns.lineplot(x='rank', y='cul_percent', data=wc);

wc[wc['rank'] <= 1000]['cul_percent'].max()
--------------------------------------------
0.9097585076280484

Squarify라이브러리를 사용하여 등장 비율 상위 20개 단어의 결과를 시각화하여 보겠다.

# squarify설치 과정은 스킵
import squarify
import matplotlib.pyplot as plt

wc_top20 = wc[wc['rank'] <= 20]
squarify.plot(sizes=wc_top20['percent'], label=wc_top20['word'], alpha=0.6)
plt.axis('off')
plt.show()

Spacy를 사용하여 더욱 쉽게 처리하기

SpaCy는 문서 구성요소를 다양한 구조에 나누어 저장하지 않고 요소를 색인화하여 검색 정보를 간단히 저장하는 라이브러리이다. 그렇기 때문에 실제 배포 단계에서 기존에 많이 사용되었던 NLTK라이브러리보다 SpaCy가 더 빠르다.

SpaCy라이브러리를 사용하여 토큰화하는 방법에 대해서 알아보겠다.

# 필요한 모듈을 import 합니다
import spacy
from spacy.tokenizer import Tokenizer

nlp = spacy.load("en_core_web_sm")
tokenizer = Tokenizer(nlp.vocab)

# 토큰화를 위한 파이프라인을 구성합니다.

tokens = []

for doc in tokenizer.pipe(df['reviews.text']):
    doc_tokens = [re.sub(r"[^a-z0-9]", "", token.text.lower()) for token in doc]
    tokens.append(doc_tokens)

df['tokens'] = tokens
df['tokens'].head()

---------------------------------------------------------------------------
0    [though, i, have, got, it, for, cheap, price, ...
1    [i, purchased, the, 7, for, my, son, when, he,...
2    [great, price, and, great, batteries, i, will,...
3    [great, tablet, for, kids, my, boys, love, the...
4    [they, lasted, really, little, some, of, them,...
Name: tokens, dtype: object

# word_count 함수를 사용하여 단어의 분포를 나타내어 봅시다.
wc = word_count(df['tokens'])
wc.head()
-------------------------------------------------------
    word    word_in_docs    count    rank    percent        cul_percent        word_in_docs_percent
51    the                4909    10514    1.0        0.039229        0.039229                0.468282
1    and                5064    8137    2.0        0.030360        0.069589                0.483068
26    i                3781    7465    3.0        0.027853        0.097442                0.360679
124    to                4157    7150    4.0        0.026678        0.124120                0.396547
19    for                4477    6617    5.0        0.024689        0.148809                0.427072

SpaCy로 토큰화 한 문장에 대하여 등장 비율 상위 20개 단어의 결과를 시각화하면 다음과 같다.

wc_top20 = wc[wc['rank'] <= 20]

squarify.plot(sizes=wc_top20['percent'], label=wc_top20['word'], alpha=0.6 )
plt.axis('off')
plt.show()

불용어(Stop words) 처리

위의 사진을 보면 i,and,of같은 제품 리뷰를 이해하는데 별 도움이 되지 않는 단어들이 높은 등장 비율을 가지고 있는 것을 볼 수 있다. 이런 것들을 Stop words(불용어)라고 한다. 다시 말하면 자주 등장하지만 분석 하는 것에 있어서 큰 도움이 되지 않는 단어들을 의미한다.

따라서 분석 시 해당 단어를 제외하고 진행한다. 대부분의 NLP 라이브러리는 접속사, 관사, 부사, 대명사, 일반동사 등을 포함한 일반적인 불용어를 내장하고 있다. 다음과 같은 명령어로 불용어를 확인할 수 있다.

print(nlp.Defaults.stop_words)

해당 불용어를 제외하고 토크나이징을 진행한 결과는 다음과 같다.

tokens = []
# 토큰에서 불용어 제거, 소문자화 하여 업데이트
for doc in tokenizer.pipe(df['reviews.text']):
    doc_tokens = []

    # A doc is a sequence of Token()
    for token in doc:
        # 토큰이 불용어와 구두점이 아니면 저장
        if (token.is_stop == False) & (token.is_punct == False):
            doc_tokens.append(token.text.lower())

    tokens.append(doc_tokens)

df['tokens'] = tokens
df.tokens.head()
-----------------------------------------------------------------
0    [got, cheap, price, black, friday,, fire, grea...
1    [purchased, 7", son, 1.5, years, old,, broke, ...
2    [great, price, great, batteries!, buying, anyt...
3         [great, tablet, kids, boys, love, tablets!!]
4    [lasted, little.., (some, them), use, batterie...
Name: tokens, dtype: object

wc = word_count(df['tokens'])

wc_top20 = wc[wc['rank'] <= 20]

squarify.plot(sizes=wc_top20['percent'], label=wc_top20['word'], alpha=0.6)
plt.axis('off')
plt.show()

불용어들이 모두 제거가 되어 왼전히 다른 단어들이 상위에서 보이는 것을 확인할 수 있다.

그리고 불용어는 사용자가 직접 추가할 수도 있다. union이라는 메서드를 통해서 추가할 수 있다.

STOP_WORDS = nlp.Defaults.stop_words.union(['batteries','I', 'amazon', 'i', 'Amazon', 'it', "it's", 'it.', 'the', 'this'])

tokens = []

for doc in tokenizer.pipe(df['reviews.text']):

    doc_tokens = []

    for token in doc: 
        if token.text.lower() not in STOP_WORDS:
            doc_tokens.append(token.text.lower())

    tokens.append(doc_tokens)

df['tokens'] = tokens

wc = word_count(df['tokens'])
wc.head()
---------------------------------------------------
    word    word_in_docs    count    rank    percent     cul_percent    word_in_docs_percent
58    great            2709     3080     1.0    0.024609    0.024609                0.258418
14    good            1688     1870     2.0    0.014941    0.039549                0.161023
68    tablet            1469     1752     3.0    0.013998    0.053547                0.140132
64    love            1183     1287     4.0    0.010283    0.063830                0.112849
103    bought            1103     1179     5.0    0.009420    0.073250                0.105218

wc_top20 = wc[wc['rank'] <= 20]

squarify.plot(sizes=wc_top20['percent'], label=wc_top20['word'], alpha=0.6)
plt.axis('off')
plt.show()

통계적 트리밍(Trimming)

불용어를 직접 제거하는 대신 통계적인 방법을 통해 말뭉치 내에서 너무 많거나, 너무 적은 토큰을 제거하는 방법도 있다. 단어들의 누적분포 그래프를 다시보면 다음과 같다.

이 그래프에서 알 수 있는 것은 몇몇 소수의 단어들이 전체 말뭉치의 80%를 차지한다는 것이다. 그래프 결과에서 나타나는 단어의 중요도를 다음과 같이 두가지로 해석할 수 있다.

1. 자주 나타나는 단어들 (그래프의 왼쪽) 여러 문서에 두루 나타나기 때문에 문서 분류 단계에서 통찰력을 제공하지 않는다.
2. 자주 나타나지 않는 단어들 (그래프의 오른쪽) 너무 드물게 나타나기 때문에 큰 의미가 없을 확률이 높다.

위의 가정을 바탕으로 랭크가 높거나 낮은 단어들을 제거하여 보겠다. describe()등의 함수로 값을 출력하는 것은 생략하고 그래프를 출력하고 제거하는 코드만 작성하였다.

# 문서에 나타나는 빈도
sns.displot(wc['word_in_docs_percent'],kind='kde')

# 최소한 1% 이상 문서에 나타나는 단어들만 선택합니다.
wc = wc[wc['word_in_docs_percent'] >= 0.01]
sns.displot(wc['word_in_docs_percent'], kind='kde');

어간 추출(Stemming)과 표제어 추출(Lemmatization)

토큰화된 단어들을 보면 batteries, battery와 같이 어근(root)이 동일한 단어를 볼 수 있다. 이런 단어들은 어간 추출(stemming)이나 표제어 추출(lemmatization)을 통해 정규화(Normalization) 해주어 단어의 수를 줄일 수 있다.

어간 추출(Stemming)

어간(Stem)이란 단어의 의미가 포함된 부분으로 접사등이 제거된 형태이다. 이는 어근이나 단어의 원형과 같이 않을 수 있다. 예를 들자면 argue, argued, arguing, argus의 어간은 단어들의 뒷 부분이 제거된 argu가 어간이다. 어간 추출은 ing,ed,s 등과 같은 부분을 제거하게 된다.

Stemming 방법에는 Poter, Snowball, Dawson등의 알고리즘이 있다. 하지만 Spacy라이브러리는 Stemming을 제공하지 않고 Lemmatization만 제공한다. 그렇기 때문에 이번에는 nltk를 사용하여 Stemming을 제공하여 보겠다.

tokens = []
for doc in df['tokens']:
    doc_tokens = []
    for token in doc:
        doc_tokens.append(ps.stem(token))
    tokens.append(doc_tokens)

df['stems'] = tokens

wc = word_count(df['stems'])
wc_top20 = wc[wc['rank'] <= 20]

squarify.plot(sizes=wc_top20['percent'], label=wc_top20['word'], alpha=0.6 )
plt.axis('off')
plt.show()

Stemming은 단어의 끝 부분을 자르는 역할을 하기 때문에 사전에 없는 단어가 많이 나오게 된다. 이상하긴 해도 현실적으로 사용하기에 성능이 나쁘지 않다. 알고리즘이 간단하여 속도가 빠르기 때문에 속도가 중요한 검색 분야에서 Stemming을 많이 사용한다.

표제어 추출(Lemmatization)

표제어 추출(Lemmatization)은 단어들의 기본 사전형 단어 형태인 Lemma(표제어)로 변환된다.

명사의 복수형은 단수형으로, 동사는 모두 타동사로 변환된다. 이렇게 단어들로부터 표제어를 찾아가는 과정은 Stemming보다 많은 연상이 필요하다.

Spacy를 통하여 Lemmatization을 진행해 보겠다.

# Lemmatization 과정을 함수로 구현
def get_lemmas(text):

    lemmas = []

    doc = nlp(text)

    for token in doc: 
        if ((token.is_stop == False) and (token.is_punct == False)) and (token.pos_ != 'PRON'):
            lemmas.append(token.lemma_)

    return lemmas

위 함수를 적용하여 텍스트 데이터 정규화를 진행한다.

df['lemmas'] = df['reviews.text'].apply(get_lemmas)
df['lemmas'].head()
------------------------------------------------------
0    [get, cheap, price, black, friday, fire, great...
1    [purchase, 7, son, 1.5, year, old, break, wait...
2    [great, price, great, battery, buy, anytime, n...
3              [great, tablet, kid, boy, love, tablet]
4    [last, little, use, battery, lead, lamp, 2, 4,...
Name: lemmas, dtype: object

wc = word_count(df['lemmas'])
wc_top20 = wc[wc['rank'] <= 20]

squarify.plot(sizes=wc_top20['percent'], label=wc_top20['word'], alpha=0.6 )
plt.axis('off')
plt.show()

5. 등장 횟수 기반 단어표현(Count-based Representation)

등장 횟수 기반의 단어표현(Count-based Representation)은 단어가 특정 문서(혹은 문장)에 들어있는 횟수를 바탕으로 해당 문서를 벡터화한다.

문서-단어 행렬(Document-Term Matrix, DTM)

벡터화 된 문서는 문서-단어 행렬(Document-Term Matrix, DTM)의 형태로 나타내어진다. 문서-단어 행렬이란 각 행에는 문서(Document)가, 각 열에는 단어(Term)가 있는 행렬이다. 대표적인 방법으로는 Bag-of-Words(TF, TF-IDF)방식이 있다.

TF(Term Frequency)

Bag-of-Words(BoW)는 가장 단순한 벡터화 방법 중 하나이다. 문서(혹은 문장)에서 문법이나 단어의 순서 등을 무시하고 단순히 단어들의 빈도만 고려하여 벡터화한다. 위의 사진처럼 단어를 넣어놓은 가방(Bag of Words)을 두고 각 문장에 어떤 단어가 몇 번 나오는지를 세어서 해당 값을 문장의 벡터로 사용한다.

사이킷런(Scikit-learn, Sklearn) 의 CounterVectorizer 를 사용하면 Bag-of-Words 방식의 벡터화를 사용할 수 있다.

# 모듈에서 사용할 라이브러리와 spacy 모델을 불러옵니다.
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.neighbors import NearestNeighbors
from sklearn.decomposition import PCA

import spacy
nlp = spacy.load("en_core_web_sm")

# 예제로 사용할 text를 선언합니다. 
text = """In information retrieval, tf–idf or TFIDF, short for term frequency–inverse document frequency, is a numerical statistic that is intended to reflect how important a word is to a document in a collection or corpus.
It is often used as a weighting factor in searches of information retrieval, text mining, and user modeling.
The tf–idf value increases proportionally to the number of times a word appears in the document and is offset by the number of documents in the corpus that contain the word,
which helps to adjust for the fact that some words appear more frequently in general.
tf–idf is one of the most popular term-weighting schemes today.
A survey conducted in 2015 showed that 83% of text-based recommender systems in digital libraries use tf–idf."""

# spacy의 언어모델을 이용하여 token화된 단어들을 확인합니다. 
doc = nlp(text)
print([token.lemma_ for token in doc if (token.is_stop != True) and (token.is_punct != True)])
---------------
출력결과는 생략하였다. 토큰화된 단어들이 나오게 된다.

from sklearn.feature_extraction.text import CountVectorizer

# 문장으로 이루어진 리스트를 저장합니다.
sentences_lst = text.split('\n')

# CountVectorizer를 변수에 저장합니다.
vect = CountVectorizer() # Stop_words나, max_features 등의 인자를 설정할 수 있다.

# 어휘 사전을 생성합니다.
vect.fit(sentences_lst)

# text를 DTM(document-term matrix)으로 변환(transform)
dtm_count = vect.transform(sentences_lst)

.vocabulary_메서드를 활용하면 vocabulary(모든 토큰)와 맵핑된 인덱스 정보를 확인할 수 있다.

vect.vocabulary_
-----------------
{'2015': 0,
 '83': 1,
 'adjust': 2,
 'and': 3,
 'appear': 4,
 'appears': 5,
 'as': 6,
 'based': 7,
 'by': 8,
     :
     :

get_feature_names()를 사용하면 추출된 토큰을 볼 수 있으며, get_feature_names()메서드를 사용하면 추출된 토큰의 수를 알 수 있다. 사용 예시는 생략한다.

다음으로 dtm_count타입과 실제 출력을 살펴보겠다.

# CountVectorizer 로 제작한 dtm을 분석해 봅시다.
print(type(dtm_count))
print(dtm_count)
----------------------------------------------
<class 'scipy.sparse.csr.csr_matrix'>
  (0, 9)    1
  (0, 12)    1
  (0, 14)    2
  (0, 18)    1
  (0, 19)    2
    :    :
    :   :

dtm_count 의 타입을 보면 CSR(Compressed Sparse Row matrix) 로 나오게 된다. 해당 타입은 행렬(matrix)에서 0을 표현하지 않는 타입이다. dtm_count 를 출력한 결과에서도 (row, column) count 형태로 출력되는 것을 확인할 수 있다.

만일 그대로의 numpy.matrix타입으로 보고 싶을 경우에는 .todense()메서드를 통해서 확인할 수 있다.

print(type(dtm_count))
print(type(dtm_count.todense()))
dtm_count.todense()
----------------------------------
<class 'scipy.sparse.csr.csr_matrix'>
<class 'numpy.matrix'>
matrix([[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 2, 0, 0, 0, 1, 2, 0,
         0, 0, 1, 1, 1, 2, 0, 1, 1, 1, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
         0, 0, 2, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1,
         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0],
        [0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
         0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0,
         1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
         0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0],
        [0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0,
         0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 0, 2, 1,
         0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,
         6, 1, 1, 0, 0, 0, 0, 1, 0, 0, 2, 0],
        [0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1,
         1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1,
         1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0,
         0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0,
         1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0],
        [1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
         0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,
         0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]])

DataFrame으로 변환하여 확인하고 싶을 경우에는 다음과 같이 코드를 구성할 수 있다.

dtm_count = pd.DataFrame(dtm_count.todense(), columns=vect.get_feature_names())

TF-IDF (Term Frequency - Inverse Document Frequency)

다른 문서에 등장하지 않는 단어. 즉, 특정 문서에만 등장하는 단어에 가중치를 두는 방법이 TF-IDF(Term Frequency-Inverse Document Frequency)이다.

수식은 다음과 같다. $$$ TF -IDF(w) = TF(w)\times IDF(w)\ $$$ TF(Term-Frequency)는 특정 문서에서 단어 w가 쓰인 빈도이다. 분석할 문서에서 단어$w$가 등장하는 횟수를 구하게 된다. $$$ TF(w) = {특정,,문서,,내,,단어,,w의,수\over특정,,문서,,내,,단어,,수} $$$ IDF(Inverse Document Frequency)는 분류 대상이 되는 모든 문서의 수를 단어 $w$가 들어있는 문서의 수로 나누어 준 뒤 로그를 취해준 값이다. 로그를 취해주는 이유는 지프의 법칙에 대해서 찾아보자. $$$ IDF(w)=log({분류,,대상이,,되는,,모든,,문서의,,수\over단어,,w가,,들어있는,,문서의,,수}) $$$ 이론적인 식은 위와 같지만 실제 계산에서는 0으로 나누어 주는 것을 방지하구 위하여 분모에 1을 더해준 값을 사용한다. 분류 대상이 되는 모든 문서의 수($n$단어 $w$가 들어있는 문서의 수)를 $df(w)$라 하면 IDF는 다음과 같이 구해진다. $$$ IDF(w) = log({n\over 1+df(w)}) $$$ 위 식에 따라 자주 사용하는 단어라도, 많은 문서에 나오는 단어들은 IDF가 낮아기 때문에 TF-IDF로 벡터화 했을 때 작은 값을 가지게 된다.

사이킷런(Scikit-learn, Sklearn) 의 TfidfVectorizer를 사용하면 TF-IDF벡터화도 사용할 수 있다.

# TF-IDF vectorizer. 테이블을 작게 만들기 위해 max_features=15로 제한하였습니다.
tfidf = TfidfVectorizer(stop_words='english', max_features=15)

# Fit 후 dtm을 만듭니다.(문서, 단어마다 tf-idf 값을 계산합니다)
dtm_tfidf = tfidf.fit_transform(sentences_lst)

dtm_tfidf = pd.DataFrame(dtm_tfidf.todense(), columns=tfidf.get_feature_names())
dtm_tfidf

TfidfVectorizer를 사용하여 생성한 문서-단어 행렬(DTM)의 값을 CountVectorizer를 사용하여 생성한 DTM의 값과 비교하여 보자.

vect = CountVectorizer(stop_words='english', max_features=15)
dtm_count_vs_tfidf = vect.fit_transform(sentences_lst)
dtm_count_vs_tfidf = pd.DataFrame(dtm_count_vs_tfidf.todense(), columns=vect.get_feature_names())
dtm_count_vs_tfidf

이번에는 하이퍼파라미터를 튜닝해보고, SpaCy tokenizer를 사용해서 벡터화를 진행하여 보겠다.

# SpaCy 를 이용한 Tokenizing

def tokenize(document):
    doc = nlp(document)
    return [token.lemma_.strip() for token in doc if (token.is_stop != True) and (token.is_punct != True) and (token.is_alpha == True)]

    """
    args:
        ngram_range = (min_n, max_n), min_n 개~ max_n 개를 갖는 n-gram(n개의 연속적인 토큰)을 토큰으로 사용합니다.
        min_df = n : int, 최소 n개의 문서에 나타나는 토큰만 사용합니다.
        max_df = m : float(0~1), m * 100% 이상 문서에 나타나는 토큰은 제거합니다.
    """
tfidf_tuned = TfidfVectorizer(stop_words='english'
                        ,tokenizer=tokenize
                        ,ngram_range=(1,2)
                        ,max_df=.7
                        ,min_df=3
                       )

dtm_tfidf_tuned = tfidf_tuned.fit_transform(df['reviews.text'])
dtm_tfidf_tuned = pd.DataFrame(dtm_tfidf_tuned.todense(), columns=tfidf_tuned.get_feature_names())
dtm_tfidf_tuned.head()

유사도를 이용한 문서 검색

검색 엔진은 검색어(Query,쿼리)와 문서에 있는 단어(key,키)를 매칭(Matching)하여 결과를 보여준다. 매칭 방법에는 방법은 여러 가지가 있으나 이번에는 가장 클래식한 방법인 "유사도 측정 방법"을 시도해 보겠다.

코사인 유사도(Cosine Similarity)

코사인 유사도는 가장 많이 쓰이는 유사도 측정방법이다. 두 벡터가 이루는 각의 코사인 값을 이용하여 구할 수 있는 유사도 이다.

• 완전히 같을 경우: 1

• 90도의 각을 이룰 경우: 0
• 완전히 반대방향일 경우: -1

NearestNeighbor(K-NN,K-최근접 이웃)

K-최근접 이웃법은 쿼리와 가장 가까운 상위 K개의 근접한 데이터를 찾아서 K개 데이터의 유사성을 기반으로 점을 추정하거나 분류하는 예측 분석에 사용된다. 사이킷런 sklearn의 NearestNeighbors를 사용하면 K-최근접 이웃 알고리즘을 사용할 수 있다.

from sklearn.neighbors import NearestNeighbors

# dtm을 사용히 NN 모델을 학습시킵니다. (디폴트)최근접 5 이웃.
nn = NearestNeighbors(n_neighbors=5, algorithm='kd_tree')
nn.fit(dtm_tfidf_amazon)

# 2번째 인덱스에 해당하는 문서와 가장 가까운 문서(0포함) 5개의 거리와 문서의 인덱스 출력
nn.kneighbors([dtm_tfidf_amazon.iloc[2]])
--------------------------------------------
(array([[0.        , 0.64660432, 0.73047367, 0.76161463, 0.76161463]]),
 array([[   2, 7278, 6021, 1528, 4947]]))

print(df['reviews.text'][2][:300])
print(df['reviews.text'][7278][:300])
-------------------------------------------------
Great price and great batteries! I will keep on buying these anytime I need more!
Always need batteries and these come at a great price

문서 검색 예제

Amazon Review의 Sample을 가져와서 문서검색에 사용하여 보겠다.

# 출처 : https://www.amazon.com/Samples/product-reviews/B000001HZ8?reviewerType=all_reviews
sample_review = ["""in 1989, I managed a crummy bicycle shop, "Full Cycle" in Boulder, Colorado.
The Samples had just recorded this album and they played most nights, at "Tulagi's" - a bar on 13th street.
They told me they had been so broke and hungry, that they lived on the free samples at the local supermarkets - thus, the name.
i used to fix their bikes for free, and even feed them, but they won't remember.
That Sean Kelly is a gifted songwriter and singer."""]

학습된 TfidfVectorizer를 통해 Sample Review를 변환하여 보겠다.

new = tfidf_vect.transform(sample_review)
nn.kneighbors(new.todense())
-------------------------------------------
(array([[0.69016304, 0.81838594, 0.83745037, 0.85257729, 0.85257729]]),
 array([[10035,  2770,  1882,  9373,  3468]]))

# 가장 가깝게 나온 문서를 확인합니다.
df['reviews.text'][10035]
-------------------------------
"Doesn't get easier than this. Good products shipped to my office free, in two days:)"

회고

어렵다. 너무 어렵다. 다루는 코드도 많아지고 방식들도 다양해지다보니까 머리에 잘 들어오지 않는 것 같다. 설상가상으로 코로나도 걸려서 집중도 잘 안되는 것 같다. 빨리 정신차리고 복습해야하는데 그게 잘 안되는 것 같다. 코로나로 몸이 힘든 것도 맞는데 좋은 핑계가 생겨서 게임하고, 유튜브보고 딴 짓을 너무 많이 하는 것 같다. 정신차리자.... 설날에 공부 좀 해야겠다.

❗ 참고자료

1. 자연어 생성
2. 말뭉치
3. 문서
4. 품사 태깅(POS tagging)
5. 개체명 인식(Named Entity Recognition)
6. 토큰화(Tokenization)

Level 1.

• 신경망에 교차 검증(Cross-Validation)을 적용할 수 있다.
• 하이퍼파라미터 탐색범 중 Grid 탐색법과 Random 탐색법에 대해 말하고 둘을 비교하여 설명할 수 있다.

  Level 2.

• 신경망 주요 용어에 대해 한 줄 이상으로 설명할 수 있다.

  Level 3.

• 실험 계획 라이브러리인 WandB의 사용법을 익히고 Keras를 엮어서 사용해 볼 수 있다.

  1. 교차 검증(Cross-Validation)

  Section2의 N213에서 교차 검증을 다루었다. 교차 검증을 실행할 경우 특정 데이터 세트에 대한 과적합을 방지할 수 있고, 더욱 일반화된 모델을 생성할 수 있다는 장점이 있다. 또한 데이터 세트의 규모가 적을 시 과소적합을 방지할 수도 있다. 하지만 교차 검증을 시행함에 따라서 모델 훈련 및 평가 소요시간이 증가한다는 단점이 있다.

보스턴 집값 실습예제를 통해서 교차 검증이 실제 신경망에서 어떤 식으로 사용되는지 확인하여 보도록 한다.

# 필요한 라이브러리를 import한다.
from tensorflow.keras.datasets import boston_housing
from sklearn.model_selection import KFold, StratifiedKFold
from tensorflow.keras.preprocessing.image import ImageDataGenerator

import numpy as np
import pandas as pd
import tensorflow as tf
import os

# 데이터셋을 불러온다.
(x_train, y_train), (x_test, y_test) = boston_housing.load_data()

# 2가지의 Fold 방법
kf = KFold(n_splits = 5)
skf = StratifiedKFold(n_splits = 5, random_state = 42, shuffle = True) 

위의 코드에서 2가지 Fold방법이 등장한다. 각각의 차이는 다음과 같다.

• KFold: K개의 학습데이터 세트를 일정한 간격으로 나누어 평가 진행, 학습/검증 데이터 셋 나누어 진행

• StratifiedKFold: 불균형한 label비율을 가진 데이터 세트에 적용하는 Fold방법으로 label의 분포 비율을 그대로 유지하여 학습/검증 데이터를 나눈다. 따라서 split()메서드에 피처뿐만 아니라 label데이터 세트도 넣어주어야 한다.

계속해서 예제를 진행한다.

x_train = pd.DataFrame(x_train)
y_train = pd.DataFrame(y_train)

# 모델 생성
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential()
model.add(Dense(64, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(1))

# 교차검증을 이용한 평과결과 출력
for train_index, val_index in kf.split(np.zeros(x_train.shape[0]),y_train):
    training_data = x_train.iloc[train_index, :]
    training_data_label = y_train.iloc[train_index]
    validation_data = x_train.iloc[val_index, :]
    validation_data_label = y_train.iloc[val_index]

    # compile
    model.compile(loss='mean_squared_error', optimizer='adam')

    # 모델 훈련
    model.fit(training_data, training_data_label,
                  epochs=10,
                  batch_size=32,
                  validation_data = (validation_data, validation_data_label),
                  )

    # 모델 평가
    results = model.evaluate(x_test, y_test, batch_size=32)
    print("test loss, test mse:", results)

2. 하이퍼 파라미터 튜닝

하이퍼 파라미터란 모델링 시 사용자가 직접세팅하는 값을 뜻한다. 학습률, epoch, batch size, 각 층의 node 수, 은닉 층의 수 등을 하이퍼 파라미터라고 할 수 있다.

그리고 이런 하이퍼 파라미터 튜닝에는 다양한 것이 존재한다.

위 사진 외에도 정말 다양한 하이퍼 파리미터 튜닝 방식이 존재하며 manual Search방법을 제외한 나머지 방법을 Automated hyperparameter selection이라고 한다.

1. Babysitting or Grad Student Descent

프로젝트나 스프린트에서 모델의 성능을 높이기 위해 여러 숫자를 직접 넣어보며 하이퍼 파라미터를 조정하였다. 이 방식을 육아(Babysitting) 혹은 대학원생 갈아넣기(Grad student descent)라고 한다.

100% 수작업(manual)으로 파라미터를 수정하는 방법으로 학계에서 논문을 출간할 수 있을 정도로 놀라운 정확도를 보여주는 하이퍼파라미터 수치를 찾아내기 위해 쓰는 방법이다.

2. Grid Search

위의 방식을 자동화한 방법이 바로 Grid Search이다. 이 방법에서는 하이퍼파라미터마다 탐색할 지점을 정해주면 모든 지점에 해당하는 조합을 알아서 수행한다.

자동으로 수행되는만큼 프로그램을 돌려놓기만 하면 끝이다. 하지만 범위를 너무 많이 설정하게 되면 프로그램이 끝날 줄 모르고 계속해서 연산을 수행할 수 있다.

그렇기 때문에 이 방법으로 많은 하이퍼 파라미터를 찾으려고 하는 것 보다는 1개, 혹은 최대 2개 정도의 파라미터 최적값을 찾는 용도로 적합하다. 모델 성능에 보다 직접적인 영향을 주는 하이퍼파라미터가 따로 있기 때문에 굳이 많은 하이퍼 파리미터 조합을 시도할 필요는 없다.

높은 영향을 주는 하이퍼 파라미터만 제대로 튜닝해서 최적값을 찾은 후 나머지 하이퍼 파라미터도 조정해 나가면 못해도 90% 이상의 성능을 확보할 수 있다.

당뇨병 데이터셋을 신경망에 적용해보고 배치 사이즈를 여러 개로 조정하면서 최적의 배치 사이즈와 은닉층의 노드 개수를 찾아보겠다.

인공 신경망 모델을 Scikit-learn에서 사용하기 위해 Wrapping을 해주어야 한다. Wrapping하는 방법으로 scikeras를 사용해보겠다.

import numpy
import pandas as pd
from sklearn.model_selection import GridSearchCV
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# scikeras는 별도 설치 필요하나 설치과정 생략.
from scikeras.wrappers import KerasClassifier

#재현성을 위한 랜덤시드 고정
numpy.random.seed(42)

# 데이터셋 불러오기
url ="https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"

dataset = pd.read_csv(url, header=None).values

# Feature와 Label분리
X = dataset[:,0:8]
Y = dataset[:,8]

이후 모델을 제작할 때는 KerasClassifier로 Wrapping하기 위하여 신경망 모델을 함수 형태로 정의한다. 그리고 이때 최초 노드의 개수를 정해주어야 정상 작동한다.

# 모델제작
def create_model(nodes=8):
    model = Sequential()
    model.add(Dense(nodes, input_dim=8, activation='relu'))
    model.add(Dense(nodes, activation='relu'))
    model.add(Dense(1, activation='sigmoid'))

    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model

# Wrapping
model = KerasClassifier(model=create_model, batch_size=8, verbose=False)

# 하이퍼파라미터 탐색
nodes = [16, 32, 64]
batch_size = [16, 32, 64]
param_grid = dict(model__nodes=nodes, batch_size=batch_size)

grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=1, cv=3)
grid_result = grid.fit(X, Y)

# 최적의 결과를 낸 하이퍼파라미터와 각각의 결과 출력
print(f"Best: {grid_result.best_score_} using {grid_result.best_params_}")

means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']

for mean, stdev, param in zip(means, stds, params):
    print(f"Means: {mean}, Stdev: {stdev} with: {param}") 

3. Random Search

Random Search는 무한 루프는 Grid Search의 단점을 해결하기 위해 나온 방법이다. Random Search는 지정된 범위 내에서 무작위로 모델을 돌려본 후 최고 성능의 모델을 반환한다. 시도 횟수를 정해줄 수 있기 때문에 Grid Search에 비해서 훨씬 적은 횟수로도 끝마칠 수 있다.

Grid Search에서는 하이퍼파라미터의 중요도가 모두 동등하다고 가정한다. 하지만 실제로는 더 중요한 하이퍼파라미터가 있다. Radom Search는 상대적으로 중요한 하이퍼파라미터에 대해서는 탐색을 더 하고, 덜 중요한 하이퍼파라미터에 대해서는 실험을 덜 하도록 한다. 하지만 Random Search는 절대적으로 완벽한 하이퍼파라미터를 찾아주지는 않는다.

4. Bayesian Methods

베이지안 방식(Bayesian Method)은 이전 탐색 결과 정보를 새로운 탐색에 활용하는 방법이다. 그렇기 때문에 베이지안 방법을 사용하면 하이퍼파라미터 탐색 효율을 높일 수 있다.

bayes_opt나 hyperopt와 같은 패키지를 사용하면 베이지안 방식을 적용할 수 있다.

더 정확한 베이지안 정리에 대한 설명은 N121을 참고하자.

3. Keras Tuner

Keras Tuner는 케라스 프레임워크에서 하이퍼파라미터를 튜닝하는 데 도움이 되는 라이브러리이다.

Fashion MNIST예제에 Keras Tuner를 적용하여 하이퍼파라미터 튜닝을 수행하여 보겠다.

from tensorflow import keras
from tensorflow.keras.layers import Dense, Flatten

import tensorflow as tf
import IPython

# Keras Tuner Import하기. 설치과정은 생략함.
import keras_tuner as kt

# 데이터 불러오기 및 정규화(Normalizing)
(X_train, y_train), (X_test, y_test) = keras.datasets.fashion_mnist.load_data()
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

다음으로는 모델을 제작하고 탐색할 하이퍼파라미터 범위와 지점을 정의한다. 이 과정에서 Model builder함수(model_builder)를 지정하는 과정이 필요하다. 먼저 model_builder라는 함수를 정의하고 해당 함수 내부에서 모델 설계와 하이퍼파라미터 튜닝까지 모두 수행해보겠다.

def model_builder(hp):
  model = keras.Sequential()
  model.add(Flatten(input_shape=(28, 28)))

  hp_units = hp.Int('units', min_value = 32, max_value = 512, step = 32)
  model.add(Dense(units = hp_units, activation = 'relu'))
  model.add(Dense(10, activation='softmax'))

  hp_learning_rate = hp.Choice('learning_rate', values = [1e-2, 1e-3, 1e-4]) 

  model.compile(optimizer = keras.optimizers.Adam(learning_rate = hp_learning_rate),
                loss = keras.losses.SparseCategoricalCrossentropy(), 
                metrics = ['accuracy'])

  return model

다음으로는 하이퍼파라미터 튜닝을 수행할 튜너(Tuner)를 지정한다. Keras Tuner에서는 Random Search, Bayesian Optimization, Hyperband등의 최적화 방법을 수행할 수 있다.

이번에는 Hyperband를 통해서 튜닝을 수행해보도록 하겠다. Hyperband사용 시 Model builder function(model_builder), 훈련할 최대 epochs 수(max_epochs)등을 지정해주어야 한다. Hyperband 는 리소스를 알아서 조절하고 조기 종료(Early-stopping) 기능을 사용하여 높은 성능을 보이는 조합을 신속하게 통합한다는 장점을 가지고 있다.

tuner = kt.Hyperband(model_builder,
                     objective = 'val_accuracy', 
                     max_epochs = 10,
                     factor = 3,
                     directory = 'my_dir',
                     project_name = 'intro_to_kt')  

하이퍼 파라미터 탐색을 실행하기 전에 학습이 끝날 때마다 이전 출력이 지워지도록 콜백 함수를 정의한다.

class ClearTrainingOutput(tf.keras.callbacks.Callback):
  def on_train_end(*args, **kwargs):
    IPython.display.clear_output(wait = True)

이제 하이퍼 파라미터 탐색을 수행한다.

tuner.search(X_train, y_train, epochs = 10, validation_data = (X_test, y_test), callbacks = [ClearTrainingOutput()])

best_hps = tuner.get_best_hyperparameters(num_trials = 1)[0]

print(f"""
하이퍼 파라미터 검색이 완료되었습니다. 
최적화된 첫 번째 Dense 노드 수는 {best_hps.get('units')} 입니다.
최적의 학습 속도는 {best_hps.get('learning_rate')} 입니다.
""")

최고 성능을 보이는 하이퍼파라미터 조합으로 다시 학습을 진행해보겠다.

model = tuner.hypermodel.build(best_hps)
model.fit(X_train, y_train, epochs = 10, validation_data = (X_test, y_test))

Level 1.

• 학습률(Learning rate)의 개념과 학습률이 너무 크거나 작은 경우 발생하는 문제에 대해 설명할 수 있다.
• 활성화 함수에 맞는 가중치 초기화(Weight Initialization)을 매칭할 수 있다.
• 신경망에 적용할 수 있는 과적합(Overfittion)을 방지할 수 있는 방법(Weight Decay, Dropout, Early stopping)의 개념에 대해 설명할 수 있고 이를 Keras로 적용할 수 있다.

  Level 2.

• 지난 강의에서 배운 내용 외에 해당하는 Optimizer의 특징에 대해 개략적으로 설명할 수 있다.
• Dropout의 효과와 Evaluation단계에서 Dropout이 어떻게 적용되는지 설명할 수 있다.

  Level 3.

• 배치 정규화(Batch Normalization)를 이해하고 이를 Keras 코드로 신경망에 적용할 수 있다.

1. 학습률 감소 or 계획법(Learing rate Decay or Scheduling)

학습률(Learing rate,lr)이란 매 가중치에 대해 구해진 기울기 값을 얼마나 경사 하강법에 적용할지를 결정하는 하이퍼 파라미터이다.

경사하강법이 산긴을 내려가는 과정을 의미한다면, 학습률은 보폭을 결정하게 된다. 따라서 학습률이 크면 Iteration마다 값이 크게 변하게 되고, 작으면 조금씩 이동하게 된다.

따라서 학습률을 잘못 설정하게 되면 위의 그림과 같이 된다. 위의 그림을 설명하면 다음과 같다.

💡 학습률이 너무 낮을 때 최적점에 이르기까지 너무 오래 걸리거나, 주어진 Iteration 내에서 최적점에 도달하는 데 실패한다.

💡 학습률이 너무 클 때 경사하강 과정에서 발산하면서 모델이 최적값을 찾을 수 없게 된다.

따라서 최적의 학습률을 찾는 것은 학습에서 중요한 요소이다. 따라서 최적의 학습률을 찾기 위하여 사용하는 방법이 학습률 감소/계획법이다.

1. 학습률 감소(Learing rate Decay)

학습률 감소는 Adagrad, RMSprop,Adam과 같은 옵티마이저에 이미 구현되어 있기 때문에 쉽게 적용할 수 있다. 위의 옵티마이저의 하이퍼 파라미터를 조정하면 감소 정도를 변화시킬 수 있다.

• 옵티마이저(Optimizer)의 다양한 하이퍼파리미터를 조정하여 적용

  tf.keras.optimizers.Adam(
  learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, amsgrad=False,
  name='Adam'
  )

  위에서 사용된 옵티마이저인 Adam알고리즘은 Momentum과 RMSProp을 조합한 옵티마이저이다.

dadelta와 RMSprop이 직전의 단계인 $t-1$까지 경사의 제곱의 이동평균 $v_t = E[g^2]_t$를 지수함적으로 감쇠평균적으로 감쇠평균한 항을 저장해가며 유지하고 매개변수의 변경식에 이 값을 사용했던 것과는 달리 adam에서는 추가로 단순한 경사의 이동평균인 $m_t=E[g]_t$를 지수함수적으로 감쇠시킨 항도 사용한다. 많은 수학적인 공식이 존재하지만 adam알고리즘에서 학습률의 계산은 다음과 같은 식으로 이루어진다.

$$$ \alpha_t = \alpha\cdot{\sqrt{1-\beta^t_2}\over 1-\beta^t_1} $$$ 보통 이 포스트에는 서술하지 않았지만 다른 식에 있는 $zeta$를 0으로 근사시키기 위해서 보통 $\beta_1=0.9,,\beta_2=0.999$로 설정한다. defalut값 역시 이로 설정되어 있다.

epsilon은 아직 무엇인지 정확히 모르겠다. 그리고 amsgrad인자는 AMSGrad변형을 적용할지 여부를 설정하는 인자로, 자세한 설명은 참고자료의 2번을 참고하자.

• 신경망을 compile하는 코드에 하이퍼파라미터를 조정하는 옵티마이저 적용

  model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.001, beta_1 = 0.89),
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

  2. 학습률 계획법(Learning rate Scheduling)

  학습 과정에 학습률을 바꿔가는 메카니즘을 골라서 처리하는 과정을 학습률 계획 또는 학습률 스케쥴이라고 한다.

아래의 그래프와 같이 Warm-up Step을 포함한 학습률 계획 방법을 적용하기도 한다. 그리고 그래프에 나타난 두가지 계획법에 대해서도 알아보자.

2-1. Step Learning rate Decay Scheduling

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.callbacks import LearningRateScheduler

import tensorflow as tf
import numpy as np

def step_decay(epoch):
    start = 0.1
    drop = 0.5
    epochs_drop = 5.0
    lr = start * (drop ** np.floor((epoch)/epochs_drop))
    return lr

model = Sequential([Dense(10)])
model.compile(optimizer=SGD(), loss='mse')

lr_scheduler = LearningRateScheduler(step_decay, verbose=1)

history = model.fit(np.arange(10).reshape(10, -1), np.zeros(10),
                    epochs=10, callbacks=[lr_scheduler], verbose=0)

가장 많이 사용되는 학습률 스케줄 방법으로는 스텝 스케줄이 있다. ResNet에서 잘 사용하고 있는 계획법이다.

처음에는 상대적으로 큰 학습률로 시작하여 최적화 과정에서 특정 지점에서 학습률을 감쇄시키고자 더 낮은 학습률을 사용한다. 위의 왼쪽 그림은 학습률 감쇄 스케쥴이라고 부르는 건데, 여기서 비용 함수의 특성이 나타나는 곡선을 볼수 있다. 여기서 스텝 학습률 감쇠로 첫 30 에폭 페이스에선 상대적으로 큰 학습률을 사용해서 빠르게 진행을 하여, 큰 값으로 시작했던 초기 비용을 지수적으로 줄일수가 있었다.

하지만 30 에폭쯤에서 처음 처럼 빠르게 진행할 수가 없어, 이 30에폭 시점에서 학습률을 감쇄시켜 10으로 나눈뒤 학습을하면 다시 비용이 급격히 떨어져 지수적인 패턴이 나오기 시작한다. 또 다시 평탄한 부분이 나오면 60 에폭 쯤에서 학습률을 다시 감쇄하여 빠르게 떨어트리고 다시 평탄해지는 스케줄을 사용하였을때 이런 특성이 나타나게 된다. 이게 스탭 학습률 스캐쥴이란 방법으로 모델을 학습시킬때 볼수 있는 학습률 곡선의 특성 형태이다.

이 계획법의 경우 모델을 학습하는데 여러개의 하이퍼파라미터가 필요하고, 따라서 튜닝하는데 워낙 많은 경우의 수가 생겨 상당히 많은 시간이 소요된다. 그래서 최근에너는 이런 단점을 극복한 다양한 계획법이 나왔다.

2-2. Cosine Learning rate decay Scheduling

스텝 학습률 감소 계획법의 단점을 극본한 방법 중 하나이다. 특정 반복 회차, Epoch에서 감쇄하는 것이 아니라 사간에 대한 함수를 사용한다. 학습률은 모든 Epoch 회차에 대한 함수로 정해진다.

이 계획법은 하이퍼파라미터가 초기 학습률로 사용할 $\alpha_0$와 학습할 에폭의 수 2개이다. 따라서 이전의 스텝 감쇄 계획법보다 다루기가 쉬우며, 일반적으로 학습을 길게 할수록 잘 동작하는 경향을 보인다.

first_decay_steps = 1000
initial_learning_rate = 0.01
lr_decayed_fn = (
  tf.keras.experimental.CosineDecayRestarts(    
      initial_learning_rate,
      first_decay_steps))


model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=lr_decayed_fn),
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

2. 가중치 초기화(Weight Initialization)

신경망 모델 학습의 목적은 파라미터 최적화이다. 이를 위해서 손실함수에 대해서 경사하강법을 수행한다. 그런데 동일한 경사하강법을 따라서 내려가더라도 위의 그림에서 보듯이 도달하는 최적점이 다른 것을 볼 수 있다. 시작 위치에 따라서 최적점이 달라지게 되는 것이다. 이처럼 첫 위치를 잘 정하는 것도 좋은 학습을 위한 조건 중 하나이다.

따라서 학습 시작 시점의 가중치를 잘 정해주야하고, 이를 위해서 상황에 맞는 적절한 가중치 초기화(Weight initialization) 방법을 사용하게 된다.

1. 가중치 초깃값 = 0

가중치의 초기값을 0으로 default를 주고 시작하면 올바른 학습을 기대하기 어렵다. 오차역전파에서 가중치의 값이 똑같이 갱신되기 때문이다. 가중치가 각각 영향이 있어야 하는데 고르게 되어버리는 상황이 발생하면 각각의 노드를 만든 의미를 잃어버리게 된다

그래서 Keras에서는 Default로 되어 있는 가중치초기화 옵션은 random initialization이다. 하지만 이방식은 역전파 과정에서 미분한 Gradient가 지나치게 커지거나 소실되는 문제에 빠질 위험성이 크다.

2. Sigmoid 함수 가중치 초깃값 설정: Xavier

2-1. 표준편차를 1인 정규분포로 가중치 초기화

표준편차가 일정한 정규분포로 가중치를 초기화 해 줄 때에는 대부분의 활성화 값이 0과 1에 위치하는 것을 볼 수 있다. 이는 Sigmoid 함수의 특성으로 인한 것이다.

이렇게 활성값이 양 끝 단에 집중적으로 분포되어 고르지 못할 경우에는 학습이 제대로 이루어지지 않는다. 그렇기 때문에 가장 간단한 방법임에도 잘 사용하지 않는다.

2-2. Xavier Initialization

Xavier 초기화(Xavier initialization)는 가중치를 표준편차가 고정값인 정규분포로 초기화 했을 때의 문제점을 해결하기 위하여 등장한 방법이다.

Xavier초기화는 이전 층의 노드가 $n$개 일 때, 현재 층의 가중치를 표준편차가 $1\over\sqrt{n}$인 정규분포로 초기화한다.

Keras에서는 이전 층의 노드가 $n$개이고 현재 층의 노드가 $m$개일 때, 현재 층의 가중치를 표준편차가 $2\over{\sqrt{n+m}}$인 정규분포로 초기화 한다. 또한 glorot라는 이름으로 사용한다.

3. ReLU 함수 가중치 초깃값 설정: He

Xavier초기화는 활성화 함수가 시그모이드인 신경망에서는 잘 작동한다. 하지만 활성화 함수가 ReLU인 신경망에서는 층이 지날수록 활성값이 고르지 못하게 되는 문제를 보이게 된다.

이런 문제를 해결하기 위해 등장한 것이 바로 He 초기화(He initialization이다. He초기화는 이전 층의 노드가 $n$개일 때, 현재 층의 가중치를 표준편차가 $2\over\sqrt{n}$인 정규분포로 초기화한다. He초기화를 적용하면 아래 그림처럼 층이 지나도 활성값이 고르게 유지되는 것을 확인할 수 있다.

위의 방법 외에도 여러 가지가 있다. 케라스에서는 아래와 같은 가중치 초기화 방법을 제공하고 있다.

['uniform', 'lecun_uniform', 'normal', 'zero', 'glorot_normal', 'glorot_uniform', 'he_normal', 'he_uniform']

케라스의 Dense layer에서는 default로 glorot_uniform이 설정되어 있다. 적용하는 방법은 다음과 같다.

Dense(32, activation='relu', kernel_initializer='he_uniform')

3. 과적합 방지를 위한 방법들

인공 신경망의 노드 수와 층을 늘리다 보면 매개 변수가 상당히 많아진다. Fashion MNIST예제를 풀기 위해서 구축한 신경망에서는 은닉층 없이 출력층만 설계했음에도 7,850개의 파라미터가 있었다. 딥러닝, 즉 은닉층이 3개 이상인 신경망에는 훨씬 더 많은 수의 파라미터가 있다.

머신러닝에서는 모델이 복잡해지면 과적합(Overfitting)문제가 발생하는 경향이 있다. 이러한 과적합 방지를 위해서 사용되는 방법들에 대해 알아보자.

1. Weight Decay(가중치 감소)

$$$ L_1(\theta_w)={1\over2}\sum_i(output_i-target_i)^2+\lambda\cdot\vert\vert\theta_w\vert\vert_1 \L_2(\theta_w)={1\over2}\sum_i(output_i-target_i)^2+\lambda\cdot\vert\vert\theta_w\vert\vert_2 $$$ 과적합은 가중치의 값이 클 때 주로 발생한다. 가중치 감소에서는 가중치가 너무 커지지 않도록 가중치 값이 너무 커지지 않도록 조건을 추가한다. 이 과정에서 손실 함수(Cost function)에 가중치와 관련된 항을 추가하게 된다.

조건을 어떻게 적용할지에 따라 L1 Regularization(LASSO), L2 Regularization(Ridge) 으로 나뉜다. 그 식은 위에 나타내었다.

Keras에서는 아래와 같이 가중치 감소를 적용하고 싶은 층에 regularizer파라미터를 추가하면 된다.

Dense(64,
      kernel_regularizer=regularizers.l2(0.01),
      activity_regularizer=regularizers.l1(0.01))

2. Dropout(드롭아웃)

Dropout(드롭아웃)은 Iteration마다 레이어 노드 중 일부를 사용하지 않으면서 학습을 진행하는 방법이다. 매 Iteration마다 랜덤하게 노드를 차단하여 다른 가중치를 학습하도록 조정하기 때문에 과적합을 방지할 수 있게 된다.

Dropout을 적용할 때에는 0 ~ 1 사이의 실수를 입력할 수 있지만, 보통 0.3 ~ 0.5 사이의 값을 사용한다.

Keras에서는 아래와 같이 Dropout을 적용하고 싶은 층 다음에 Dropout함수를 추가하면 된다.

Dense(64,
      kernel_regularizer=regularizers.l2(0.01),
      activity_regularizer=regularizers.l1(0.01))
Dropout(0.5)

3. Early Stopping

위의 그림에서 볼 수 있는 것처럼 학습(Train)데이터에 대한 손실은 계속 줄어들지만 검증(Validation)데이터셋에 대한 손실은 증가한다면 학습을 종료하도록 설정하는 방법이다.

이제 Fashion MNIST예제에서 구축 신경망에 조기 종료(Early Stopping)를 적용하여 보겠다.

from tensorflow.keras.datasets import fashion_mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Dropout
from tensorflow.keras import regularizers

import os
import numpy as np
import tensorflow as tf
import keras

# 시드 고정
np.random.seed(42)
tf.random.set_seed(42)

# 데이터셋 불러오기
(X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()

# 데이터 정규화(Normalization)
X_train = X_train / 255.
X_test = X_test / 255.

신경망 모델을 구축하고 Compile한다. 이 과정에서 Weight Decay(가중치 감소), Dropout(드롭아웃)을 적용하여 본다.

model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(64,
          kernel_regularizer=regularizers.l2(0.01),     # 가중치 감소
          activity_regularizer=regularizers.l1(0.01)),  # 가중치 감소
    Dropout(0.5), # Dropout 적용
    Dense(10, activation='softmax')
])

compile설정에서 힉습률 감소(Learning rate Decay)를 적용하여 본다.

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001, beta_1 = 0.89)
             , loss='sparse_categorical_crossentropy'
             , metrics=['accuracy'])

그런 다음 신경망 모델을 학습하고 이 과정에서 Early Stopping을 적용할 수 있도록 파라미터 저장 경로와 조기 종료 옵션을 설정하여 준다.

# 파라미터 저장 경로를 설정하는 코드입니다.
checkpoint_filepath = "FMbest.hdf5"

early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1)

save_best = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_filepath, monitor='val_loss', verbose=1, save_best_only=True,
    save_weights_only=True, mode='auto', save_freq='epoch', options=None)

위의 코드에서 tf.keras.callbacks.ModelCheckpoint는 어떤 지표로 모니터하고, 어느 경로로 저장하며, 최적의 값만 저장하는지, 또 그중에서 가중치만 저장하는지 등 다양한 설정을 하는 것이다.

model.fit(X_train, y_train, batch_size=32, epochs=30, verbose=1, 
          validation_data=(X_test,y_test), 
          callbacks=[early_stop, save_best])

콜백(Callback)에 의해 Best 모델의 파라미터가 제대로 저장되었는지 확인하고 해당 모델로 평가를 진행한다.

model.load_weights(checkpoint_filepath)
model.predict(X_test[0:1])
test_loss, test_acc = model.evaluate(X_test,  y_test, verbose=1)

4. Batch normalization(배치정규화)

배치정규화 참고 사이트

• https://gaussian37.github.io/dl-concept-batchnorm/
• https://buomsoo-kim.github.io/keras/2018/04/24/Easy-deep-learning-with-Keras-5.md/

❗ 참고자료

1. 옵티마이저
2. AMSgrad논문 정리 velog
3. 가중치 초기화

Level 1.

• 신경망이 학습되는 메커니즘(순전파, 손실계산, 역전파)에 대해 적절한 비유를 들어 설명할 수 있다.
• 경사 하강법(Gradient Descent, GD)을 통해 갱신되는 과정을 대략적으로 설명할 수 있다.
• 옵티마이저(Optimizer)의 개념과 확률적 경사 하강법(Stochastic Gradient Descent, SGD) 및 미니 배치 경사 하강법(Mini-Batch Gradient Descent)의 개념에 대해 설명할 수 있다.

  Level 2.

• 편미분(Partial Derivatives)과 연쇄 법칙(Chain Rule)에 대해 이해하고 곱셉 노드, 덧셈 노드 및 활성화 함수에 대한 미분 예제를 풀 수 있다.
• 편미분과 연쇄법칙을 사용하여 역전파 과정을 설명할 수 있다.

  Level 3.

• 이론적으로 이해한 내용을 파이썬 코드로 구현할 수 있다.
• 구현한 함수를 모두 엮어 신경망 학습을 파이썬 코드로 작성할 수 있다.

  1. 신경망 학습(Training Neural Network)

  

신경망은 기본적으로 위의 gif파일처럼 학습된다.

1. 데이터가 입력되면 신경망 각 층에서 가중치 및 활성화 함수 연산을 반복적으로 수행한다.
2. 1의 과정을 모든 층에서 반복한 후에 출력층에서 계산된 값을 출력한다.
3. 손실함수를 사용하여 예측값(Prediction)과 실제값(Target)의 차이를 계산한다.
4. 경사하강법과 같은 방법과 역전파를 통해서 각 가중치를 갱신한다.
5. 학습 중지 기준을 만족할 때까지 위의 과정을 반복한다.

이때 1~4까지의 과정을 Iteration이라고 하며 매 Iteration마다 가중치가 갱신된다. Iteration은 순전파(1,2), 손실계산(3), 역전파(4)로 나눌 수 있다.

1. 순전파(Foward Propagation)

순전파는 입력층에서 입력된 신호가 은닉층의 연산을 거쳐 출력층에 값을 내보내는 과정이다. 각 층에서 이루어지는 연산 과정은 다음과 같다.

1. 입력층(혹은 이전 은닉층)으로부터 신호를 전달받는다.
2. 입력된 데이터에 가중치-편향 연산을 수행한다.
3. 가중합을 통해 구해진 값은 활성화 함수를 통해 다음 층으로 전달된다.

가중치-편향 연산과 활성화 함수를 적용하는 과정을 수식적으로 나타내면 다음과 같다. $$$ x^{(l+1)}i = g(s^{(l)}_i) \ ,\ s^{(l)}_i = w^{(l)}{0i} + w^{(l)}{1i}x^{(l)}{1} + w^{(l)}{2i}x^{(l)}{2}+\cdot\cdot\cdot,+w^{(l)}{(n-1)i}x^{(l)}{n-1} + w^{(l)}{ni}x^{(l)}{n} $$$

• $g()$: 활성화 함수

• $l$: Layer층 수
• $i$: Node 번호
• $s^{(l)}_i$: $l$번째 층 Layer에서 $(l+1)$번째 층 Layer의 i번째 노드로 출력되는 가중합
• $w^{(l)}_{ji}$: $l$번째 층 Layer의 $j$번째 Node에서 $(l+1)$번째 층의 $i$번째 node로 연결된 가중치
• $x^{(l)}_{i}$:$l$번째 층 Layer의 $i$번째 노드의 값

2. 손실함수(Loss function)

신경망은 손실 함수를 최소화 하는 방향으로 가중치를 갱신한다. 그렇기 때문에 손실 함수를 잘 정의해야 가중치가 제대로 갱신될 수 있다. 입력데이터를 신경망에 넣어 순전파를 거치면 마지막에는 출력층을 통과한 값이 도출된다. 이 때 출력된 값과 그 데이터의 타겟값을 손실 함수에 넣어 손실(Loss or Error)를 계산하게 된다.

대표적인 손실 함수로는 앞 서 배운 Section2에서 다루었던 MSE(Mean-Squared Error), CEE(Cross-Entropy Error) 등이 있다.

일반적으로 각 문제에서 사용하는 손실 함수가 있다.

• 📌 회귀: MSE, MAE

• 📌 이진 분류: binary_crossentropy
• 📌 다중 분류
  • One-Hot Encoding으로 라벨링 되었을 때: Categorical_crossentropy
  • Index 형식으로 라벨링 되었을 때: sparse_categorical_crossentropy

3. 역전파(Backward Propagation)

역전파(Backward Propagation)는 말 그대로 순전파와는 반대 방향으로 손실(Loss or Error) 정보를 전달해주는 과정이다.

순전파가 입력 신호 정보를 입력층부터 출력층까지 전달하여 값을 출력했다면, 역전파는 구해진 손실 정보를 이용하여 출력층부터 입력층까지 전달하여 각 가중치를 얼마나 업데이트 해야할 지를 구하는 알고리즘이다.

이 알고리즘을 수식으로 정리하여보았다.

역전파 알고리즘의 수식에서 가장 중요한 것은 미분과 Chain Rule이다. 위의 그림에서도 복잡한 미분을 편미분을 통하여 각각의 변수에 대한 미분으로 나누어 진행하게 된다.

신경망은 매 반복마다 손실(Loss)을 줄이는 방향으로 가중치를 업데이트한다. 그리고 위의 그림에 설명하였듯이 손실을 줄이기 위해서 경사하강법(Gradient Descent), 확률적 경사하강법(Stochastic Gradient Descent, SGD), Mini-batch Gradient Descent 등의 옵티마이저(Optimizer) 사용한다.

4. 옵티마이저(Optimizer)

옵티마이저는 쉽게 말해 경사를 내려가는 방법을 결정한다.

4-1. 경사하강법(Gradient Descent, GD)

경사하강법은 앞의 N134에서 다루었었다. 다시 한 번 예시들어 설명하자면 앞이 보이지 않는 안개가 낀 산을 내려올 때, 모든 방향으로 산을 더듬어가며 산의 높이가 가장 낮아지는 방향으로 한 발씩 내딛어 가는 것이 경사하강법을 직관적으로 이해하기 가장 쉬운 예시이다.

오차함수가 최소가 되는 점을 찾기 위해서 미분을 활용한다. 경사하강법이라는 이름에서 알 수 있듯이 함수의 기울기를 활용하여 $\theta$의 값을 어디로 옮겼을 때 함수가 최솟값을 찾는지 알아본다.

일반적인 경사하강법에서는 모든 입력 데이터에 손실 함수의 기울기를 계산한 후에 가중치를 업데이트 하였다. 즉 1번의 Iteration마다 모든 데이터를 사용한다. 만약 입력데이터가 적다면 경사하강법으로도 빠르게 가중치를 금방 갱신할 수 있다.

자세한 수학적 공식과 알고리즘은 N134를 참고하자.

4-2. 확률적 경사하강법(Stochastic Gradient Descent, SGD)

경사하강법의 경우 많은 양의 데이터를 다루게 되면 모든 데이터에 대해 손실을 계산하기 때문에 이 과정이 굉장히 오래 걸리게 된다. 그래서 등장한 것이 바로 확률적 경사 하강법과 미니 배치(Mini-batch) 경사 하강법이다.

확률적 경사하강법(SGD)은 전체 데이터에서 batch_size가 1인, 즉, 하나의 데이터만을 뽑아서 신경망에 입력한 후 손실을 계산한다. 그리고 그 손실 정보를 역전파하여 신경망의 가중치를 업데이트하게 된다.다시 말하면 1번의 Iteration에는 1개의 데이터만 사용하게 되고, 따라서 1번의 epoch에서 전체 데이터 수만큼의 Iteration이 진행된다.

각 Iteration에서 1개의 데이터만 사용하기 때문에 가중치를 빠르게 업데이트할 수 있다는 장점이 있다. 물론 확률적 경사 하강법에도 단점이 있다. 1개의 데이터만 보기 때문에 학습 과정에서 불안정한 경사 하강을 보인다.

4-3. Mini-batch Gradient Descent

경사하강법의 단점과 확률적 경사하강법의 단점을 보완하기 위해서 그래서 두 방법을 적절히 융화한 Mini-batch Gradient Descent가 등장한다.

N개의 데이터로 미니 배치를 구성하여 해당 미니 배치를 신경망에 입력한 후 이 결과를 바탕으로 가중치를 업데이트 한다. 즉 1번의 Iteration마다 N개(=batch size)의 데이터를 사용하게 되고 결국 Iteration 수는 다음과 같이 결정된다. $$$ Iteration = {# , of , Data \over Batch,Size} $$$ 이때, Keras에서는 전체 데이터를 batch_size로 나누었을 때 나머지가 생기면 그 나머지 그대로를 사용하여 Iteration 진행한다. 즉, 나눈 값을 올림하여 주면 1epoch에서의 전체Iteration 수가 된다.

일반적으로 batch_size는 2의 배수로 결정되먀, 메모리가 허락한다면 큰 사이즈를 쓰는 것이 안정적인 학습에 도움이 된다. 실제로는 32~128정도 사이의 크기가 주로 쓰인다고 한다.

위의 3가지 예시 외에도 다양한 옵티마이저들이 존재한다.

• 확률적 경사하강법(SGD)을 변형한 알고리즘: Momentum, RMSProp, Adam 등
• Newton's method등의 2차 최적화 알고리즘 기반 방법: BFGS 등 (수치해석 책 참조하자.)

여러가지 옵티마이저 중에서 어떤 것이 가장 좋다고 말하기는 어렵다. 문제마다, 데이터마다 달라지기 때문에 여러 옵티마이저를 적용하면서 서로 비교하여 보아야 한다.

2. 회고

이번 Sprint는 뭔가 딥러닝을 위한 개념학습을 진행하는 것 같은 느낌이 든다. 레퍼런스에 다양한 수식과 파이썬으로 직접 신경망을 구성하는 코드들이 나와있는데, 아직 그것까지는 학습하지 못했다. 주말을 이용해서 추가적으로 학습해야할 것 같다.

그리고 뭔가 코드를 안만지니까 다시 전공 수업듣는 느낌이 든다. 조금 더 많은 딥러닝 알고리즘과 코드들을 만져보고 싶다.

Level 1.

• 퍼셉트론(Perceptron)의 개념과 구조에 대해 설명할 수 있다.
• 신경망을 왜 다층으로 구성해야 하는 지와 신경망 각 층(입력층, 은닉층, 출력층)의 역할에 대해 설명할 수 있다.
• MINIST 예제 코드를 이해하고 재현할 수 있다.

  Level 2.

• 가중치 행렬의 Shape과 신경망 구조에 대해서 이해하고 설명할 수 있다.
• 활성화 함수의 공통점과 신경망의 특징인 표현 학습에 대해 이해한다.

  Level 3.

• 시그모이드 함수의 단점인 기울기 소실 문제와 ReLU함수를 쓰는 이유에 대해 이해할 수 있다.
• 파이썬 기본 코드로 퍼셉트론을 구현할 수 있다.

  1. 퍼셉트론(Perceptron)과 인공신경망(Artificial Neural Networks)

  

인공신경망(Artificial Neural Networks)는 1943년 워렌 맥컬록(Warren McCulloch)이라는 신경생리학자가 처음 제시한 개념으로 기계를 학습시키는데 있어서 인간의 신경세포인 뉴런을 모방하는 수학적인 모델을 제시하였다.

이후 1958년 프랑크 로젠블랫(Frank Rosenblatt)은 이런 인공신경망의 최소 단위를 퍼셉트론(Perceptron)으로 정의하고 이들의 연결로 인지과정을 이해할 수 있을 것이라고 기대했다.

퍼셉트론은 이진 분류(binary Classification)모델을 학습하기 위한 지도학습(Supervised Learing)기반의 알고리즘이다. 수학적인 측면에서 2가지 클래스를 특정 기준 하에 구분하는 방법이다. 그리고 클래스를 구분하는 기준(아래 그림에서는 빨간선)을 Decision Boundary라고 부른다.

퍼셉트론은 뉴런이 다른 뉴런으로부터 신호를 입력받듯이 다수의 값 $x$를 입력받고, 입력된 값마다 가중치($weight$)를 곱한다. 여기서 가중치는 생물학 뉴련에서 뉴런 간 시냅스를 통한 결합의 세기와 같은 역할이며 가중치가 클수록 입력값이 중요하다는 것을 의미한다.

이때 위 그림을 살펴보면 입력값에 1과 가중치에 $b$가 있는 것을 볼 수 있다. 이것을 편향($bias$,b)이라고 한다. 이는 딥러닝 모델 최적화의 중요 변수 중 하나이다. 일반적으로 입력값을 1로 고정하고 편향 b를 곱한 변수로 표현한다. 입력값과 가중치의 곱, 편향은 퍼셉트론으로 전달된다. 퍼셉트론은 입력받은 값을 모두 합산하는데, 합산된 결괏값을 가중합이라고 부른다. 퍼셉트론은 이 가중합의 크기를 임계값과 비교하는 활성화 함수(Activation Function)을 거쳐 최종 출력값을 결정한다. 활성화 함수는 다시 말해서 계산된 가중합을 얼마 만큼의 신호로 출력할지 결정하는 출력과 관련이 있는 함수이다. 다양한 활성화 함수가 존재하며 이는 아래에서 다루도록 한다.

이러한 퍼셉트론이 처음 수행한 작업은 논리연산이다. 자동제어 시간에 들은 AND, OR, NAND Gate가 이런 논리연산의 예시로, 적절한 매개변수(가중치와 편향)를 선택하여 논리연산을 수행할 수 있다. 이러한 사실은 당시 과학자 들을 매우 흥분시켰다. 하지만 1969년 MIT 인공지능 연구소의 마빈 민스키(Marvin Minsky)와 페퍼트 세이모어(Papert Seymour)는 이런 퍼셉트론이 XOR Gate(배타적 논리합, 비선형 연산자)을 표현할 수 없다는 당시 퍼셉트론의 한계이자 맹점을 지적하였다.

한 개의 퍼셉트론은 2차원 공간을 나누는 1차원 직선으로 해석할 수 있다. 입력이 2차원 이상인 n차원 초공간에서 퍼셉트론은 (n-1)차원 초평면에 해당한다. 이런 기하학적 해석에 따르면 위의 그림에서 보듯이 XOR은 퍼셉트론 한 개로 검은 점과 흰 점을 나눌 수 없음이 자명하다. 이런 퍼셉트론의 한계는 머신러닝의 첫 어둠의 시기를 촉발했다.

이러한 문제를 해결하기 위하여 은닉층을 이용하여 여러 개의 퍼셉트론을 쌓는 방법이 제시되었다. 배타적 논리합 문제에서 직선 2개를 이용하면 검은 점과 흰 점을 구분할 수 있다. 이 직선을 수직으로 표현하면 다음과 같다. $$$ S1 = W_{11}x_1+W_{12}x_2-b_1=0,\ S2 = W_{21}x_1+W_{22}x_2-b_2=0 $$$ 여기서 입력 $(x_1,x_2)$의 좌표변환 $z_1=f(s_1)$과 $z_2=f(s_2)$를 통해 좌표계를 변환하여 주면 $(z_1,z_2)$에서는 검은 점과 흰 점을 비로소 한 개의 직선으로 나룰 수 있다. 이를 신경망의 신호흐름으로 나타내면 위의 그림에서처럼 입력 신호$(x_1,x_2)$가 은닉층(Hidden layer)의 숨은 뉴런의 활성화 상태$(z_1,z_2)$로 변환되고 이는 최종적으로 출력신호 $y$로 변환된다. 즉 은닉층을 추가함으로써 단일 퍼셉트론으로 구성된 신경망에서는 표현할 수 없는 XOR을 표현할 수 있게 된 것이다.

이 결론을 일반화 한 것이 보편적 어림정리(Universal Approximation Theorem)정리이다. 충분히 많은 뉴런들로 구성된 은닉층을 가진 신경망은 임의의 입력 $x$와 출력 $y$사이의 함수관계 $y=f(x)$를 표현할 수 있다는 정리이다. 이는 임의의 입력 $x$와 출력 $y$사이의 관계를 표현할 수 있는 신경망이 반드시 존재함을 보장한다. 그렇다고 이 정리가 신경망 구성을 위한 최소한의 은닉 뉴런 수, 신경망의 매개변수 값들을 구체적으로 알려주진 않는다.

즉 주어진 문제를 풀 수 있는 매개변수의 최적값을 알 수 없다. 배타적 논리합과 같은 간단한 문제는 2차원 좌표 위의 기하학적 모습을 토대로 매개변수 값을 쉽게 정할 수 있지만, 다차원의 입력과 출력 사이의 관계를 다루는 일반적인 문제에서는 간단하지 않다. 이러한 문제를 해결하기 위하여 제시된 방법이 바로 역전파(Backpropagation) 알고리즘이다.

역전파 알고리즘은 지도학습 문제에서 신경망을 학습시키는 방법이다. 결과를 알고 있기 때문에 Output에 대한 오차값을 이용하여 경사하강법(Gradient Descent Method)을 이용하여 매개변수를 갱신한다. 이를 사용하여 순전파와 역전파를 반복해나아가면 이론적으로는 오차가 0에 가까워진다. 하지만 경사하강법의 한계로 인하여 항상 Global minimum을 찾는다고 보장할 수 없다. 또한 극소값이 두 개 이상 존재하는 함수에 대해서 가장 작은 최솟값을 가진다고 할 수 없고, 알고리즘 자체가 단순히 기울기가 작아지는 방향으로 나아가기 때문에, 출발지점에 따라서 결과가 달라질 수 있다.

다시 처음으로 돌아와서 인공신경망을 다시 설명하여 보자면 퍼셉트론으로 구성된 인간의 신경세포를 모방한 구조를 이용하여 컴퓨터를 가르치는 인공지능 방식이라고 할 수 있으며 줄여서 뉴럴넷(Neural-Net)으로 부르기도 한다. 그 구조는 입력층, 은닉층, 출력층으로 구성되어 있다.

신경망은 퍼셉트론을 여러 층으로 쌓아서 만들게 된다. 1개 층으로 이루어진 신경망은 단층 퍼셉트론 신경망이라고 한다. 그리고 1개 층으로는 해결할 수 없는 문제(ex. XOR)를 해결하기 위해서 2개 이상의 층으로 구성하여 여러 개의 층으로 쌓아 구축한 신경망을 다층 퍼셉트론 신경망(Multi-Layer Perceptron, MLP)라고 한다.

1. 신경망의 각 층

1-1. 입력층(Input Layer)

• 데이터가 입력되는 층이다.
• 데이터의 특징의 수에 따라서 입력층의 노드수가 결정된다.
• 그냥 값들을 전달하기만 하는 층이기 때문에 신경망의 층수를 셀 때 입력층은 포함되지 않는다.

  1-2. 은닉층(Hidden Layers)

• 입력층으로부터 입력된 신호가 가중치, 편향을 이용하여 연산되는 층
• 입력층과 출력층 사이에 존재하는 층을 의미한다.
• 계산 결과를 사용자가 볼 수 없기 때문에 은닉층(Hidden Layer)라고 한다.
• 입력층의 노드수와 관계없이 노드수를 구성할 수 있다.
• Deep-Learing 알고리즘은 이런 은닉층이 2개 이상인 신경망을 의미한다.

  1-3. 출력층(Output Layer)

• 가장 마지막에 위치한 층이며 은닉층 연산을 마친 값이 출력되는 층이다.
• 다중 분류 문제에서는 활성화 함수로 Softmax를 주로 사용하고, 노드 수는 레이블의 Class 수가 된다.
• 이진 분류의 경우 sigmoid 함수를 활성화 함수로 사용하면 1개의 노드, Softmax를 사용하면 2개의 노드를 가지게 된다. 둘의 차이는 사실상 없기 때문에 굳이 노드의 수를 증가시키는 Softmax보다는 sigmoid함수를 사용한다.
• 회귀 문제는 일반적으로는 활성화 함수를 지정해주지 않으며 출력층의 노드 수는 출력값의 특성(Feature)수와 동일하게 설정한다.

  2. 가중치 행렬

  

신경망에서 실제로 학습되는 부분이다. 위 그림에서 화살표 하나마다 각각의 가중치가 주어진다. 입력층에 3개의 노드, 은닉층에 4개의 노드가 있기 때문에 12개의 가중치가 존재한다. 이 12개의 가중치가 연산되는 과정을 컴퓨터에서 잘 연산하기 위해서는 행렬의 형태로 만들어주어야 한다.

퍼셉트론에 있는 가중치-편향 연산은 행렬 곱으로 연산이 된다. 입력 벡터의 형태에 따라서 가중치 행렬의 Shape가 결정된다. 관습적으로 표기할 때는 가중치 행렬을 $W$, 입력 벡터를 $x$라 하고, 연산의 결과로 출력되는 벡터는 $y$라 하면 다음과 같이 나타낸다. $$$ y = Wx $$$ 하지만 실제 연산에서 위의 식을 그대로 이용하지는 않는다. 실제로는 아래의 그림과 같이 이루어진다.

model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=100),    # 은닉층
    tf.keras.layers.Dense(1, activation='sigmoid')                    # 출력층
])

위의 코드로 생성한 신경망의 경우 입력층의 노드수가 100개, 은닉층의 노드 개수가 10개이므로 두 층 사이에 생성되는 가중치 행렬의 Shape는 (100,10)이 된다. 은닉층과 출력층의 경우 출력층의 노드 개수가 1개 이므로 두 층 사이에 가중치 행렬의 Shape은 (10,1)이 된다.

3. MINIST 예제(손글씨 분류)

### 패키지 & 라이브러리
import pandas as pd
!pip install tensorflow-gpu==2.0.0-rc1
import tensorflow as tf

# 라이브러리 데이터셋을 불러온다. 
mnist = tf.keras.datasets.mnist

# Training Set, Test Set 분류. 
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Value normalization(정규화) 수행
# 픽셀값이 0~255사이의 값을 가지기 때문에 255로 나누어 준다.
# 이를 수행하지 않을 시 모델의 정확도가 매우 낮게 출력된다.
x_train, x_test = x_train / 255.0, x_test / 255.0

# 레이블의 구성 형태 확인
pd.unique(y_train)
------------------------------------------------------
-> array([5, 0, 4, 1, 9, 2, 3, 6, 7, 8], dtype=uint8)

# 신경망 모델 구축
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)), # 전체 원소 개수를 유지하면서 다차원 자료를 전결합층에 전달하기 위해 1차원 자료로 바꿔주는 Layer이다.

  tf.keras.layers.Dense(100, activation='relu'),
  tf.keras.layers.Dropout(0.2), # 과적합(Overfitting) 방지 역할
  tf.keras.layers.Dense(10, activation='softmax')
])

# 구축한 모델을 컴파일하며, 옵티마이저, loss function 등을 설정.
# 컴파일 : 모델을 학습시키기 위한 학습과정 설정 단계
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 모델이 학습 하는 부분
model.fit(x_train, y_train, epochs=5) # epoch의 수를 변화시키면 더 많이 학습하거나 적게 학습할 수 있다. 

# 만들어진 모델을 이용하여 예측하는 부분
model.evaluate(x_test,  y_test, verbose=2)

4. 신경망 종류 그림

2. 활성화 함수(Activation function)

딥러닝에서 사용하는 인공신경망들은 일반적으로 이전 레이어로부터 값을 입력받아 활성화 함수를 통과시킨 후 그 결과를 다음 레이어로 출력한다. 활성화 함수의 종류는 다음과 같다.

• 이진 활성화 함수 (Binary step activation function)

• 선형 활성화 함수(Linear activation function)
• 비선형 활성화 함수(Non-linear activation function)

3가지 종류가 존재하지만 일반적으로 비선형 활성화 함수를 사용한다. 은닉층에서 이진 활성화 함수를 활성화 함수로 사용하면, 다중 출력이 불가능하다는 문제가 발생하고, 은닉층에서 선형 활성화 함수를 활성화 함수로 사용할 경우, 역전파가 불가능하며 Layer를 깊게 쌓는 의미가 사라진다는 문제가 생기기 때문이다.

이런 비선형 활성화 함수는 다양한 종류가 존재하지만 크게 4가지를 다뤄보도록 하겠다.

1. Step function(계단 함수)

가장 간단한 활성화 함수로 임계값을 넘으면 1 그렇지 않으면 0을 출력하는 함수이다. 하지만 신경망에서는 역전파를 통해 매개변수들을 수정하며 학습하게 되고 이 과정에서 경사하강법이 사용되어 미분 과정이 필요하기 때문에 임계값에서 미분 불가능한 지점을 가지는 Step function은 적합하지 않다.

2. Sigmoid function(시그모이드 함수)

미분 불가능한 점을 가지는 Step function의 단점을 해결하기 위하여 사용되는 함수이다. 계단 함수처럼 임계값보다 작은 부분은 0에 가까워지고, 큰 부분은 1에 가까워진다. 그리고 임계값에서 부드럽게 연결되어 있기 때문에 모든 지점에서 미분 가능하며, 미분값도 0이 아니다.

하지만 Sigmoid를 중복하여 사용하면 Vanishing Gradient(기울기 소실)문제가 발생하게 된다.

❗️ Vanishing Gradient(기울기 소실) 딥러닝 분야에서 Layer를 많이 쌓을수록 데이터 표현력이 증가하기 때문에 학습이 잘 될 것 같지만, 실제로는 Layer가 많아질수록 학습이 잘 되지 않는다. 바로 기울기 소실현상 때문이다. 기울기 소실이란 역전파 과정에서 출력층에서 멀어질수록 Gradient값이 매우 작아지는 현상을 말한다.
그 원인은 활성화 함수(Activation function)의 기울기와 관련이 깊다. Sigmoid함수를 예로 들어보면 아래의 그림에서 볼 수 있듯이, sigmoid함수의 미분 값은 입력값이 0일 때 가장 크지만 0.25에 불과하고 $x$값이 크거나 작아짐에 따라 기울기는 거의 0에 수렴하는 것을 볼 수 있다. 따라서, 역전파 과정에서 미분값이 거듭 곱해지면 출력층과 멀어질수록 Gradient값이 매우 작아질 수밖에 없다.(이는 역전파 수식을 찾아보자.) 더불어 $e$는 컴퓨터가 계산할 때 정확한 값이 아닌 근사값으로 계산해야 되기 때문에 역전파 과정에서 점차 학습 오차까지 증가하게 된다. 결국 Sigmoid함수를 활용하면 모델 학습이 제대로 이루어지지 않게 된다. 이를 해결하기 위한 방법 중 하나로 tanh함수가 제안되었다.
출력값의 범위를 2배 늘렸지만, 여전히 가울기 소실 문제를 방지하는데 어려움이 있었고, 이를 또 해결하기 위해 ReLU 함수가 제안된다. 그리고 이 함수는 기울기 소실 문제를 잘 해결하였다고 평가받는다.

3. ReLU function(렐루 함수)

ReLU function는 신경망 발전에 큰 영향을 미친 활성화 함수이다. 시그모이드 함수를 중복하여 사용하게 되면 기울기 소실문제가 발생하게 되는데, 기울기 소실 문제를 해결하기 위해서 등장한 것이 ReLU이다.

ReLU function는 양의 값이 입력되면 그 값을 그대로 출력하고 음의 값이 입력되면 0을 반환한다. 식으로 나타내면 다음과 같다. $$$ f(x) = max(0,x) $$$ 함수의 특성상 층이 깊어지더라도 1의 값이 계속 곱해지기 때문에 기울기 값이 과도하게 커지거나 작아지는 문제가 발생하지 않게 된다.

ReLU함수의 등장 이전까지는 은닉층을 깊게 쌓을 수가 없었기 때문에 복잡한 문제를 푸는 데에 딥러닝을 사용할 수 없었다. 하지만 ReLU함수가 고안되고 사용되면서 딥러닝은 더욱 더 발전할 수 이었다.

4. Softmax function(소프트맥스 함수)

Softmax function는 다중 분류(Multi-classification)문제에 적용할 수 있도록 시그모이드 함수를 일반화한 활성화 함수이다. 가중값을 소프트맥스 함수에 통과시키면 모든 클래스의 값의 합이 1이 되는 확률값으로 변환된다.

3. 표현학습(Representation Learing)

기계 학습에서 특징 학습 또는 표현 학습(Representation)은 시스템이 원시 데이터에서 특징 탐지 또는 분류에 필요한 표현을 자동으로 검색할 수 있도록 하는 일련의 기술을 의미한다.

우리는 보통 어떤 Task를 해결하기 위해 Task와 관련된 정보들을 이용한다. 예를 들어, 나누기(=Task)를 하려고 하면 수(=numeric)라는 정보를 이용한다. 하지만 이러한 수라는 정보들은 다양하게 표현(=Representation)될 수 있다. 로마숫자표기, 아라비아숫자표기 등이 그 예시이다.

보통 Task들의 난이도는 정보들을 어떻게 표현해주느냐에 따라서 결정된다. 즉 정보들을 특정 Task에 맞게 잘 표현해주면 해당 Task를 풀 수 있는 확률이 높아지는 것이다.

결국 어떤 Task를 해결할 때, 정보를 어떻게 가공하여 표현해줄지에 따라서 Task의 난이도가 결정되는 것이다. 그렇다면 딥러닝 모델에서 representation이란 개념은 어떻게 이해해야 할까?

딥러닝에서는 최종 Task의 유형에 따라서 new representation에 해당하는 new feature를 출력하게 된다. 이러한 new representation을 뽑게 학습하는 것을 representation learing이라고 부른다.

사실 너무 방대한 양의 글이라 완벽히 이해는 못했다. 표현학습에 대해서는 나중에 다시 아래의 참고자료를 읽어보자.

4. Tensorflow 신경망 예제 - Iris데이터 분류하기

전체 특성 중 2개의 특성만 선택하여 사용하고, 150개의 데이터 중 Setosa 50개, Versicolor 50개만 추출하여 100개의 데이터에 대해서 이진분류를 진행한다.

# 필요한 패키지와 라이브러리를 불러온다.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# 시드(Seed)를 고정한다.
np.random.seed(42)
tf.random.set_seed(42)

# Iris 데이터셋을 Dataframe 형태로 불러온다.
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
# 데이터를 살펴보는 과정의 코드는 생략한다.

# Setosa, Versicolor 데이터만 추출하여 전처리 하여준다.
label = df.iloc[0:100, 4].values

# 타겟 레이블을 Setosa=0, Versicolor=1로 변경해준다.
label = np.where(label == 'Iris-setosa', 0, 1)

데이터가 어떤 분포를 가지고 있는지 시각화를 통해 알아볼 수 있다.

features = df.iloc[0:100, [0,2]].values
plt.scatter(features[:50, 0], features[:50, 1], color='red', marker='o', label='setosa')
plt.scatter(features[50:100, 0], features[50:100, 1], color='blue', marker='x', label='versicolor')
plt.xlabel('sepal length')
plt.ylabel('petal length')
plt.legend(loc='upper left')
plt.show()

Train dataset과 Test dataset으로 나누어준다.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(features, label, test_size=0.2, random_state=42)

다음으로는 신경망 모델을 구축하고 Complie한 후 학습한다. 이번 예제에서는 단층, 즉 은닉층이 없이 출력층으로만 모델을 구성해본다.

먼저 Sequential API를 사용하여 모델을 구축하여 보겠다.

model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(1, activation='sigmoid')
])

위의 코드를 다음과 같이 다른 방식으로도 나타낼 수 있다.

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))

Sequential API말고도 Keras에는 또 다른 방법인 Functional API도 존재한다. 사용법은 다음과 같다.

input = tf.keras.layers.Input(shape=(2,))
output = tf.keras.layers.Dense(1, activation='sigmoid')(input) # <- 새로 추가

model = tf.keras.models.Model(inputs=input, outputs=output)

함수형 API에서는 달라지는 점은 다음과 같다.

• Input()함수에 입력의 크기를 정의한다.

• 이전층을 다음층 함수의 입력으로 사용하고, 변수에 할당한다.
• Model()함수에 입력과 출력을 정의한다.

.compile에서는 신경망에서 사용할 optimizer, loss, metrics를 설정한다.

model.compile(optimizer='sgd',
              loss='binary_crossentropy',
              metrics=['accuracy'])

각 파라미터를 설정함에 있어서 주로 다음과 같이 설정한다.

💡 신경망 설계 - 이진분류

• 활성화 함수: Sigmoid function
• 출력층 노드 수: 1개 (0 또는 1로 라벨링)
• 손실함수: binary_crossentropy(이항 교차 엔트로피)

💡 신경망 설계 - 다중분류

• 활성화 함수: Softmax function
• 출력층 노드 수: Label의 Class 수
• 손실함수
  • categorical_crossentropy(범주형 교차 엔트로피, label이 One-Hot Encoding된 형태)
  • sparse_categorical_crossentropy(label이 정수 인코딩 된 형태, 즉, label이 class index를 값으로 가질 때 사용)

💡 신경망 설계 - 회귀

• 활성화 함수: 사용하지 않음
• 출력층 노드 수: 출력값의 특성(feature) 수
• 손실함수: MSE(Mean_Squared_error, MSE)

.fit은 실제로 신경망 학습이 진행되는 부분이다. epochs를 조정하면 학습 횟수를 조정할 수 있다.

model.fit(X_train, y_train, epochs=30)

# 학습한 신경망 모델을 사용하여 평가한다.
model.evaluate(X_test, y_test, verbose=2)

5. 회고

진짜 진짜 진짜 너무 오랜만에 TIL을 작성하는 것 같다. 아직 N331~N334까지는 작성도 못했는데 밀린 거 하는 것 보다는 일단 Section4 배운 내용을 정리해나가면서 남는 시간에 정리하려고 한다. 후 그래도 뭔가 DE에 대해서 배우다가 다시 인공지능 쪽으로 넘어오니까 뭔가 훨씬 재미있는 것 같다. 일단 진짜로 이번 섹션은 안밀리고 복습하는 것이 목표다.

❗️ 참고자료

1. 퍼셉트론
2. 퍼셉트론2
3. 신경망의 각 층
4. 활성화 함수
5. 기울기 소실
6. 표현학습

Level 1.

• 웹 애플리케이션과 웹 프레임워크에 대해 설명할 수 있다.
• Flask, JinJa, 라우팅, 블루프린터에 대해 설명할 수 있다.
• Flask 예제를 활용하여 간단한 웹 애플리케이션을 제작할 수 있다.
• Bootstrap을 통해 HTML을 꾸미는 예제 코드를 재현할 수 있다.
• IP주소에 대해 설명할 수 있다.

Level 2.

• 웹 애플리케이션을 제작하여 csv파일의 내용을 출력할 수 있다.
• JinJa템플릿을 활용하여 웹 애플리케이션의 사용자가 입력한 데이터를 활용할 수 있다.
• 웹 애플리케이션의 Endpoint마다 요구하는 기능을 구현할 수 있으며, HTTP 상태 코드를 전달할 수 있다.

Level 3.

• Application Factory를 기반으로 웹 애플리케이션을 제작할 수 있다.
• 제작한 웹 어플리케이션을 폴더와 라우팅에 따른 프레임워크 기반으로 설명할 수 있다.
• Flask 기반 웹 어플리케이션에 데이터베이스를 연결하고 데이터를 읽고 쓰는 API를 제작할 수 있다.

Level 4.

• Flask-SQLAlchemy를 활용하여 웹 애플리케이션과 데이터베이스를 연결하고 조작할 수 있다.
• Flask에서의 리다이렉트 및 사용자 세션처리에 대해 설명할 수 있다.
• 웹 3계층 시스템 아키텍처에 대해서 설명할 수 있다.

1. 주요개념

Flask

장고(Django)나 플라스크(Flask)에 대해서는 파이썬을 접하게 되면 한 번은 들어봤을 수도 있다. 이 두 개의 프레임워크는 파이썬을 사용해 웹 애플리케이션을 작성할 수 있도록 도와준다.

그 중에서 Flask에 대해서 배우게 될 것이다.

Flask는 마이크로 웹 프레임워크(Micro Web Framework)이다. 웹 프레임워크는 웹 애플리케이션을 개발할 수 있도록 웹 서비스(Web Service)나 웹 API(Web API)등을 제공하고 웹 개발과 배포를 할 수 있는 특정 방법을 제공한다. 즉, 뭔가를 만들어낼 수 있는 도구 모음을 제공한다고 보면 된다.

Flask는 웹 프레임워크이긴 하지만 마이크로가 앞에 붙는다.즉, 이러한 도구 모음들이 최소한의 크기로 줄여진 것이다. 예를 들어 일반적인 웹 프레임워크를 손톱깎이 세트로 비유하자면 손톱깎이를 비롯한 여러 가지가 들어 있는 것이다. Flask는 여기에서 정말 최소한의 도구들을 모아놓은 것이다.

기본적으로 프레임워크에 따라 패키지와 라이브러리 등 모듈들의 컬렉션이 있어 개발이 수월할 수 있도록 도와준다. Jinja, Werkzeug, Flask-SQLAlchemy 등 다양한 패키지들과 라이브러리들이 존재한다.

Flask 시작하기

1. Flask 시작 우선 파이썬 환경에 Flask를 먼저 설치해야 한다.

pip install flask

2. 폴더 생성하기 다음으로 Flask 애플리케이션을 저장할 폴더를 새로 만들어 준다. 이름은 통상적으로 애플리케이션 이름으로 지정해준다. 이번 예시에서는 flask_app을 사용하겠다. 그리고 폴더 안에 __init__.py이라는 파일을 하나 만들면 다음과 같은 구조가 된다.

flask_app
└── __init__.py

3. Flask 애플리케이션 생성하기 이번에는 __init__.py파일에 코드를 담아보겠다. 먼저 Flask를 사용해서 웹 애플리케이션을 만드는 방법은 다음과 같다.

# __init__.py
from flask import Flask

app = Flask(__name__)

코드를 보면 Flask(__name__)은 해당 애플리케이션의 이름을 지정해 주고 있다. 비록 아무 기능은 없지만 Flask 웹 애플리케이션을 생성한 것이다.

4. CLI로 실행하기 CLI 명령어로 실행할 때에는 프로젝트 폴더 상위 디렉토리에서 다음과 같이 실행해 주면 된다.

FLASK_APP = (폴더명) flask run

위에서는 프로젝트 폴더명을 flask_app으로 했기 때문에 폴더명 자리에 flask_app이 들어간다. 그러면 다음과 같은 화면이 나타난다.

여기서 제일 마지막에 적혀있는 문구를 살펴보겠다.

Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

실행한 웹 애플리케이션을 시작했는데 이 애플리케이션에 접속할 수 있는 주소를 알려주고 있다. 바로 http://127.0.0.1:5000/이다. 127.0.0.1은 localhost이고 5000번 포트에서 작동하고 있다는 뜻이다.

웹 브라우저를 키고 접속하면 애플리케이션에 접근할 수 있지만 아무 설정도 없기 때문에 404(Not Found)페이지가 보일 것이다.

어플리케이션을 종료하기 위해서는 Press CTRL+C to quit이 명령대로 해주면 된다. 만일 이 방법으로 종료하지 않으면 프로세스를 따로 찾아서 종료를 해줘야 한다. 터미널만 종료한다고 꺼지는 것이 아니다. 명심하자.

5. 라우트 추가하기 이제 애플리케이션에 접속하면 "Hello World!"가 나타나도록 코드를 수정해보겠다. 기존 파일에 다음과 같은 작업을 추가한다.

# __init__.py

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello World!'

이제 코드를 하나씩 뜯어서 살펴보자.

• @app.route('/') 애플리케이션의 루트 주소 ('/')에 접속했을 때에 실행하라는 뜻이다. URL에 따라 실행하게 될 함수를 지정하는 역할이다. 즉, 엔드 포인트(endpoint)를 설정하게 되는데, 이때 엔드 포인트란 주소가 어떻게 끝나는지를 말하고 있는 것이다.
  기본적으로 기본 URL 뒤에는 슬래시(/)가 붙어야 하기 때문에 만일 '/'없이 그저 @app.route('about')와 같은 설정을 하게 되면 Flask를 실행할 때에 에러를 일으킨다.

• def index() 루트 주소로 접속했을 때 실행되는 함수로 "Hello World!"라는 문자열을 반환한다.

이제 이 코드를 실행해보면 이전과 달리 index()함수가 실행되면서 "Hello World"라는 문구를 볼 수 있다.

❗️ 만약 동일한 라우트가 여러개라면? 라우트(Route) 자체는 경로, 서로 다른 네트워크 간 데이터를 전송하고 전송한 데이터를 받는 경로를 의미한다. 즉, 위의 @app.route('/')는 기본경로 URL + /라는 경로를 통해서 데이터를 전송하고 받는다는 것을 의미한다는 것이다.
그런데 만약 동일한 라우트가 여러 개가 있다면 Flask에서는 HTTP Request를 받고 처리할 때에 가장 먼저 엔드 포인트 조건이 맞는 라우트를 사용한다.

6. 라우트 기능들 Flask에서는 라우트를 다양하게 설정할 수 있다. 앞서 했던 것처럼 기본적으로 엔드 포인트를 지정할 때도 있지만 URL 내에서 변수를 받을 상황도 있을 수 있다. 그리고 시각적인 부분 없이 접속이 되는 라우트들도 있을 수 있다. 이러한 기능들을 여기에서 다 다루지는 않지만 몇 가지만 살펴보겠다.

• HTTP Request 메서드

기본적으로 Flask의 라우트 데코레이터를 사용하게 되면 3가지 HTTP Request메서드를 허용한다. 바로 GET, HEAD, OPTIONS이다. 하지만 이외에 POST, PUT, PATCH, DELETE등 다른 메서드들을 통과하다록 설정하기 위해서는 데코레이터 함수에 methods라는 인자를 추가하면 된다.

예를 들어 @app.route('/')에 POST메서드를 추가하려면 다음과 같이 할 수 있다.

@app.route('/',methods=['POST','GET'])
def index():
    ...

이제는 GET과 POST라는 메서드가 통과된다. 그리고 HEAD와 OPTIONS라는 메서드들은 이제 사용이 불가하다.

• 세부 엔드 포인트

URL을 보다 보면 슬래시(/)로 이어진 긴 엔드 포인트들이 있다. 예를 들어 유어클래스에서 코스 카드를 하나 선택하면 다음과 같은 URL이 하나 뜨게 된다.

https://urclass.codestates.com/course/37/curriculum

여기에서 course 뒤에 37이라는 숫자가 보이고 curriculum이라는 단어가 잇따라 온다. 이처럼 URL을 세부적으로 지정하고 주소에서 값을 전달할 수 있다.

index의 번호에 따라 해당 번호가 포함된 Welcome to Index {번호}를 리턴하도록 Flask애플리케이션에 index라우트를 만들어보겠다.

다음과 같이 라우트를 설정할 때 엔드포인트에 꺽쇠(<>)모양으로 어떠한 변수를 설정할 수 있다. 그리고 꺽쇠 안에는 변수의 이름을 지정해주고 함수에서는 변수를 그대로 받아 사용할 수 있다.

@app.route('/index/<num>')
def index_number(num):
    return 'Welcome to Index %i' % int(num)

한 번 살펴보자.

• < num > num이라는 이름의 변수를 만들어 받게 하도록 한다. 따라서 사용자가 입력하는 값과 상관없이 변수로 받게된다. 만약에 index/hello를 넘겨주면 hello가 값이 된다. 따라서 변수의 타입을 신경 써야 하기도 한다.

• int(num) 들어오는 변숫값의 타입을 변환해 준다. 그 이유는 기본적으로 URL을 통해 들어오게 되는 값은 문자열 타입이기 때문이다. 따라서 숫자로 표현하기 위해서는 변환해 주는 작업이 필요하다.

만약에 숫자를 넘겨주지 않으면 어떻게 될까요? 예를 들어 숫자가 안 주어지면 0을 기본으로 설정해 주는 방법은 다음과 같다.

@app.route('/index/', defaults={ 'num' : 0 })
@app.route('/index/<num>')
def index_number(num):
    return 'Welcome to Index %i' % int(num)

• 블루프린트 사용하기

기능이 많아질수록 라우트도 많아진다. 그렇기 때문에 이러한 라우트들을 하나의 파일로 모아서 사용하지 않고 기능별로 나눠서 블루프린트 기능을 사용한다. 블루프린트는 Flask에서 여러 개의 라우트를 한 곳에 묶어둘 수 있는 기능이 있다.

사용하는 방법은 다음과 같다.

그리고 routes라는 폴더를 만들어 그 안에 user_routes.py라는 파이썬 파일을 생성한다. 이제 프로젝트 구조는 다음과 같다.

flask_app
├── __init__.py
└── routes
    └── user_routes.py

그리고 user_routes.py파일에는 다음과 같이 코드를 작성한다.

# user_routes.py

from flask import Blueprint

bp = Blueprint('user', __name__, url_prefix='/user')

@bp.route('/')
def index():
    return 'User index page'

위에서 Blueprint의 인수로 들어가는 것은 다음과 같다.

• user:블루프린터의 이름
• __ name__:블루프린트의 import이름
• url_prefix='/user': URL 접두어 설정(해당 블루프린트의 라우트는 URL 앞에 /uesr가 자동으로 붙게 된다.)

그리고 __init__.py파일에서 해당 파일을 불러와서 사용할 수 있다.

# __init__.py

from flask import Flask
from flask_app.routes import user_routes

app = Flask(__name__)
app.register_blueprint(user_routes.bp)

@app.route('/')
def index():
    return 'Hello World!'

이제 위 코드를 실행하여 http://127.0.0.1:5000/user/로 접속하면 다음과 같은 문구가 보이게 된다.

Application Factory

Flask를 통해서 애플리케이션을 만드는 방법을 살펴봤다. 하지만 추후에 프로젝트가 커지고 파일들이 많아지면 import를 사용할 일이 많아진다. 이때 파이썬에서 circular import(순환참조)를 피하기 위해서 Flask에서는 애플리케이션 팩토리 패턴을 추천하고 있다.

말 그대로 애플리케이션을 만드는 "공장"을 세우는 것이다. 여태까지는 글로벌한 컨텍스트에서 app을 선언하고 사용했다. 하지만 이렇게 되면 여러 개의 애플리케이션을 동시에 사용하거나 app이 선언되어 있는 파일의 일부분만 필요할 때에도 문제가 발생할 수 있다.

이러한 잠재적인 문제점들을 피하기 위해 사용되는 방법이 함수를 따로 만드는 것이다. 기본적인 패턴은 다음과 같다.

__init__.py파일에서 다음과 같은 코드가 들어가게 된다.

from flask import Flask

def create_app():
    app = Flask(__name__)

    from yourapplication.views.admin import admin
    from yourapplication.views.frontend import frontend
    app.register_blueprint(admin)
    app.register_blueprint(frontend)

    return app

if __name__ == "__main__":
  app = create_app()
  app.run()

보시는 것처럼 함수 안에 애플리케이션을 생성해 준다면 해당 함수를 실행하기만 하면 원하는 애플리케이션이 하나 만들어진다. 이제는 다른 파일에서 import를 해도 문제가 될 일도 줄어든다.

블루프린트도 함수 내에서 import를 해온 뒤에 애플리케이션에 추가해 준다.

앞으로 작성하는 Flask 애플리케이션은 이 패턴으로 작성하면 좋다.

Level 1.

• Docker가 필요한 이유를 설명할 수 있다.
• Docker image에 대해 설명할 수 있으며, Whalesay예제를 재현할 수 있다.
• Docker Container에 파일을 복사하는 예제를 재현할 수 있다.
• Docker Hub, Docker container, Docker Image 사이의 관계를 알고 설명할 수 있다.

  Level 2.

• Docker Container가 Linux Container기술에서 시작했다는 것을 알고, LXC의 세 종류의 구획화에 대해 설명할 수 있다.
• Docker Image 이름과 Docker Container 실행 명령어의 구성을 각각 설명할 수 있으며 Docker Container를 실행할 수 있다.
• Docker Container의 터미널을 활용하여 Container 내의 폴더 구조를 파악할 수 있으며, 로컬 환경과 파일을 주고 받을 수 있다.
• 포트에 대해서 설명할 수 있으며, Container에서 로컬로 포트 포워딩을 할 수 있다.

  Level 3.

• Docker Docs에서 필요한 명령어와 옵션을 찾아서 실행할 수 있다.
• Yaml문법을 이해하고, Docker-Compose를 활용하여 여러 개의 Container를 다룰 수 있다.

  Level 4.

• Dockerfile 에 사용되는 문법을 이해하고, 원하는 Docker Image 를 제작 후 배포할 수 있다.
• Docker network 를 활용하여 여려 개의 Container 를 연결하고 활용할 수 있다.
• Docker 와 Linux Container 사이의 관계를 설명할 수 있다.
• Kubernetes 와 컨테이너 표준 사이의 관계를 설명할 수 있다.
• 가상 머신에 대해서 이해하고, Docker 와 가상 머신을 비교하여 설명할 수 있다.

  1. 주요개념

  Docker(도커)?

  “Docker takes away repetitive, mundane configuration tasks and is used throughout the development lifecycle for fast, easy and portable application development.”

일반적으로 Server(서버)를 관리한다는 것은 복잡하고 어려우며 고급 개발자들의 섬세한 작업이 필요한 영역이다.

개발을 하면서 시간이 흐르다보면 서버 환경이 계속 바뀐다. CentOS에 익숙해지면 Ubuntu를 써야할 일이 생긴다거나 하는 일이 생긴다.(둘 다 Linux운영체제의 여러 버전) 게다가 최근 DevOps의 등장으로 개발주기가 짧아지면서 배포는 더 자주 이루어지고 마이크로 서비스 아키텍쳐가 유행하면서 프로그램은 더 잘게 쪼개어져 관리는 더 복잡해진다.

그리고 리소스 격리성에 대해서 이해하기 위해 IP와 Port Number에 대해 잠깐 이야기 해보겠다. IP주소는 인터넷상에 있는 컴퓨터의 고유 주소로, 인터넷상의 한 컴퓨터에서 다른 컴퓨터로 데이터를 주고받을 수 있게 해준다. Port number는 IP주소와 함께 쓰여 해당하는 프로토콜에 의해 사용된다. 비유하자면, 우리가 물건을 어떤 사람의 방까지 전달해준다고 하자. IP 주소는 단지 집 주소까지, Port Number는 방 주소까지라고 생각하면 된다. 이제 본격적으로 서버 관리자들에게 다음과 같은 요구가 들어온다고 가정해보자.

• 웹서버 1은 IP는 A로 하고 포트 번호는 A-1로 하고, 방화벽 규칙은 a의 규칙을 이용하라.

• 웹서버 2는 IP는 B로 하고 포트 번호는 B-1로 하고, 방화벽 규칙은 b의 규칙을 이용하라.

이런 두가지 요구에 대해서 서버가 하나빡에 없어서 IP주소를 구분하기 위해 브릿지 설정(뭔지 모르겠다...)을 변경해야 하고, 방화벽 규칙 a와 b가 서로 충돌이 일어날 것이다.

이러한 문제를 해결하고자, 하나의 컴퓨터에서 여러 개의 컴퓨터를 이용하는 것처럼 하기 위해서 "리소스 격리성"을 이용한다. 그리고 이런 리소스 격리성을 제공하는 기술로 VM( virtual machine)과 바로 이번에 배우는 Docker가 있다. 두 방법 모두 격리성을 제공하기 때문에 각 애플리케이션마다 다른 컴퓨터에서 실행되는 것처럼 IP, Port 등을 다르게 설정할 수 있다.

👉 Docker(좌측), Virtual Machine(우측)

• 도커는 Virtual Machine만큼 견고한 격리성을 제공하지 않는다.
• 도커는 리눅스의 컨테이너를 이용한 기술로, OS 위에 다른 OS를 실행하는 것이 아니기 때문에 Virtual Machine보다 좋은 성능을 낼 수 없다.

👉 Virtual Machine(가상머신)이란? Docker가 등장하기 전, 프로그래머들은 OS(Operation System)를 가상화하여 사용하는 방식을 사용했다. 구체적인 예를 들어 OS의 가상화가 무엇인지 설명해보겠다.
A는 지금까지 Windows가 설치 된 개노트북에서 개발을 해 왔다. 그런데 A는 이번에 눈여겨보고 있던 최신 애플 노트북을 새로 사게 되었다. 지금까지 Windows에 사용한 프로그램들을 다시 MAC컴퓨터에서 다시 설치하려고 한다.
여기서 문제가 발생한다. Windows에서 설치한 프로그램들이 IOS와 호환되지 않는 것들이 매우 많다는 것이다. 이미 설정해둔 설정값이나 자료들 역시 새로운 노트북에서 다시 설정하기 매우 힘이 드는 작업이다.
이러한 문제를 해결하기 위해 새로 구매한 Mac컴퓨터 안에 원래 사용하고 있던 Windows환경을 설치하기로 했다. 이것이 바로 OS의 가상화이다.

위 그림은 또 다른 OS를 설치하는 과정을 그림으로 나타낸 것이다.

• Window내에서 VMware를 설치한다.
• VMware를 사용하여 hypervisor를 설치한다.
• hypervisor를 통해 Guest OS로 접근한다.
• Guset OS 안에서 개발을 진행한다.
  우리는 원래 사용하는 OS를 Host OS,즉 주인 운영체제라고 부른다. 그리고 설치한 새로운 OS를 Guest OS, 즉 손님 운영체제라고 부른다. 컴푸터를 2대를 따로 사는 것 대신에, 하나의 하드웨어에서 2개의 운영체제를 가지고 있는 것이다.
  짧게 정리하자면, 하나의 하드웨어 안에서 또 다른 OS를 만드는 것을 Virtual Machine(가상머신)이라고 한다.
  이런 가상머신은 하나의 하드웨어에서 두 가지의 OS를 사용할 수 있다는 장점 덕분에 많은 인기를 누렸다. 하지만 단점도 존재했다. 가상머신은 하나의 하드웨어가 또 다른 OS를 유지하기 위해서 엄청나게 많은 자원(Resource)이 사용된다. 또, 하드웨어를 나눠써야 하는 점 때문에 효율성이 떨어지고 실행 속도도 느리다는 단점이 있다.

👉 Docker의 장점

• 인프라를 편하게 가져올 수 있다. 인프라를 이미지로 만들었기 때문에 저장된 이미지들만 관리한다. 중앙 보관소에 있는 이미지를 가져와서 체계적인 관리와 테스트를 할 수 있다.
• 용량이 가볍고 빠르다. OS와 컨테이너 환경을 분리하여 가볍고 어디서든 실행 가능하게 만들어 준다.
• 쉽게 삭제하고 복수할 수 있다. 이미지를 사용하여 개발환경을 동시에 여러개 만들 수 있고 수정/배포가 간단하므로 테스트가 매우 쉽다.

Docker를 짧게 정의하자면, 애플리케이션 실행 환경을 코드로 작성할 수 있고 OS를 격리화하여 관리하는 기술,또는 그런 기술을 제공하는 컨테이너 기반의 오픈소스 가상화 플랫폼을 의미한다. 그리고 이 Docker는 Linux Container라는 기술에서 시작되었다.

따라서 이번 섹션에서는 Docker의 사용방법을 상세히 다루기 이전에 Linux Container기술에 대해서 학습한 후, Docker의 사용 방법등에 대해서 다룬다.

Linux Container

리눅스 기반의 기술 중에 하나로 필요한 라이브러리와 어플리케이션을 모아서 마치 별도의 서버처럼 구성한 것을 말한다. 컨테이너를 이루는 네트워크 설정, 환경 변수 등의 시스템 자원은 각 컨테이너가 독립적으로 소유하고 있다.

1. 프로세스의 구획화

• 특정 컨테이너에서 작동하는 프로세스는 기본적으로 그 컨테이너 안에서만 액세스 할 수 있다.
• 컨테이너 안에서 실행되는 프로세스는 다른 컨테이너의 프로세스에게 영향을 줄 수 없다.

  2. 네트워크의 구획화

• 기본으로 컨테이너 하나에 IP주소가 할당되어 있다.

  3. 파일시스템의 구획화

• 컨테이너 안에서 사용되는 파일 시스템은 구획화되어 있다. 그렇기 때문에 해당 컨테이너에서의 명령이나 파일 등의 액세스를 제한할 수 있다.

가상머신과 얼핏보면 동일해 보이지만 비슷할 뿐 가상머신(가상화)와는 다른 기술이다.

• Container아키텍쳐

• VM아키텍쳐

• 두 개의 차이 정리

조금 더 상세히 설명하자면 기존 가상화 방식은 주로 OS를 가상화 했다. 위의 예시에서 등장한 VMware같은 VM은 호스트 OS위에 게스트 OS 전체를 가상화하여 사용하는 방식이다. 이 방식은 비교적 사용법이 간단하지만 무겁고 느려서 운영환경에선 사용할 수 없다.(Docker 컨테이너는 보통 MB단위 크기지만, VM은 GB크기를 가진다고 한다.) 이런 상황을 개선하기 위해서 반가상화 방식의 Xen이 등장한다.

하지만 전가상화든 반가상화든 추가적인 OS를 설치하여 가상화하는 방법은 어쨋든 성능 문제가 있었고 이를 개선하기 위해 프로세스를 격리하는 방식이 등장한다. 그리고 이런 프로세스를 격리하는 방식을 리눅스에서 리눅스 컨테이너라고 한다. 단순히 프로세스를 격리시키기 때문에 가볍고 빠르게 동작하게 되는 것이다. CPU나 메모리는 딱 프로세스가 필요한 만큼만 추가로 사용하고 성능적으로도 거의 손실이 없다.

Docker Container

리눅스 컨테이너는 리눅스에서 프로세스를 격리하는 방식이라고 했다. Docker Conatainer는 Docker에서 이런 프로세스를 격리하는 방식이다.

도커는 Container라는 물체를 운반한다. 컨테이너는 인프라를 비롯한 프로그램을 어떤 환경에서나 실행 가능 할 수 있도록 해주는 개체를 의미한다.

프로그램을 만들기 위해서는 다양한 인프로가 필요한데, 도커는 이 인프라들을 각각의 장소에서 하나씩 가져오는 것이 아니라, Container라는 보관함에 담아서 한 장소에서 가져오는 것이다.

예를 들자면 쿠팡이나 지마켓과 같은 쇼핑몰 웹사이트를 만들기 위해서는 FE,BE, DB 등과 같은 구성요소들이 필요하다. 이때, 구성요소들을 모두 Docker Container형태로 가져오면, 각기 다른 장소에서 설치하는 시간을 줄일 수 있다.

Docker 사용하기

도커를 이용하는 데 있어서 명령어, 옵션 등 사용법은 Docker Docs에서 확인할 수 있다. Docker CLI뿐만 아니라 사용법과 환경을 구성하는 방법에 대해서 설명되어 있다.

Docker Image

본격적으로 도커를 사용하기 앞서 Docker Image라는 개념을 이해해야 한다. Image는 컨테이너와 함께 도커를 사용하는데 있어서 가장 중요한 개념이다.

이미지는 컨테이너 실행에 필요한 파일과 설정값 등을 포함하고 있는 것으로 상태 값을 가지지 않고 변하지 않는다.(Immutable). 컨테이너는 이미지를 실행한 상태라고 볼 수 있고 추가되거나 변하는 값은 컨테이너에 저장된다. 같은 이미지에서 여러개의 컨테이너를 생성할 수 있고 컨테이너의 상태가 바뀌거나 컨테이너가 삭제되더라도 이미지는 변하지 않고 그대로 남아있다.

말 그대로 이미지는 컨테이너를 실행하기 위한 모든 정보를 가지고 있기 때문에 더 이상 의존성 파일을 컴파일 하고 이것저것 설치할 필요가 없다. 이제 새로운 서버가 추가되면 미리 만들어 둔 이미지를 다운받고 컨테이너를 생성만 하면 된다. 한 서버에 여러 개의 컨테이너를 실행할 수 있고, 수십, 수백, 수천 대의 서버도 문제없다.

도커 이미지는 Docker Hub에 등록하거나 Docker Registry 저장소를 직접 만들어 관리할 수 있다.

Docker Image 예제

docker/whalesay라는 이미지를 통해 예제를 실습해보겠다.

Docker Image의 이름은 레지스트리 계정, 레포지토리 이름, 태그 세 가지 정보로 구성되어 있다.

• 레지스트리(Registry)

  • 도커 이미지가 관리되는 공간을 의미한다.
  • 특별히 다른 것을 지정하지 않는다면 도커 허브(Docker Hub)를 기본 레지스트리로 설정한다.
  • 레지스트리는 Docker Hub, Private Docker Hub, 회사 내부용 레지스트리 등으로 나뉠 수 있다.

• 레포지토리(Repository)

  • 레지스트리 내에 도커 이미지가 저장되는 공간이다.
  • 이미지 이름이 사용되기도 한다.
  • Github의 레포지토리와 비슷한 개념이다.

• 태크(Tag)

  • 같은 이미지라고 할지라도 버전 별로 안의 내용이 조금 다를 수 있다.
  • 해당 이미지를 설명하는 버전 정보를 주로 입력한다.
  • 특별히 다른 것을 지정하지 않는다면 latest태그를 붙인 이미지를 가져온다.

자 그럼 다시 docker/whalesay라는 문장을 다시 읽어보면 다음과 같은 뜻을 가진 것을 알 수 있다.

👉 Docker Hub라는 레지스트리에서 docker라는 계정이 등록한 whalesay레포지토리에서 lastest태크를 가진 이미지

👆 실제 docker/whalesay

이제 실제 이미지를 가져와서 실행까지 진행해보자.

먼저 다음 명령어를 통해서 레지스트리에서 이미지 혹은 레포지토리를 가져온다. 이 과정을 Pull이라고 한다.

$ docker image pull docker/whalesay:latest

※ docker image pull만 아니라 docker pull을 사용하여 검색해도 많은 정보를 찾을 수 있다고 한다.

다음 명령어로는 이미지 리스트를 출력해 볼 수 있다.

$ docker image ls

받아온 이미지를 실행시켜 보자.(이미지 -> 컨테이너)

$ docker container run --name myName docker/whalesay:latest cowsay boo

각각의 명령에 대해서 간단히 정리하면 다음과 같다.

• {container} run
  • 컨테이너를 실행한다.

• option:
  • --name: 컨테이너의 이름을 할당한다.
• COMMAND:
  • cowsay: 컨테이너에서 cowsay를 호출한다.
• ARG..:
  • boo: COMMAND인 cowsay에 넘겨질 파라미터이다.

다음 명령어를 이용하면 종료된 컨테이너를 포함하여 모든 컨테이너를 볼 수 있다.

$ docker container ps -a

• {container} ps: 컨테이너의 리스트를 출력한다.
• -a: Default로는 실행되는 컨테이너지만 종료된 컨테이너를 포함하여 모든 컨테이너를 출력한다.

그리고 만일 컨테이너를 삭제하고 싶다면 다음과 같은 명령어로 삭제할 수 있다.

$ docker container rm myName

• {container} rm: 컨테이너를 지칭해서 삭제한다. 컨테이너를 명시할 때는 ps명령을 통해 확인할 수 있는 NAMES 혹은 CONTAINER ID를 사용한다.

이미지는 다음과 같이 지우면 된다.

$ docker image rm docker/whalesay

위와 같이 각 과정을 따로 진행할 수 있지만 이미지를 받아오고, 컨테이너로 실행하고, 컨테이너와 관련된 리소스를 지우는 작업을 한 번에 실행할 수도 있다.

$ docker container run --name my_name --rm docker/whalesay cowsay boo

• {container} run: 컨테이너를 실행한다. 이미지가 없다면 이미지를 받아온 뒤(pull) 실행한다.
• --rm: 컨테이너를 일회성으로 실행한다. 컨테이너가 종료될 때 컨테이너와 관련된 리소스를 모두 제거한다. 이미지까지 완벽하게 제거하려면

  $ docker image rm docker/whalesay

  까지 실행하면 된다.

도커는 같은 기능을 수행하더라도 여러 명령으로 실행될 수 있다. 아직 docker 측에서 특정 구문만 이용하라는 말이 없다. 그래서 웹서핑을 하면서 같은 기능을 하더라도 다른 docker 구문으로 구성되어 있는 경우를 잘 파악할 수 있어야 한다.

하나의 예시로 image rm과 rmi는 같은 기능을 수행한다.

❗ 참고자료

1. 초보자를 위한 도커 안내서
2. 코드스테이츠 N331 Lecture Note

• NoSQL 단어 유래에 대해 이해하고 설명할 수 있다.
• NoSQL 종류를 이해하고 구분할 수 있다.
• NoSQL 종류벼 특징에 대해 설명할 수 있다.
• 문서형(Document)데이터베이스를 활용할 수 있다.

  1. 주요개념

  1. NoSQL(Not Only SQL)

  NoSQL은 Not Only SQL의 약어로 조핸 오스카슨(Johan Oskarsson)이 2009년 6월 샌프란시스코에서 조직한 모임에서 관계형 데이터 모델을 쓰지않는 연구를 빠른 시간에 다양한 사람들과 논의하기 위해서 트위터의 해시태그에 사용할 중복되지 않으면서도, 부정적이여서 사람들의 끌 수 있는 단어를 생각하다 NoSQL을 찾았고, 이를 해시태그로 사용하여 현재 비관계형 데이터베이스 기술을 아우르는 말이 되었다.

2000년대 초 웹 시장의 발전과 함께 데이터 소스와 데이터의 양이 폭발적으로 증가하기 시작했다. 이런 웹 서비스의 데이터는 XML, JSON으로 처리되는데 관계형 데이터베이스로 처리하기에는 데이터 설계시간이 오래걸리기 시작했다. 그리고 하나의 서버를 크게 만드는 것(수직확장)보다, 여러개의 서버를 연결(수평확장)시켜 확장하는 방법이 더 비용적으로 우수하게 되었다. 따라서 한 대에서 실행되도록 설계된 관계형 데이터베이스보다는 여러 대의 컴퓨터에 분산하여 저장할 수 있고, XML, JSON 등의 데이터를 처리하는데 시간이 짧은 NoSQL이 등장하게 된다.

관계형 DB와 비관계형 DB는 만들어진 방식, 저장하는 정보의 종류, 그리고 저장하는 방법 등에 차이가 있다. 관계형 DB는 테이블을 사전에 정의를 한 뒤에 그에 알맞은 형태의 데이터만 넣을 수 있다. 각각의 행은 하나의 속성에 대한 정보를 저장하고, 열에는 각각의 데이터 형식에 맞는 데이터가 저장된다. 특정한 형식을 지키기 때문에 데이터가 제대로 추가되었다면 꺼낼 때에는 수월하다. SQL을 활용해 원하는 정보를 쿼리할 수 있다. 즉, 관계형 DB에서는 스키마가 뚜렷이 보인다. 덕분에 테이블 간에 관계들이 어떻게 되는지 알 수 있다.

그렇다고 NoSQL이 스키마가 반드시 없는 것은 아니다. 관계형 DB가 데이터를 쓸 때 스키마에 맞춘다면, 반면에 비관계형 DB(NoSQL)은 데이터를 읽어올 때 스키마에 따라 읽어온다. 읽어올 때만 데이터 스키마가 사용되기 때문에 쓸 때는 따로 정해진 것이 없다는 의미는 아니다. 결국 어떻게 쓰냐가 어떻게 읽어와야 하는지에 대한 영향을 미친다.

NoSQL 기반 DB data type - Key-Value type: 데이터를 key-value의 쌍을 속성으로 하는 배열의 형태로 저장한다. Redis, Dynamo 등이 대표적인 Key-value형식의 DB이다.
- 문서형(Document) DB: 데이터를 테이블이 아닌 문서처럼 저장하는 DB를 의미한다. JSON유사 형식으로 데이터를 문서화하는 것이 일반적이다. 각각의 문서는 하나의 속성에 대한 데이터를 가지고 있고, 컬렉션이라고 하는 그룹으로 묶어서 관리한다. 대표적인 문서형 DB에는 MongoDB가 있다.
- Wide-Column DB: DB의 열(Column)에 대한 데이터 관리를 집중하는 DB이다. 각 열에는 Key-value형식으로 데이터가 저장되고, 컬럼 패밀리(Column families)라고 하는 열의 집합체 단위로 데이터를 처리할 수 있다. 하나의 행에 많은 열을 포함할 수 있어서 높은 유연성을 자랑한다. 데이터 처리에 필요한 열을 유연하게 선택할 수 있다는 점에서 규모가 큰 데이터 분석에 주로 사용되는 DB형식이다. 대표적인 DB는 Cassandra, HBase가 있다.

SQL기반의 관계형 DB는 DB의 ACID성질을 준수해야하는 경우, 소프트웨어에 사용되는 데이터가 구조적이고 일관적인 경우에 사용하면 좋다. ACID성질을 준수하면 DB의 무결성을 보호할 수 있다. 전자 상거래, 금융 서비스를 위한 소프트웨어 개발에서는 이 성질을 준수하는 것이 필수 옵션으로 되어 있어 SQL을 이용한 솬계형 DB를 이용하는 것이 보편적이다. 또한 프로젝트의 규모가 많은 서버를 필요로 하지 않고 일관된 데이터를 사용하는 경우, 보통 관계형 DB를 사용한다. 다양한 데이터 유형과 높은 트래픽을 지원하도록 설계된 NoSQL DB를 굳이 사용할 이유가 없다.

NoSQL기반의 DB는 데이터의 구조가 거의 또는 전혀 없는 대용량의 데이터를 저장하거나, 클라우드 컴퓨팅 및 저장공간을 최대한 활용하는 경우, 빠르게 서비스를 구축하고 데이터 구조를 자주 업데이트 하는 경우에 사용하면 좋다. 대부분의 NoSQL DB는 저장할 수 있는 데이터 유형에 제한을 설정하지 않는다. 필요에 따라서 데이터의 새 유형을 추가할 수 있다. 그렇기 때문에 소프트웨어 개발에 정형화 되지 않은 많은 양의 데이터가 필요한 경우, NoSQL을 적용하는 것이 효율적일 수 있다. 그리고 클라우드 기반으로 DB저장소를 구축하면 저렴한 비용의 솔루션을 제공 받을 수 있다. 소프트웨어에 데이터베이스의 확장성이 중요하다면 여러 데이터 센터에 걸쳐서 많은 번거로움 없이 확장할 수 있는 NoSQL DB를 사용하는 것이 좋다. 또한 스키마를 미리 준비할 필요가 없기 때문에 빠르게 개발하는 과정에 매우 유용하다. 또한 소프트웨어 버전별로 많은 다운타임없이 데이터 구조를 자주 업데이트 해야하는 경우, 일일이 스키마를 수정해주어야 하는 관계형 DB보다는 NoSQL 기반의 비관계형 DB를 사용하면 더 좋다.

2. MongoDB

MongoDB는 문서형 데이터베이스를 사용하는 NoSQL 기반의 비관계형 데이터베이스이다.

문서들은 BSON(Binary JSON)형태로 저장되고 정해진 틀이나 데이터 타입이 없다. 따라서 자유롭게 문자, 숫자, 객체, 배열 등을 저장할 수 있다.

SQL과 비교하자면 자유롭게, 즉, 사전에 정의된 테이블 필드나 관계에 맞춰 할 필요없이 데이터를 추가할 수도 있다. 그렇기 때문에 보통은 일관되지 않은 데이터들을 추가해야하거나 혹은 재빠르게 데이터를 쌓아야 할 때 사용되기도 한다. SQL에 비해 비교적 자유롭지만 스키마가 아예 없는 것은 아니다. 각 문서를 저장할 때에는 자유롭게 저장해도 되지만 자유롭게 저장하는 만큼 읽어올 때에 일종의 스키마가 있어야 수월하게 가져올 수 있다. SQL에서는 각 테이블을 생성할 때에, 그리고 각 테이블의 관계들을 사전에 정의할 때에 스키마를 정했지만 NoSQL에서는 데이터를 읽을 때에 특정 스키마에 따라 데이터를 불러와야 하기도 한다.

MongoDB에서는 MongoDB Atlas라는 클라우드 데이터베이스 서비스로 인터넷을 이용해 어디서든 접속 가능한 서비스를 제공한다. 상세한 설정 방법은 [링크]를 참고하자.

3. Pymongo

Python에서는 MongoDB를 사용하기 위해서 pymongo라이브러리를 사용한다. Database 커넥터이기 때문에 MongoDB연결과 해제, 데이터 입출력과 조작, 결과 반환 등의 기능을 제공한다.

pymonogo 설치

pip install pymongo

MongoDB 연결하기

from pymongo import MongoClient
client = MongoClient({URI})

URI의 형식은 다음과 같으며 이는 절대적인 것이 아닌 Atlas의 경우이다. 실제 구체적인 URI는 다음 링크를 참고하자.

💡 [URI]

mongodb+srv://{USER}:{PASSWORD}@{HOST}/{DATABASE_NAME}?retryWrites=true&w=majority

작업흐름

Pymongo의 작업 흐름은 SQL을 이용했던 흐름과 다르다. 이전에는 connection과 cursor를 통해서 연결을 맺고 쿼리를 실행했다면 이번에는 연결하는 것은 마찬가지로 connection으로 하지만 그 후에는 database를 선택하고 documents와 상호작용하는 방식은 다르다.

client = MongoClient({URI})        # 연결
database = client[DATABASE_NAME]   # DB 선택 or 생성
collection = database[COLLECTION_NAME]    #collection 조작

콜렉션을 생성한 뒤에는 문서를 해당 콜렉션에 삽입할 수 있다.

이전에 진행했던 SQL쿼리문들과 달리 여기에서는 추가하는 것이 매우 쉽다. 특히 테이블에 대한 사전 정의나 구조가 없기 때문에 JSON형태를 바로 저장할 수 있다.

collection.insert_one({document}) # insert_one: 문서 하나 추가

더 많은 명령어와 사용법은 공식문서를 참고하자.

💡 [pymongo 공식문서]

2. 회고

드디어 Sprint2의 정리를 끝냈다. 이번 단원에서는 다양한 프로그램을 사용해보는 거라 명령어 자체가 많이 없는게 좋다. 그리고 강의노트를 짧게 정리하면서 정말 내가 필요한 것만 찾아서 정리해야겠다고 다시금 다짐했다. 정리는 정말 복습하면서 정리한다는 느낌으로...짧게 가져가고 내가 하고싶은거 공부 해야겠다. 이제 곧 새해인데 일단 버텨... [링크]:https://junho85.pe.kr/1979 [URI]:https://ko.wikipedia.org/wiki/%ED%86%B5%ED%95%A9_%EC%9E%90%EC%9B%90_%EC%8B%9D%EB%B3%84%EC%9E%90 [pymongo 공식문서]:https://pymongo.readthedocs.io/en/4.1.1/index.html

• API를 이해하고 사용할 수 있어야한다.
• RESTful API에 대해서 설명할 수 있어야한다.
• API의 데이터를 받아와 데이터베이스에 저장할 수 있어야한다.

1. 주요개념

1. API

[N314]에서 API가 무엇인지 간단히 다루었다. 이번에는 조금 더 상세하게 다루어 보고자 한다.

API란 "Application ProgrammingInterface"의 줄임말로 정의 및 프로토콜 집합을 사용하여 두 소프트웨어 구성요소가 서로 통신할 수 있게 하는 메커니즘이라고 앞서 정리하였었다. 이 API를 더 이해하기 위해서는 클라이언트와 서버도 같이 이해해야 어떤 방식으로 작동하는지 이해할 수 있다.

위의 사진을 통해서 API의 예시를 들어보면, 음식점에서 손님은 뭔가를 요청하고 있는 클라이언트이고 메뉴는 API이다. 손님은 주방에 들어가서 조리되는 음식을 보고 메뉴를 정하지 않는다. 또한 메뉴판에 없는 음식을 주문할 수도 없다. 메뉴판을 보고 음식을 고를 수 있는 이유는 메뉴판을 통해 어떤 음식이 나올지 어느 정도 예상하고 있기 때문이다. 그렇기 때문에 메뉴판은 손님과 주방 사이의 규칙으로 볼 수도 있다. 만약에 피자를 시켰는데 햄버거가 나온다면 메뉴판은 제 역할을 수행하지 못한 것이고, 손님 입장에서는 원했던 음식이 나오지 않게 되는 것이다.

여기서 중요한 점은 메뉴판(=API)은 단지 문서일 뿐이라는 것이다. 따라서 구체적인 실체가 존재하지 않는다. 하지만 몇몇 문서와 업체에서는 API를 어떤 특정한 서비스나 기능처럼 설명하기도 한다.

여기서 메뉴판의 주문을 주방장이 직접 받아서 요리까지 한다면 효율이 떨어질 것이다. 그래서 주문을 대신 받아 전달해주는 웨이터를 가게에 고용했다고 생각해보자 바로 이 웨이터가 API Server이다. 웨이터가 음식 주문을 받고, 조리된 음식을 전달하듯이 API server도 Service Server의 결과를 전달해준다. 즉 클라이언트와 Service server가 조금 더 원할하게 소통할 수 있게 도와준다.

그리고 주방장에 해당하는 Service server는 실제로 클라이언트의 요청에 대한 task를 처리하는 server이다.

API를 통해서 원하는 요리, 즉 데이터를 받으면 대체로 JSON형식 반환받는다. 대체로 그렇다는 것이지 API를 통한 서버의 응답에는 정해진 형식이 없으며 경우와 상황에 따라 다르다. 하지만 실제로 많이 사용하는 Web API는 앞서 말한 JSON형식을 가장 많이 사용한다.

💡 JSON?? JSON(Javascript Object Notation)는 Javascript에서 Object를 표기하는 방식을 의미한다.
얼핏 보기에는 파이썬이 "Dictionary"를 표기하는 방식과도 비슷하게 생겼다. 실제로도 아래의 JSON예시를 그대로 파이썬 변수값으로 입력해도 문제가 없다. 그대로 가져다 사용할 수 있는 셈이다. JSON은 다른 프로그래밍에서도 사용되고 있을 정도로 표준처럼 자리 잡았다. 그렇기 때문에 Javascript에 국한되어 있지 않고 널리 사용된다.
또한 JSON을 이용한 구조는 사람들도 나름 쉽게 읽고 이해할 수 있고 어플리케이션에서도 쉽게 이해할 수 있는 장점이 있다.

{
  "glossary":{
    "title":"example glossary",
    "GlossDiv":{
      "title":"S",
      "GlossList":{
        "GlossEntry":{
          "ID":"SGML",
          "SortAs":"SGML",
          "GlossTerm":"Standard Generalized Markup Language",
          "Acronym":"SGML",
          "Abbrev":"ISO 8879:1986",
          "GlossDef":{
            "para":"A meta-markup language, used to create markup languages such as DocBook.",
            "GlossSeeAlso":[
              "GML",
              "XML"
            ]
          },
          "GlossSee":"markup"
        }
      }
    }
  }
}

2. HTTP API

HTTP는 HyperText Transfer Protocol이라는 약어로 컴퓨터들의 기술적인(알고리즘, 데이터 형식, 계층구조 등..) 통신규약(protocol) 중 하나이다. 하나의 컴퓨터가 다른 컴퓨터와 파일을 받거나 전송하거나 하는 등의 소통을 하고 싶을 때에 정해진 규칙과 틀을 준수해야 원활한 소통이 가능하다.

예를 들어 이메일을 주고 받을 때에는 이메일 사이트로 로그인해서 받은 편지함을 보면 되지만 실제로 받아야 하는 메일을 받아야 하는 이메일 주소로 보낼 수 있도록 해주는 규약들이 있다. POP3, SMTP, IMAP등이 그러한 규약들이다.

HTTP는 웹에서 통신할 때 사용되는 규약이다. 따라서 모든 컴퓨터는 웹에서는 HTTP를 사용하여 소통한다. HTTP를 사용하게 된다면 웹과 관련된 작업을 한다는 것을 표현하는 것이기도 하다. 위의 그림에서 나오듯이 HTTP를 통한 소통은 크게 요청(HTTP Request)과 응답(HTTP Response)로 나눠져있다.

HTTP Request 한 컴퓨터가 다른 컴퓨터에 리소스 요청을 보낼 때 사용되는 말이다. 보통 요청을 하는 컴퓨터는 클라이언트라 부르고 요청을 받는 컴퓨터는 서버라고 부른다. 이러한 요청을 보낼 때 사용하는 것들을 HTTP 요청 메소드라고 하며, 다양한 메서드들을 [MDN HTTP Request Methods]에서 확인 가능하다.

다양한 메서드들 중에서 데이터를 다룰 때 큰 틀의 기준이 되는 4가지 요청인 [CRUD]에 해당하는 메소드는 다음과 같다.

이러한 요청들을 특정 방법으로 사용하도록 정해진 것은 아니다. DELETE메소드를 사용해 회원가입을 진행할 수 있고 GET으로 업데이트도 할 수 있다. 이렇게 할 수 있는 이유는 클라이언트와 서버가 사전에 약속된 방법만 있다면 작동에는 문제가 없기 때문이다.

물론 어느 HTTP메소드인지에 따라 제한이 있다. GET이나 DELETE와 같은 경우에는 주소에만 데이터를 담아 넘길 수 있다. 복잡한 데이터 형태를 넘기기에는 제한이 많다.

그리고 각각의 CRUD요청은 각각의 주소를 가지게 되고, 클라이언트는 각각의 주소로 요청을 보내게 되는데, 모든 CRUD요청마다 주소가 생기면 주소의 수가 너무 많아져 관리가 어려워지고, 기능이 겹치는 주소가 담긴 API에 버그가 생긴다. 이를 해결하기 위하여 사람들은 CRUD를 하나의 주소로 관리하는 API, RESTful API를 사용하기 시작했다. API를 제작할 때에는 보통 REST가이드라인을 따라 제작된다. 그리고 이 가이드라인을 따라 HTTP메소드들이 사용된다.

HTTP Response HTTP Request를 보내면 이 요청은 HTTP규약을 통해서 보낸 요청이기 때문에 응답 또한 HTTP규약에 따른 응답을 받게 된다.

클라이언트 측에서 요청을 보내게 되는 경우 서버 측에서도 다양한 응답을 보내게 되고, 각 응답은 기본적으로 상태코드([Status Code])라는 것을 가지고 있다. HTTP요청에 대한 상태가 어떤지 알려주는 것이다. 상태 코드는 총 5개의 종류로 나누게 된다.

💡 HTTP 상태 코드 분류

• 100번대: 정보응답
• 200번대: 성공응답
• 300번대: 리다이렉션 메시지
• 400번대: 클라이언트 에러 응답
• 500번대: 서버 에러 응답

이런 응답코드는 웹페이지를 열어 개발자 도구를 연 뒤에 네트워크 탭으로 들어가면 실제로 보내지는 HTTP요청과 응답을 볼 수 있다.

3. RESTful API

[REST]는 REpresentational State of Transfer의 줄임말이다. 지금 널리 사용되고 있는 World Wide Web(WWW)와도 같은 분산 하이퍼미디어 시스템을 위한 소프트웨어 아키텍쳐의 한 형식이다. 여기서 중요한 것은 소프트웨어의 아키텍쳐를 어떻게 형성할지에 대한 가이드라인이라는 것이다. 총 6개의 가이드라인이 존재하는데 다 따르게 된다면 해당 아키텍처를 RESTful이라고 부르게 된다.

조금 더 REST에 대해서 간결하게 정리하면 다음과 같다.

1. HTTP URI를 통해 자원(Resource)을 명시한다. 👉 자원
2. HTTP Method를 사용하여 👉 자원에 대한 행위
3. 해당 자원(URI)에 대한 CRUD Operation을 적용한다. 👉 자원에 대한 행위의 내용

REST의 특징으로는 5가지를 들수 있으며 다음과 같다.

1. Server-Client(서버-클라이언트 구조)
2. Stateless(무상태)
3. Cacheable(캐시 처리 가능)
4. Layered System(계층화)
5. Uniform Interface(인터페이스 일관성)

REST아키텍처는 HTTP를 사용할 때 특정 가이드라인을 제시한다. 만약 서버에서 이미지를 요청할 때 어떤 서버는 GET을 통해서 이미즈를 전달할 수 있고, 다른 서버는 POST요청을 통해 이미지를 전달할 수 있다고하자. 각 서버의 API가 다르기 때문에 유저는 사용할 때마다 각 서버의 API활용법을 개별적으로 알고 있어야 한다. 만일 서버가 늘어난다면 유저가 알고있어야 할 API는 더 늘어나게 되고 유저들의 피로감은 엄청날 것이다. 그래서 REST아키텍쳐라는 것이 등장하여 HTTP를 사용할 때 일종의 가이드라인을 제시해서 웹 API의 혼란 속에 질서를 세우려고 하는 것이다. 하지만 말 그대로 가이드 라인이기 때문에 모든 API가 따라야 하는 것은 아니다. 보통 RESTful API를 작성했다고 하면 HTTP 메소드를 다음과 같이 사용한다.

• GET: 데이터를 조회

• POST: 데이터를 생성
• PATCH: 데이터를 업데이트(일부 변경)
• PUT: 데이터를 업데이트(전체 변경)
• DELETE: 데이터 삭제

2. 회고

RESTful API는 사실 아직 잘 이해는 못했다. 나중에 좀 더 찾아보자.


[N314]:https://velog.io/@sea_panda/N314-TIL-%EB%B0%8F-%ED%9A%8C%EA%B3%A0 [MDN HTTP Request Methods]:https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods [CRUD]:https://ko.wikipedia.org/wiki/CRUD [Status Code]:https://developer.mozilla.org/en-US/docs/Web/HTTP/Status [REST]:https://restfulapi.net/rest-api-design-tutorial-with-example/

0. 학습목표

• 웹 스크레이핑을 이해하고 설명할 수 있다.
• 파이썬을 통해서 웹 스크레이픙을 할 수 있다.
• HTML 혹은 CSS를 설명할 수 있다.
• DOM에 대해서 설명할 수 있다.
• requests 라이브러리를 사용할 수 있다.
• beautifulsoup 라이브러리를 사용할 수 있다.

1. 주요개념

1. HTML, CSS

위 사진은 구글 홈페이지의 HTML과 CSS이다. 왼쪽이 HTML, 오른쪽이 CSS이다.

1-1. HTML

HyperText Markup Language의 약자로 웹에서 페이즈를 표시할 때 사용한다. [MDN]에서는 웹페이지가 어떻게 구성되어 있어야 하는지 알려주는 마크업 언어라고 소개되어 있다. 즉, 웹페이지에서 보여지는 각 요소들이 어디에 위치해야 하는지 알려주는 마크업 언어이다.

HTML에서는 요소(element)라는 것들이 존재한다. 그리고 각 요소들은 Tag를 통해서 표현된다. 즉, head라는 요소는 <head> </head>처럼 표현된다는 것이다. 이 태그를 잘 보면 두가지 태그로 이루어진 것을 알 수 있는데, 하나는 열어주는 태그(Opening Tag)이고 두 번째는 닫아주는 태그(closing Tag)이다. 두 태그 모두 꺽쇠를 사용하지만 닫아주는 태그만 슬래시 /를 사용한다.

여기서 주의해야하는 것은 모든 요소들에서 닫아주는 태그가 있는 것은 아니다. 요소에 따라서 열어주는 태그만 사용할 때도 있다. 빈 줄을 추가하는 <br>이나 수평으로 줄을 그어주는 <hr>과 같은 요소들이 그 예시이다.

그리고 하나의 요소 안에 다른 요소(Children)을 추가할 수 있다. 방식은 다음과 같다.

<ul>
  <li>hello</li>
  <li>World</li>
  <li>!</li>
</ul>

위는 리스트를 HTML에서 표현할 때 쓰는 표현방식으로 이렇게 표현되는 리스트는 내부에 HTML요소가 자동으로 포함되어야 한다.

1-2. CSS

HTML이 웹페이지가 어떻게 구성되어야 있어야 하는지 알려주는 뼈대와 같은 역할을 한다면 CSS는 이를 꾸며주는, 즉 어떻게 표현되는지 알려주는 스타일시트 언어이다. Cascading Style Sheets의 약자로 알 수 있듯이 CSS는 HTML이 표현한 문서가 어떻게 표현되는지 알려준다.

HTML에서도 태그 내에 스타일에 대해서 알려줄 수 있다. 하지만 스타일에 관한 내용이 많아지면 HTML이 복잡해지고 편의성도 떨어지기 때문에 분리해서 사용한다.

CSS에서는 특정 요소를 선택할 수 있는 방법인 셀렉터라는 것들이 존재한다. 다양한 종류의 셀렉터가 존재하며, 그 중에서 기본적인 몇 개만 살펴보면 다음과 같다.

1. Type selector: CSS 타입에 따라서 선택할 수 있다.(ex. p, div)
2. Class selector: 클래스에 따라 선택할 수 있다.
3. Id selector: id에 따라 선택할 수 있다.

CSS 상속 스타일에 대한 문서를 작성할 때 주의해햐 할 점 중 하나가 상속이다. CSS는 요소의 위치에 따라서 상위 요소의 스타일을 상속받도록 되어있다. 이런 특성으로 인해 스타일을 반복작업을 거치지 않고도 하위 자식요소들에게 적용되지만 이에 따라 상속을 어떻게 받을지 잘 생각해야 한다.

<div style = "color:red">
  <p>I have no style</p>
</div>

p태그는 아무런 스타일이 적용되어 있지 않아도 상위 요소인 div의 스타일을 상속받는다.

CSS Class Selecotor 클래스는 어떤 특정 요소들의 스타일을 정하고 싶을 때 사용된다. 동시에 여러 개의 요소들에 대한 스타일을 정할 때에 보통 클래스를 지정해서 상속받도록 정한다.

.banana {
    color:"yellow";
}

CSS에서는 위와 같은 방법을 통하여 .을 통해서 클래스를 정의할 수 있다. 이렇게 정의한 클래스는 HTML에서는 다음과 같은 방법으로 적용할 수 있다.

<p class="banana">I have a banana class</p>

이때 여러 개의 클래스도 동시에 부여할 수도 있다.

<p class="banana fruit orange">I have a banana class</p>

CSS ID Selecotor 클래스와 비슷하게 사용할 수 있는 것이 ID이다. HTML에서는 클래스뿐만 아닌 ID도 지정할 수 있다. 다만 ID는 보통 특정 HTML 요소를 가리킬 때에만 사용된다. 클래스와 달리 보통 여러 개의 요소에 사용되지 않는다. 이러한 차이점을 인지하고 ID 혹은 클래스를 구분할 수 있어야 한다.

CSS에서는 #기호를 통해서 스타일을 정할 수 있다.

#pink{
    color:"pink";
}

이 ID를 이용하는 HTML예시는 다음과 같다.

<p id='pink'>My id is pink</p>

2. DOM

DOM은 Document Object Model의 약어로 웹페이지에서 매우 중요한 역할을 하는 문서 객체 모델이라고 불린다. 여기서 중요한 역할이란 HTML문서에 접근하기 위한 일종의 인터페이스 역할로 문서 내의 모든 요소를 정의하고, 각각의 요서에 접근하는 방법을 제공한다. 이러한 기능 덕분에 프로그래밍 언어에서도 웹페이지의 요소나 스타일 등을 추가하거나 수정하는 등 다양한 작업을 진행할 수 있다.

특히 DOM은 객체(Object)로 표현을 하는데 이 때 object란 JS(Java Script)에서 사용되는 데이터 구조 중 하나를 의미한다. 파이썬에는 이와 비슷한 것으로 dictionary가 존재한다.

즉, DOM을 통해서 HTML을 프로그래밍 언어에서 사용할 수 있는 데이터 구조 형태로 작업을 수행할 수 있어서 크롤링 등 웹 페이지와 작업할 때 매우 중요한 개념 중 하나이다.

DOM의 종류 W3C DOM 표준은 세가지 모델로 구분된다. 1. Core DOM: 모든 문서를 타입을 위한 DOM모델 2. HTML DOM: HTML문서를 위한 DOM모델 3. XML DOM: XML문서를 위한 DOM모델

DOM을 사용할 수 있는 가장 손쉬운 방법 중 하나는 개발자 도구를 열어서 Console 창으로 들어가 JS를 통하여 DOM을 사용해 보는 것이다.

위 사진은 Console창에서 JS를 통해서 NodeList라는 이름의 p태그를 사용하는 요소들을 담은 유사 배열이라는 것을 받은 것이다. 이처럼 HTML이나 XML 등 웹페이지의 문서 형식을 프로그래밍 언어에서도 사용할 수 있는 큰 장점이 있다.

이와 비슷하게 DOM에는 다양한 기능들이 존재하며 대표적인 몇가지만 나타내어 보겠다.

• getElementsbyTagName: 태그 이름으로 문서의 요소들을 리턴한다.

• getElementById: id가 일치하는 요소들을 리턴한다.
• getElementByClassName: class가 일치하는 요소들을 리턴한다.
• querySelector: selector와 일치하는 요소들을 리턴한다.
• querySelectorAll: selector와 일치하는 모든 요소들을 리턴한다.

DOM은 크롤링 할 때에도 DOM의 개념은 중요하다. 예를 들어 파이썬에서 크롤링을 한다고 해도 웹 페이지를 텍스트, 즉 문자열로 읽게되면 원하는 정보를 찾기가 쉽지 않을 것이다. 하나의 거대 문자열로 웹페이지를 인식하게 되면 텍스트를 해석하고 원하는 정보를 찾을 때 구별하기 쉽지 않게 된다. 따라서 보통은 웹페이즈를 텍스트 형식으로 사용하는 것이 아닌 DOM을 활용한다.

<html>
    <head>
    </head>
    <body>
        <h1>h1 태그입니다.</h1>
        <p>p 태그입니다.</p>
    </body>
</html>

위와 같은 간단한 html이 있다고 하자. 여기서 만일 h1의 내용을 알고 싶을 때 html이 전부 문자열이였다면 태그를 구분할 수 있는 방법을 먼저 고민하고, 그 후에 태그 내부에 있는 정보를 받아 사용할 수 있다. 하지만 이렇게 되면 단순한 작업을 하는 것도 오래 걸리게 된다.

반면에 DOM을 사용하면 위에서 봤던 예시처럼 간단한 명령어를 통해서 태그 내용을 추출할 수 있다. 이런 편의성으로 인해 DOM이 중요하다.

3. 웹 스크레핑과 크롤링

웹스크레핑

웹 스크레핑은 특정 웹 사이트나 페이지에서 필요한 데이터를 자동으로 추출해 내는 것을 의미한다. 원하는 데이터를 추출하기 위해서 특정 웹 사이트에 콘텐츠를 다운로드하기 위한 HTTP GET요청을 보낸다. 이에 사이트가 응답하면 HTML문서를 분석하여 특정 패턴을 지닌 데이터를 뽑아낸다. 그리고 추출된 데이터를 원하는 대로 사용할 수 있도록 데이터베이스에 저장한다.

웹 스크래핑은 자동으로 수집된 특정 정보가 필요한 분야에서 다양하게 활용되고 있다. 금융 및 주식 시장의 경우, 스크래핑 기술을 활용하여 뉴스 정보를 모으기도 하고, 애널리스트들이 투자 자문을 위해 활용할 수 있는 기업 재무제표 정보를 자동으로 수집하기도 한다. 전자 상거래 시장의 경우 경쟁력 확보를 위해 경쟁사 상품의 정보를 수집하고 가격 변동 이슈를 빠르게 파악하기 위해 스크래핑 기술을 활용하기도 한다.

웹 스크레핑은 특정사이트에 필요한 데이터를 찾는데 집중하기 때문에 데이터 포인트를 정확히 잡고 확실한 정보만을 수집할 수 있다는 점에서 유용한다. 장기적으로 서비스 대역폭이나 비용을 절약할 수 있다는 장점이 있다.

그리고 스크래핑은 방식에 따라서 크게 정적 스크래핑과 동적 스크래핑 나눌 수 있다.

정적 스크래핑은 정적인 데이터를 수집하는 방법으로 한 페이지 안에서 원하는 정보가 모두 들어나는 경우에는 이 방식을 활용하여 스크래핑할 수 있다. beautifulsoup4가 대표적인 라이브러리이다.

동적 스크래핑은 페이지에서 로그인, 스크롤 등의 이동이나 실시간으로 페이지의 내용이 계속 추가되거나 수정될 때 사용할 수 있는 방식이다. Selenium이 대표적인 라이브러리이다.

웹크롤링

웹 크롤링이란 "기어다니다"라는 뜻을 지닌 이름에서도 알 수 있듯이 여러 웹사이트들을 기어다니며 원하는 정보를 탐색하고 수집하는 작업을 의미한다. 인터넷에 존재하는 방대한 양의 정보를 사람이 일일히 파악하는 것은 불가능한 일이다. 때문에 규칙에 따라 자동으로 웹 문서를 탐색하는 컴퓨터 프로그램, 웹 크롤러(Crawler)를 만들었다.

크롤러는 인터넷을 돌아다니며 여러 웹 사이트에 접속한다. 그리고 페이지의 내용과 링크의 복사본을 생성하여 다운로드하고 요약본을 만든다. 그리고 검색 시 유용한 정보만을 노출하도록 검색 색인을 붙인다. 이는 도서관에서 책을 찾기 위해 분류 기준을 구성하는 것과 비슷한 작업이다.

웹 크롤링은 웹상을 돌아다니며 방대한 양의 정보를 수집하기 때문에, 특정 키워드에 대한 심층 분석이 필요할 때 유용하다. 또한 크롤러는 실시간 정보 수집을 위해 계속해서 작동하므로 자주 변화하는 데이터를 파악하기가 좋다.

차이점

둘은 "원하는 데이터를 모을 수 있다."라는 점이 비슷하여 의미가 자주 혼용되고 한다. 또한 기술적으로 함께 사용되는 경우가 많아 더욱 헷갈린다. 하지만 웹 크롤링은 웹 페이지의 링크를 타고 계속해서 탐색을 이어나가지만, 웹 스크레핑은 데이터 추출을 원하는 대상이 명확하여 특정 웹 사이트만을 추적한다는 차이점이 있다.

또한 웹 크롤링은 페이지를 모아 색인화하고 검색 결과에 내가 찾는 키워드와 관련된 링크만 모아 볼 수 있도록 작동한다. 하지만 웹 스크래핑은 상품의 가격, 주식정보 등 원하는 데이터가 명확하여, 흩어져있는 해당 데이터를 자동으로 추출하여 전달한다. 이 외에 차이점은 아래와 같다.

4. Library: requests

공식문서: https://requests.readthedocs.io/en/latest/

파이썬에서 사용할 수 있는 웹과 소통을 편하게 해주는 라이브러리이다. 이 라이브러리는 파이썬에서 HTTP요청을 보낼 때 거의 표준으로 사용되는 정도로 많이 사용되고 있다. 특히 HTTP요청을 간단한 메소드를 통해 실행할 수 있도록 짜여졌다는 것이 가장 큰 장점 중 하나이다. 따라서 사용자는 HTTP요청이나 응답에 대한 고민을 줄이고 실제 서비스나 기능에 더욱 집중할 수 있게 된다.

먼저 pip을 사용하여 라이브러리를 설치해준다.

pip install requests

다음으로 라이브러리를 불러와서 원하는 사이트의 콘텐츠를 다운로드 하기 위한 Get요청을 다음과 같이 보낼 수 있다.

import requests

requests.get('{사이트주소}')
-------------------------
<Response [200]>    # 정상적으로 연결됐을 시 출력

응답 객체의 type을 확인하면 다음과 같은 결과가 출력된다.

<class 'requests.models.Response'>

requests라이브러리의 Response타입인 것을 알 수 있다.

import requests

url = 'https://google.com'

resp = requests.get(url)
print(resp.status_code)

위 코드를 통해서 응답의 상태 코드를 확인할 수 있다. 200이라고 출력된다면 정상적으로 요청이 처리된 것이다.

다음으로는 응답 객체를 통해 응답 내용을 살펴보겠다. 먼저 웹 브라우저를 통해 웹 페이지에 접속하게 되면 보이게 되는 HTML은 사실 브러우저에서 뒷작업을 거치면서 보여지게 되는 것이다. 그러나 본질은 HTML, CSS 등 문서 파일이라는 것은 변함이 없다.

따라서 requests라이브러리를 활용해서 웹 브라우저가 받는 동일한 HTML문서를 받을 수 있다. 물론 이것 뿐만 아니라 서버에서 보내주는 데이터도 받을 수 있다.

일단 Response객체에는 text라는 속성이 존재한다. 이 속성은 서버에서 받은 응답을 텍스트 형식으로 보여주게 된다. 서버에서 받게되는 응답의 데이터는 실제로 bytes로 받게 된다. 따라서 해당 데이터를 텍스트로 인지하기 위해서는 알맞게 디코딩 작업을 거쳐야 한다. 이런 디코딩 작업을 text속성이 알아서 해주기 때문에 보통은 걱정하지 않아도 된다. 그리고 requests의 기본적인 인코딩 방법은 utf-8이다.

resp.text
----------
'<!doctype html><html itemscope=" "......><head>...</head></html>'

출력을 자세히 살펴보면 하나의 HTML파일이다.

5. Library: BeautifulSoup

공식문서: https://www.crummy.com/software/BeautifulSoup/bs4/doc/

requests를 통하여 실질적으로 돌려받은 응답 내용을 파싱(parsing)하고 정보를 얻어낼 수 있어야 한다. BeautifulSoup 라이브러리는 받아온 HTML파일을 파싱해서 원하는 정보를 손쉽게 찾을 수 있도록 해준다.

💡 파싱(Parsing)이란? 파싱은 구문 분석이라고 한다. 문장이 이루고 있는 구성 성분을 분해하고 분해된 성분의 위계 관계를 분석하여 구조를 결정하는 것이다. 즉 데이터를 분해 분석하여 원하는 형태로 조립하고 다시 빼내는 것을 말한다. 웹상에서 주어진 정보를 내가 원하는 형태로 가공하여 서버에서 불러들이는 것이다.
더 쉽게 이야기하면 HTML 등을 파이썬 등에서도 사용할 수 있게 변환해주는 것이라 생각해도 된다.

설치는 다음과 같이 pip을 사용하여 설치한다.

pip install beautifulsoup4

기본 파싱

먼저 파싱할 문자열과 어떻게 파싱할 것인지 정한다. 기본적으로 사용할 수 있는 parser는 html.parser이다. 이때 이 parser는 파이썬 기본 라이브러리에 포함되어 있기 때문에 별도의 설치가 필요하지 않지만, 만약에 XML문서나 다른 HTML파서(ex. htm5lib)등을 사용하려면 따로 설치를 진행해야 한다. 각 parser에 대한 장단점은 공식문서에 나와있다.

다음과 같은 코드를 이용하면 문자열로 된 HTML파일을 넘길 수 있다.

import requests
from bs4 import BeautifulSoup

url = 'https://google.com'
page = requests.get(url)

soup = BeautifulSoup(page.content, 'html.parser')

요소찾기

파싱을 완료했으면 원하는 요소를 찾아내야 한다. 기본적으로 id, class, tag 등의 특징들과 find 및 find_all메소드를 이용해 찾아내는 방법들을 알아보겠다.

bs4에서 한 개의 요소를 찾을 때에는 find, 여러 개의 요소들을 찾을 때는 find_all을 사용하게 된다. find는 조건에 일치하는 첫번째 결과를 리턴하고 find_all은 조건에 일치하는 모든 결과를 리스트에 담아 반환한다. 그리고 여기서 얻게 되는 결과들은 HTML문서이기 때문에 결과를 가지고 다시 find혹은 find_all과 같은 메소드를 실행할 수 있다.

"""
id = 'dog'인 요소 찾기
id는 주로 한번만 사용되기 때문에 find 사용
"""
dog_element = soup.find(id='dog')
------------------------
"""
class = 'cat'인 요소 찾기
class를 이용해 찾을 경우 class_을 사용해야 한다. 이는 파이썬의 class와 구분하기 위함이다.
class는 다양한 요소에 사용되기 때문에 find_all을 사용
"""
cat_elements = soup.find_all(class_='cat')
------------------------
"""
앞 서 설명했듯이 얻게된 결과 역시 HTML문서이기 때문에 결과를 가지고
다시 find 및 find_all사용 가능
"""
cat_elements = soup.find_all(class_='cat')

for cat_el in cat_elements:
    cat_el.find(class_='fish')

태그 활용

조금 더 상세하게 찾고 싶을 경우 tag를 조합해서 사용할 수 있다.

예를 들어 cat이라는 클래스가 div라는 태그에도 있고 p태크에도 있다면 이 때 div태크를 사용하는 요소들만 가지고 오고 싶다면 다음과 같이 실행할 수 있다.

cat_div_elements = soup.find_all('div',class_ = 'cat')

String 활용

특정 문자열이 포함되어 있는 요소를 찾고 싶을 때 사용할 수 있다. 만일 raining이라는 문자열이 포함되어 있는 요소를 찾고 싶다면 string파라미터를 이용해 다음과 같은 코드를 사용할 수 있다.

soup.find_all(string='raining')

이때 string의 단점은 명시한 문자열을 그대로 찾는다는 것이다. 즉, 정확히 raining이라는 문자열을 포함하는지 확인한다. 만약에 대소문자를 잘못 적어써나 띄어쓰기를 실수했다해도 동일한 문자열을 포함한 요소를 찾는다.

만일 이런 엄격한 기준으로 찾기보다 대소문자 구분없이 들어가 있는 것을 찾고 싶다면 익명함수를 활용할 수 있다.

soup.find_all(string=lambda text: 'raining' in text.lower())

이때 string을 사용하면 .string속성을 불러오는 것이기 때문에 요소가 아닌 문자열로 리턴된다. 따라서 하나의 요소로 받기 위해서는 태그도 같이 추가해야 된다.

soup.find_all('h3', string='raining')

정보 얻기

원하는 요소들을 선택했다면 이제부터는 정보를 얻어낼 수 있어야 한다. 기본적으로 text속성을 이용해서 내부 문자를 얻어낼 수 있다. 다음과 같은 HTML에서 p태그 내부 글을 얻으려면 text속성을 사용할 수 있다.

<p class='cat'>This is a p-cat</p>

cat_el = soup.find('p', class_='cat')

cat_el.text
------------------------------------
'This is a p-cat'

만일 불필요한 띄어쓰기가 있을 수 있다. 그럴 때에는 파이썬의 strip메소드를 사용해서 정리해줄 수 있다. strip은 특정 문자를 제거하는 함수로 아무 인자도 입력으로 주지 않으면 공백을 제거한다.

cat_el.text.strip()

2. 회고

음...할 말이 없다. 너무 오래 지났다. 일단 빨리 다음 것도 마무리하고 정상화 렛츠기릿 해야겠다.

❗️참고자료

1. 크롤링과 스크래핑
2. 파싱

"파이썬에서는 모든 것이 객체다"

0. 학습목표

• 파이썬 개발자들이 공통으로 가진 철학을 말할 수 있다.
• pdb디버거를 반복문, 함수에 사용하여 문제가 일어나는 부분을 찾을 수 있다.
• 함수와 클래스를 이용해 파이썬 코드를 작성할 수 있다.

1. 주요개념

1. Debugging(디버깅)

디버그(Debug)는 프로그래밍 과정중에 발생하는 오류나 비정상적인 연산, 즉 Bug를 찾고 수정하는 것이다. 이 과정을 디버깅이라 하기도 한다.

Debug의 어원의 유래는 초창기 컴퓨터에 나방이 들어가 고장을 일으킨데에 있다. 그 뒤로 버그는 조작하는데 발생한 오류의 은유적 표현이 되었다.

프로그래밍에서 버그는 일종의 불가항력같은 것이라서 아무리 능력이 좋거나 경험이 많더라도 버그가 없는 프로그램을 만들 수 없다. 다만 요령있는 사람은 오류 지향적인 설계보다는 견고한 설계를 지향하고 버그가 나더라도 잡아낼 수 있도록 유도하여 짠다.

파이썬에서는 디버깅을 위해서 pdb라는 표준 라이브러리에 포함된 디버깅 도구가 있다. 사용 방법은 다음과 같다.

import pdb

def simple_func(num):
    sum = 0
    pdb.set_trace()

    for i in range(1, num + 1):
        pdb.set_trace()
        sum += i

    return sum

simple_func(4)

#다음은 실행결과입니다.

-> for i in range(1,num+1):
(pdb)

파이썬 3.7이상부터는 `breakpoint()`라는 함수를 실행하기만 하면 된다.
즉, `pdb.set_trace()`대신에 `breakpoint()`를 입력하면 된다.

위 코드를 실행하면 (pdb)라는 문구가 뜨고 코드가 여기에 멈춘다. 이렇게 멈춘 상태에서 특정 단계들을 검토한다던지 등 다양한 작업을 할 수가 있다. 위 코드의 결과에서 화살표로 보이는 것은 다음 줄을 표시하는 것이다. 현재는 sum=0 바로 다음 줄에 있는 함수에 멈춰있다. 여기에서 현재 상태에서는 변수에 어떤 것들이 저장되어 있는지 확인할 수 있다.

(pdb)단계에서 쓸 수 있는 pdb command는 다음과 같다.

2. Pythonic

Pythonic은 파이썬답게 코드를 짜는 것을 말한다. 파이썬다운 코드라하면 파이썬의 기능들을 잘 이용하여 작성된 코드이고, 그렇기 때문에 가독성이 좋은 코드를 말할 것이다. 대게 파이썬 커뮤니티의 사람들이 쓰는 패턴을 pythonic(파이썬다운)코드라고 생각한다.

이러한 pythonic을 작성할수 있도록 가이드가 존재한다. (Pythonic Coding Convention) PEP 8이 바로 그것이다. 이 가이드는 절대적인 것은 아니다. 잘 동작하고 읽기 쉽고 유지보수가 쉽다면 그보다 좋은 코드는 없다. 하지만 가이드를 따른다면 나뿐만 아니라 다른 사람에게도 읽기 쉽고, 유지하기 쉬운 코드가 된다. 이처럼 코드의 가독성과 일관성이라는 장점을 얻을 수 있다.

PEP 8의 주요 내용을 정리하여 번역한 codechacha.com를 시간날 때 읽어보자.

3. 함수

파이썬을 사용하면 피할 수 없는 것 중 하나가 함수이다. 파이썬을 설치하면 sum, print 등의 내장함수를 사용할 수 있고, pandas, numpy 등의 외부 라이브러리에도 loc,iloc 등의 함수가 포함되어 있기 때문이다. 또한 파이썬, 라이브러리의 설치와 함께 사용될 수 있는 내장된 함수들이 있다. 이를 "Built-in functions"라고 한다. 이와 별개로 새로 만들어지는 함수들은 "user-defined functions"라고 한다.

함수는 특정한 기능을 반복적으로 실행할 수 있도록 도와주기 때문에 반복적인 작업들을 하지 않아도 된다.

파이썬에서 함수를 만들기 위해서는 몇가지 규칙이 존재한다. 함수의 문법을 정리하면 다음과 같다.

def 함수_이름( 파라미터 ):
   "함수 문서"
   함수 내용
   return [표현식]

위 코드에서도 알 수 있듯이 함수를 정의하게 되면 함수에 포함되는 코드는 들여쓰기를 통해 구별짓는다. 가장 처음으로 오는 줄은 함수에 대한 문서가 될 수 있다(주석 및 설명). 이는 선택사항이라 존재유뮤 자체가 함수의 기능에 영향을 미치지는 않는다.

함수의 파라미터들은 위치에 따라 영향을 받는다. 따라서 파라미터를 어느 순으로 받는지 정한 것에 따라 함수를 호출할 때 순서를 지켜서 인수(Argument)를 넘겨야 한다.

def get_names(name_1, name_2, name_3):
    print(f"{name_1}{name_2}, {name_3}")

get_names("sponge", "bob", "patrick")

코드에서 순서를 바꾼다면 spongebob patrick이 출력되지 않는다.

파이썬에서는 인수들이 함수에 전달될 때 참조로 전달된다. 즉, 객체의 주소값을 전달(ex. int, str)한다. 하지만 immutable인 객체(ex. list, dict)들은 값으로 전달된다.

함수에 전달되는 인수는 크게 3가지로 나눠진다.

- 필수 인수

def person_info(first_name, last_name):
    print(f"Hello {first_name}, {last_name}!")

위의 예시처럼 위치에 따라서 전달되는 인수이다. 순서를 지켜야하며 함수에서 파라미터로 정의했기 때문에 필수로 넘겨야한다. 만일 모든 필수 인자를 전달하지 않고 코드를 실행하면 TypeError가 발생한다.

- 키워드 인수 위치로 전달하지 않고 키워드를 사용하여 전달하는 인수를 의미한다. 아래처럼 키워드를 명시하여 실행 할 수 있다. 필수 인수들을 전달하기만 하면 순서는 상관없다.

person_info(last_name="bob", first_name="sponge")

- 기본 인수 만약에 함수에서 받게 되는 파라미터 값들에 대해서 기본 값들을 설정하면 인수를 넘기지 않을 경우 기본값들이 설정되어 함수를 실행하게 할 수 있다.

def person_data(name, type_p='human'):
    print(f"Hello {name}, you are {type_p}")

위와 같은 경우에는 type_p인수를 넘기지 않으면 함수에서 기본값인 human으로 입력으로 받게된다. 여기서 주의할 점은 기본 값은 설정된 파라미터들은 기본값이 없는 파라미터 뒤에 등장해야 한다는 것이다. 만일 이를 어기면 syntaxError가 발생한다.

파이썬에서는 함수를 종료하기 위해서는 return을 사용하여야 한다. 그리고 호출자에게 표현을 전달하는 기능도 있다. 즉, 함수에서 return을 만나게 되면 함수기 그 즉시 종료된다.

def print_hello_1(name):
    print(f"Hello {name}")
    return None

위 코드에서는 return을 따로 명시하지 않아도 print문이 출력된다. 하지만 이는 함수의 출력은 아니고 함수가 실행되면서 그 안에서 print문에 의해서 실행된 것에 불가하다. 함수의 출력결과는 None이다.

a = print_hello_1('sponge')
print(a)

위의 출력 결과는 이름이 나오겠지만 함수의 출력값인 a는 None이라는 의미이다.

따로 리턴 문구를 넣어서 특정 결과를 리턴하게 할 수 있다.

def print_hello_4(name):
    return f"Hello {name}"

위 처럼 실행하면 함수의 결과값은 "Hello {name}"이 된다.

4. Class와 객체(object, or Instance)

파이썬에서는 모든 것이 객체이다. 그리고 이러한 객체를 만들기 위한 설계 도면이 바로 Class이다. 다시 말하자면, 함수와 비슷하게 설계 중심의 사고와 재사용성을 줄이기 위하여 만들어진 것이다. 조금 더 자세히 함수와 클래스의 차이를 알아보자면, 클래스가 조금 더 큰 범위라고 생각하면 된다. 클래스에서는 함수와 속성 두 가지를 전부 담을 수가 있다. 이때 클래스의 함수는 Method라고 한다. 두 가지를 전부 담을 수 있는 특성으로 인해서 다양한 정보와 기능들을 묶어서 따로 사용할 수 있다.

- 클래스 생성

class Pokemon:
    pokemon_a = 'pikachu'

    def print_pika(self):
        print("pika")

클래스는 위와 같은 형태로 만들 수 있다. 클래스 내에서 속성과 함수 모두를 정의할 수 있다. 위 코드처럼 일반적인 함수와 동일하게 클래스 내에서도 함수를 선선해도 잘 작동한다.

Pokemon.print_pika()

Class 코드에서 보면 self라는 것이 등장한다. 이는 인스턴스(객체)에서 해당 메서드를 실행할 때 자기자신을 인수로 넘겨주기 때문에 그것을 받는 자리이다.

self는 사실 단어 자체가 키워드는 아니다. 따라서 다른 단어로 대체해도 문제는 없다. 하지만 인스턴스에서 메서드나 특성을 사용할 때 첫 번째 인수, 파라미터로 넘겨지고 받아져야 한다는 것은 변함 없다. 여기서 또! 하지만! 위에서 다룬 Pythonic한 코드를 작성하기 위해서는 self를 사용하도록 가이드 하고 있다. 또한 class의 첫 번째 인자 이름은 cls를 사용하도록 권장한다.

- 생성자 함수 클래스의 함수 중에서 생성자 함수는 클래스가 인스턴스화(instantiate)될 때 사용되는 함수이다.만일 이 함수가 따로 정의되어 있지 않으면 기본 생성자 함수를 사용한다. 이 함수는 다음과 같이 사용할 수 있다.

class Pokemon:
    def __init__(self, pokemon_a='pikachu'):
        self.pokemon_a = pokemon_a

poke_a = Pokemon()
print(poke_a.pokemon_a) 

클래스 기반으로 생성되는 인스턴스는 클래스의 생성자 함수에 따라 인스턴스의 초기 속성들을 받을 수 있다. 하지만 이는 인스턴스마다의 속성이지 클래스 전체에 대한 속성은 아니게 된다. 따라서 클래스 자체에서는 이러한 속성들에 대한 접근이 힘들다. 다음과 같은 코드를 실행하면 Pokemon클래스는 인스턴스의 속성에 접근 못한다는 것을 확인할 수 있다.

Pokemon.pokemon_a
------
-> AttributeError: type object 'Pokemon' has no attribute 'pokemon_a'

5. 객체지향

우리가 실생활에서 쓰는 모든 것을 객체라 하며, 객체 지향 프로그래밍은 프로그램 구현에 필요한 객체를 파악하고 각각의 객체들의 역할이 무엇인지를 정의하여 객체들 간의 상호작용을 통해 프로그램을 만드는 것을 말한다. 객체는 클래스라는 틀에서 생겨난 실체(instance)이다. 따라서 객체 지향 프로그램은 객체와 객체 간의 연결로 되어 있으며 각각의 객체 안에 자료구조와 알고리즘이 들어있다.

객체 지향 모델링에서는 기능이 아닌 객체가 중심이 되며 "누가 어떤 일을 할 것인가?"가 핵심이 딘다. 즉 객체를 도출하고 각각의 역할을 정의해 나가는 것에 초점을 맞춘다.

💡 객체? 인스턴스? 점프 투 파이썬의 예시를 들어보자. 쿠키를 만들기 위한 틀이 있다고 하자. 이 쿠키 틀을 바로 Class라고 한다. 그리고 이렇게 쿠키틀을 이용하여 찍어낸 쿠키가 객체이자 인스턴스가 되는 것이다. 둘의 차이는 관점의 차이이다. 쿠키 그 자체를 객체라고 한다면 인스터는 보다 관계적인 의미이다. "쿠키 틀의 인스턴스는 쿠키이다."라고 할 수 있다.

6. 파이썬 데코레이터(@)

파이썬 데코레이터는 PEP 318에서 어색하고 반복적인 함수의 표현을 줄이기 위해 제안되었다. 현재는 함수뿐만 아니라 클래스, 함수, 제네레이터 등의 다른 타입에서도 사용되고 있다. 이 역시 Pythonic한 코드를 작성하는 것과 관련된 개념으로 DRY원칙(Don't Repeat Yourself)을 따르기 위하여 사용하는 다양한 방법 중 하나로, 다른 형태보다 깔끔하고 간결한 코드를 만들면서 코드의 재사용을 줄이기 위해 많이 추천되는 기술이다.

이번 수업에서는 함수 데코레이터에 대해서 다루었다.

만일 다양한 문장을 출력하는데 겹치는 문장이 있다고 하자.

def my():
    print("데코레이터")
    print("my 라는 함수입니다.")

def mine():
    print("데코레이터")
    print("mine 이라는 함수입니다.")

def iam():
    print("데코레이터")
    print("iam 이라는 함수입니다.")

위 코드는 간단한 문장을 프린트하는 방식이였지만 복잡한 로직이 들어간다면 코드는 길어지고 같은 내용을 반복해서 작성해야할 것이다. 이를 데코레이터를 이용하면 다음과 같이 간단하게 작성할 수 있다.

def first_deco(func): # func 는 실행할 함수입니다.
    def first(): # 실행할 함수를 감싸는(wrap) 함수입니다.
        print("데코레이터")
        func()
    return first #first 함수를 return합니다

@first_deco
def my():
    print("my 라는 함수입니다.")

@first_deco
def mine():
    print("mine 이라는 함수입니다.")

@first_deco
def iam():
    print("iam 이라는 함수입니다.")

만일 사용할 함수에 인자가 주어진 경우에는 인자를 처리하는 구문이 있어야 정상작동된다. 따라서 인자값이 정의되어 있을 땐 데코레이터에도 인자 값을 처리하는 *args, **kwargs구문이 필요하다.

def first_last_deco(func): # func 는 실행할 함수입니다.
    def first_last(*args, **kwargs): # 실행할 함수를 감싸는(wrap) 함수입니다.
        print("first")
        func(*args, **kwargs)
        print("last")
    return first_last

@first_last_deco
def you(name):
    print(f"{name}! Hello")

여기서 *args는 arguments의 줄임말이다. 이 지시어는 여러 개의 인자를 함수로 받고자 할 때 사용한다. 몇 개의 입력이 주어지는지 모를 때도 사용할 수 있다.

**kwargs는 {키워드=특정값}의 형태로 함수를 호출할 때 사용하는 키워드이다. 딕셔너리 형태로도 전달할 수 있다. 대표적인 사용예시는 print문에서 end키워드가 있다.

print("end=?가 바로 **kwargs입니다.",end='이것은 키워드 밸류')

키워드 인자를 받는 것이라고 생각하면 된다.

2. 명령어

이제부터는 대다수 필요한 명령어는 주요 개념에서 함께 다루는 것으로 바꿔보았다. 여기에는 과제 명령어나 위에서 다루지 않은 것들만 정리한다.

1. _와 __

예전의 수업에서도 _와 __에 대해서 다루었던 기억이 있는데 어딘지 모르겠다. 여하튼 다양한 기능을 내포하고 있는데 이번 수업에서는 변수나 함수명에 특별한 의미 또는 기능을 부여하고자 할 때 사용한다.

- Single underscore 파이썬 클래스 내부에서 따로 변수나 값을 저장할 때 사용된다. 보통 private 접근 제한자를 표현하기 위해서 사용한다. 하지만 여기서 중요한건 이는 관례적인 표현일 뿐 실제로 private해지는 것은 아니다. 여기서 private라는 것은 클래스 내부에서만 접근 가능한 변수 혹은 값을 의미한다.

보통 이 sigle underscore를 쓰면 접근하지 않았으면 좋겠다는 의미이니 여기에 직접 접근하는 것은 별로 좋지 않다.

class Pokemon:
    _pokemon_health = 100

    def __init__(self, pokemon_a='pikachu'):
        self.pokemon_a = pokemon_a

poke_a = Pokemon()
print(poke_a._pokemon_health) #=> 100

- double underscore (dunderscore) 파이썬 클래스 내부에서만 관리하도록 밑줄을 두 개 사용할 수도 있다.이때 __를 사용하면 진짜 private인 것처럼 결과가 출력되는데 이는 실제로 private한 것이 아니라 파이썬의 Name Mangling으로 발생하는 상황이다. 밑줄을 두 개 사용하게 된다면 정해준 이름을 사용하지 않고 _<클래스 이름>_<변수 혹은 함수 이름>으로 변경된다. 따라서 앞의 형식에 맞게 클래스 밖에서 이름을 선언하면 여전히 접근할 수 있다는 것을 알 수 있다. 하지만 보이는 것과 다르게 변수가 저장되기 때문에 실수로 속성에 접근하는 것을 막아준다.

class Pokemon:
    __pokemon_health = 100

    def __init__(self, pokemon_a='pikachu'):
        self.pokemon_a = pokemon_a
-----------------------------------------------------------
poke_a = Pokemon()
print(poke_a.__pokemon_health) #=> 에러
print(poke_a._Pokemon__pokemon_health) #=> 100

이렇게 밑줄을 이용하여 클래스의 속성을 바깥에서 접근하지 못하도록 하는 것을 캡슐화라고 한다.

2. getter과 setter: 클래스 특성 가져오기, 저장 변경하기

class Student:

  def __init__(self, name, age):
    self._name = name
    if age <= 10:
      raise ValueError('11살 이상의 학생만 가능합니다')
    self._age = age

stu1 = Student('son', 20)
stu1 = Student('son', 8) # ValueError 발생

# __init__함수의 영향을 받지 않으므로 ValueError가 발생하지 않는다
stu1._age = 8

문제가 없어보이는 코드처럼 보이지만 객체를 생성하고 나서 값을 변경하게 된다면 더 이상 __init__함수의 영향을 받지 않기 때문에 문제가 될 수 있다. 원래는 들어가지 못할 값이 들어가게 되는 것이다.

이러한 문제를 getter메서드와 setter메서드를 구현하여 해결할 수 있다.

class Student:

  def __init__(self, name, age):
    self.__name = name
    if age <= 10:
      raise ValueError('11살 이상의 학생만 가능합니다')
    self.__age = age

  @age.getter
  def age(self):
    return self.__age

  @age.setter
  def age(self, age):
    if age <= 10:
      raise ValueError('11살 이상의 학생만 가능합니다')
    self.__age = age
  -------------------------------------------------
a = Student('son', 21)
a.get_age() # 21
a.set_age(12)
a.get_age() # 12

위는 수동으로 직접 age에 대한 getter메소드와 setter메소드를 만든 것이다. 그리고 마지막에는 age라는 이름으로 property에 등록해주었다. 이런 방식의 특징은 get_age와 set_aget를 직접 사용할 수 있다는 것이다.

getter/setter메서드를 통해서 객체의 내부 데이터에 대한 접근을 조금 더 통제할 수 있게되었지만 기존에 필드명을 바로 사용할 때 보다는 코드가 지저분해 진 것을 알 수 있다. 그리고 호출할 때 역시 getter메서드와 setter 메서드를 호출하여야 하기 때문에 번거롭다. 이 점은 property()를 사용하면 해결할 수 있다. 위의 클래스 코드의 마지막에 다음과 같은 코드를 추가하여 준다.

age = property(get_age, set_age)
-------------------------------
a = Student('son',21)
a.age #=> 21
a.age = 15
a.age #=> 15

위와 같이 getter와 setter를 한 번에 property안에 담겨서 값이 변경되고 얻어지는 것을 확인할 수 있다.

위에서는 수동으로 각각의 메서드를 만들었다면 더 간단하게 데코레이터를 이용하여 만들 수 있다. getter를 만들기 위해 @property데코레이터를 사용한다. 함수 이름은 변수명과 동일하게 작성하는 관계가 있다. 그리고 setter를 만들기 위해 @변수.setter를 사용한다. 마찬가지로 변수명과 동일한 함수명을 추천한다.

이렇게 클래스 내부의 변수에__를 덧붙여서 private 속성을 만들고 값이 필요할 때 setter메소드와 getter메소드를 사용하는 것이 보편적인 객체지향 프로그래밍 방법 중 하나다.

class Student:

  def __init__(self, name, age):
    self.__name = name
    if age <= 10:
      raise ValueError('11살 이상의 학생만 가능합니다')
    self.__age = age

  @property
  def age(self):
    return self.__age

  @age.setter
  def age(self, age):
    if age <= 10:
      raise ValueError('11살 이상의 학생만 가능합니다')
    self.__age = age
---------------------------------------------------------------------
a = Student('son',21)
a.age #=> 21
a.age = 15
a.age #=> 15

데코레이터를 사용하면 위의 수동으로 작성한 코드와 다르게 get_age, set_age 메소드는 존재하지 않는다. age는 실제로 메서드이지만 getter역할을 하는 @property로 인하여 외부에서는 속성처럼 사용할 수 있게된다.

@property는 클래스 메소드를 속성처럼 사용할 수 있게 해준다. @property를 붙인 메소드는 일반적으로 어떤 인스턴스 변수에 대한 getter메소드임을 나타낸다.

3. assert: 가정 설정문(코드의 동작 보장)

조건문이 True가 아닐 경우, 예외를 일으킨다. 작동하던 코드에서 추가로 코드를 작성했을 때 예상하지 못한 다른 동작을 방지하기 위해서 주로 사용한다. 즉, 조건이 충족되지 않으면 코드가 실행되지 않는다.

kitai = 100
in_put = 1
assert kitai == in_put, '기대한 값은 [{0}], 입력값은 [{1}]'.format(kitai,in_put)
---
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: 기대한 값은[100], 입력값은[1]

4. isinstance: 주어진 객체는 해당 클래스의 인스턴스 인가?

확인하고자 하는 데이터나 인스턴스와 확인하고자하는 데이터 타입이나 클래스를 입력으로 받는다. 사실, 파이썬의 모든 것은 객체이고 데이터 타입도 일종의 클래스이기 때문에 객체가 클래스에 담겨있는지 확인하는 것이라고 생각하면 된다.

class KimChi:
    pass

kc = KimChi()

result6 = isinstance(kc, School)
print(f' isinstance(kc, School) : {result6}')

result1 = isinstance(100, int)
print(f'isinstance(100, int) : {result1}')
-------------------------------------------------
isinstance(kc, School): False
isinstance(100, int): True

5. raw String: escape문에 영향 받지 않고 출력

\n. \t 등의 escape문에 영향을 받지 않고 문자열을 출력하고 싶을 때 사용한다.

print(r"raw string은 \n과 같은 개행문자가 실행되지 않는다.")
print("일반적으로는 \n 개행문자가 실행된다.")
-----------------------------------------------------
raw string은 \n과 같은 개행문자가 실행되지 않는다.
일반적으로는
개행문자가 실행된다.

6. Class 속성

6-1. __class__

객체 뒤에 위치하면 어떤 class의 인스턴스 인지 확인 가능

6-2. __name__

클래스 이름을 출력한다.

6-3. __doc__

해당 함수 또는 Class에 대한 설명을 출력 또는 변경할 수 있다.

class example:
    pass
print(example.__doc__)
example.__doc__ = "이것은 설명을 추가하는 것입니다."
print(example.__doc__)
----------------------------------------------
None
이것은 설명을 추가하는 것입니다.

documentation은 class시작 전 큰 따옴표 세 개로 둘러싸서 추가할 수도 있다.

6-4. __dict__

클래스 객체의 속성 정보를 확인하기 위해서 사용한다. 객체가 가진 여러가지 속성을 딕셔너리 형태로 편하게 확인할 수 있다.이를 활용하여 객체의 변수를 dict혀애로 변경할 수 있다. dictionary형태로 만들어 두면, 편하게 속성 값들을 가져올 수 있다.

class Test:
    def __init__(self, name):
        self.name = name
        self.test_dict = {'a':1, 'b':2}
        self.test_list = ['1','2','3']

test_object = Test("minimi")
print(type(test_object.__dict__)) # => <class 'dict'>

print(test_object.__dict__)
-------------------------------------------------------
{'name': 'minimi', 'test_dict': {'a': 1, 'b': 2}, 'test_list': ['1', '2', '3']}

속성 값들이 딕셔너리 형태로 저장되기 때문에 key 값으로 조회시 바로 value를 얻을 수 있다.

7. getattr: 속성 값 가져오기

해당 객체에 속해있는 속성 값을 가져온다.

class sample:
    def __init__(self,x):
        self.x = x

c = sample(1)
print(getattr(c,'x'))
-----------------------
1

보통은 c.X와 같은 방법으로 불러올 수도 있다. 하지만 클래스 안에서 선언된 이름이 다른 라이브러리의 메소드와 같아서 충돌을 일으킬 경우 앞의 방식보다 문자열로 전달하는 getattr가 유용하다.

8. str과 repr: 객체의 문자열 표현 반환

두 함수 모두 객체를 문자열로 반환하는 함수이다. 하지만 두 함수에는 약간의 차이가 있다.

a = "Life is too short"
str(a)
------------------------
'Life is too short'
------------------------
repr(a)
------------------------
"'Life is too short'"

repr은 문자열로 다시 객체를 생성하는 것이 목적이기 때문에 eval을 통해서 문자열을 다시 객체로 만들 수 있다. 자세한 설명은 다음 사이트 주소를 참조하자.

💡 위키독스 사이트 주소: https://wikidocs.net/134994

9. with assertRaise: 특정예외 발생 검증

assertRaise에 전달된 어떤 위치 또는 키워드 인자와 함께 callable이 호출되었을 때 예외가 발생하는지 테스트한다. exception이 발생하면 테스트를 통과하고, 다른 예외가 발생하면 에러이고, 아무 예외도 발생하지 않으면 실패이다. 여러 예외 모음을 잡기 위해서 예외 클래스를 포함한 튜플을 expection으로 전달해도 된다.

with self.assertRaises(SomeException) as cm:
    do_something()

위와 같은 형태로 작성하면 된다.

10. issubclass: 자식클래스의 부모클래스 확인

상속 받은 자식 클래스가 부모 클래스에 포함되는지 확인해보기 위해서 사용하는 함수이다.

class Parent:         # 부모가 될 클래스 (기반 클래스)
    pass

class Child(Parent):  # 자식 클래스 (서브 클래스)
    pass

result5 = issubclass(Child, Parent)
print(f'issubclass(Child, Parent) : {result5}')
--------------------------------------------------
issubclass(Child, Parent) : True

11. super: 부모클래스에 정의된 메소드 재정의

인스턴스 속성은 부모클래스 객체가 형성될 때 __init__ 매직 메소드가 실행되면서 생성된다. 그러나 자식 클래스 어디에도 부모 클래스의 객체가 형성된 적이 없다. 그래서 super()라는 함수를 이용하여 부모 클래스의 __init__매직 메소드를 자식 클래스에서 실행하므로 문제를 해결할 수 있다.

class Person:
    def __init__(self):
        print('Person __init__')
        self.hello = '안녕하세요.'

class Student(Person):
    def __init__(self):
        print('Student __init__')
        self.school = '파이썬 코딩 도장'

james = Student()
print(james.school)
print(james.hello)    # 부모 클래스의 속성을 출력하려고 하면 에러가 발생함
--------------------------------------------------------------
Student __init__
파이썬 코딩 도장
Traceback (most recent call last):
  File "C:\project\class_inheritance_attribute_error.py", line 14, in <module>
    print(james.hello)
AttributeError: 'Student' object has no attribute 'hello' 
--------------------------------------------------------------
class Person:
    def __init__(self):
        print('Person __init__')
        self.hello = '안녕하세요.'

class Student(Person):
    def __init__(self):
        print('Student __init__')
        super().__init__()   # super()로 기반 클래스의 __init__ 메서드 호출
        self.school = '파이썬 코딩 도장'

james = Student()
print(james.school)
print(james.hello)
-------------------------------------------------------------
Student __init__
Person __init__
파이썬 코딩 도장
안녕하세요.

부모 클래스의 hello 속성을 찾는 과정은 다음과 같은 그림의 순서로 실행된다.

12. try ~ except ~

except란 코드를 실행하는 중에 발생한 에러를 뜻한다. try~except~는 try 뒤에 오는 코드를 실행하다가 에러가 발생했을 때 에러를 출력하며 코드를 정지하는 것이 아닌 except 뒤에 오는 코드를 실행하게 된다.

try:
    x = int(input('나눌 숫자를 입력하세요: '))
    y = 10 / x
    print(y)
except:    # 예외가 발생했을 때 실행됨
    print('예외가 발생했습니다.')
------------------------------------------
나눌 숫자를 입력하세요: 0  # 입력  
예외가 발생했습니다.

3. 회고

연말은 연말인 것 같다. 약속은 많아지고 겨울 잠이 동면하듯이 내 잠도 늘어간다. 자연의 힘은 위대한 것 같다...이번 수업에서는 진짜 많은 것을 배웠다. 진짜 앞에 머신러닝보다 더 많은 것을 배우는 것 같다. 익숙하지 않은 툴과 기초에서 넘어가는 파이썬 내용이 나오니까 Section2까지는 강의 다듣고 과제 다하면 늦어도 13시 30분? 그랬는데 이제는 20시는 되어야 과제가 끝난다. 그리고 약속 있으면 잠깐 나갔다오면 12시...핑계긴 하지만 TIL이 늦어지는 이유....그래도 올해가 끝나기 전까지는 계속 이 TIL을 썼으면 좋겠다.

<12월 21일> 아직도 지난주 금요일에 쓴걸 못끝냈다. 진짜 간단히 간단히 속으로 말하는데 계속 길어진다...진짜 간단하게 해야지...

❗️ 참고자료

1. pdb 명령어
2. 객체 지향
3. getter,setter
4. property 1
5. property 2
6. __dict__