Suheeeee.Dev

[알고문풀] 프로그래머스 : 섬 연결하기

Thu, 28 Oct 2021 11:48:32 GMT

문제주소

https://programmers.co.kr/learn/courses/30/lessons/42861

문제접근 방식

도시 연결 + 그리디 👉 MST 문제 👉 Kruskal

입력된 edge를 weight를 기준으로 오름차순 정렬
두개의 배열을 초기화 한다.
visited : node의 방문여부 기록, 기록되는 값은 노드가 속하는 그룹, 0으로 초기화
answer : 선택된 edge의 weight를 기록, 빈 배열로 초기화
edge를 순회하면 아래의 조건에 따라 동작하면 배열의 값을 변경한다.
- 현재 선택된 edge에 연결된 두 node n1, n2에 대하여
  - 두 노드 다 방문 전(visited[n1] == 0 && visited[n2] == 0)이라면, 새로운 그룹을 추가하고 visited의 값을 그룹으로 할당한다. answer에 현재 edge의 weight를 추가한다.
  - 두 노드 중 하나의 노드에 방문을 했었다(visited[n1] == 0 && visited[n2] > 0, visited[n1] > 0 && visited[n2] == 0)면, 방문 전 노드의 visited 값을 방문한 노드의 그룹 값으로 할당한다. answer에 현재 edge의 weight를 추가한다.
  - 두 노드를 모두 방문했었는데 서로 같은 그룹(visited[n1] == visited[n2])이라면, 아무 동작도 하지 않는다.
  - 두 노드를 모두 방문했었는데 서로 다른 그룹(visited[n1] != visited[n2] && visited[n1] > 0 && visited[n2] > 0)이라면, n2의 그룹을 n로 병합한다. answer에 현재 node의 weight를 추가한다.
answer의 길이가 n-1에 도달하면 순회를 종료한다.
answer의 합을 반환한다.

입출력 예

n=4, costs=[[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]], return=4

Solution

Python

import numpy as np

def solution(n, costs):
    visited = np.zeros(n, dtype=int) # cycle 체크를 위한 그룹기입
    answer = [] # 선택된 간선의 weight
    g = 0 # 그룹번호

    costs_sorted =  sorted(costs, key=lambda x: x[2])

    for s, e, c in costs_sorted:
        if visited[s] == 0 and visited[e] == 0: # 둘다 방문 X
            # 그룹 추가
            g += 1
            visited[s] = g
            visited[e] = g
        elif visited[s] == visited[e]: # 같은 그룹
            continue
        elif visited[s] > 0 and visited[e] == 0: # 첫번째만 방문
            # 두번쨰가 첫번째 그룹으로 삽입
            visited[e] = visited[s]
        elif visited[s] == 0 and visited[e] > 0: # 두번째만 방문
            visited[s] = visited[e]
        else: # 서로 다른 그룹
            # 두번째가 속한 그룹을 첫번째가 속한 그룹으로 병합
            visited[visited == visited[e]] = visited[s]

        answer.append(c)
        if len(answer) == n-1: break;

    return sum(answer)

JavaScript

// minimum spanning tree
function solution(n, costs) {
  let answer = 0

  let group = []
  let visited = {}
  let cnt = 0

  costs.sort((a,b) => a[2] - b[2])

  let i = 0
  while(costs.length > i && n - 1 > cnt ){
    let isVisited0 = visited[costs[i][0]] ? true : false
    let isVisited1 = visited[costs[i][1]] ? true : false

    if(isVisited0 && isVisited1){
      // s, d visited -> group check
      let groupNum = [-1, -1]
      for(let j = 0 ; j < group.length; j++){
        if(groupNum[0] == -1)
          groupNum[0] = group[j].indexOf(costs[i][0]) > -1 ? j : -1

        if(groupNum[1] == -1)
          groupNum[1] = group[j].indexOf(costs[i][1]) > -1 ? j : -1

        if(groupNum[0] != -1 && groupNum[1] != -1)
          break;
      }

      // 1. same group -> continue
      if(groupNum[0] == groupNum[1]) {
        i++
        continue
      }

      // 2. diff group -> union group, cnt ++, answer += cost
      group[groupNum[0]] = group[groupNum[0]].concat(group[groupNum[1]])
      group.splice(groupNum[1], 1)

    }
    else if(isVisited0){
      // s visited

      // add d to visited
      visited[costs[i][1]] = true

      // add d to group
      group.some(g => {
        if(g.indexOf(costs[i][0]) > -1){
          g.push(costs[i][1])
          return true
        }
        return false
      })
    }
    else if(isVisited1){
      // d visited

      // add s to visited
      visited[costs[i][0]] = true

      // add s to group
      group.some(g => {
        if(g.indexOf(costs[i][1]) > -1){
          g.push(costs[i][0])
          return true
        }
        return false
      })
    }
    else {
      // not visited s, d

      // add s and d to visited
      visited[costs[i][0]] = true
      visited[costs[i][1]] = true

      // add new group
      group.push([costs[i][0], costs[i][1]])
    }

    answer += costs[i][2]
    i++
    cnt ++
  }

  return answer;
}

[알고문풀] 프로그래머스 : 체육복

Thu, 28 Oct 2021 10:48:32 GMT

문제주소

https://programmers.co.kr/learn/courses/30/lessons/42862

문제접근 방식

초기화 : 학생의 수 n만큼의 길이를 가지는 배열(std)을 생성하고 0으로 초기화한다.
lost를 순회하며 체육복을 도난 당한 학생의 std 값에 1을 빼준다.
reserve를 순회하며 여벌의 체육복을 가진 학생 학생의 std 값에 1을 더해준다.
std를 순회하면 값이 -1인 경우, 전후의 값에 1이 있다면, 해당 값을 -1하고 현재 값에 +1을 해준다.
std에서 그 값이 0 이상인 것의 갯수를 구한다.

✨ 학생 수가 최대 30명이라 배열을 순회하는 것에 대한 부담감이 없어 가능한 방식이다. 만약 제약조건이 달라진다면 풀이도 달려져야 할 것이다.

입출력 예

n=5, lost=[2, 4], reserve=[1, 3, 5], return=5

Solution

JavaScript

function solution(n, lost, reserve) {
    let answer = 0;

    let std = []
    for(let idx = 0; idx <= n; idx++) std.push(0)

    lost.forEach((val, idx) => { std[val]-- })
    reserve.forEach((val, idx) => { std[val]++ })
    std.forEach((val, idx) => {
        if(val >= 0) return;
        if(idx > 0 && std[idx-1] == 1){ // 이전
            std[idx]++
            std[idx-1]--
        }
        else if(idx < n-1 && std[idx+1] == 1){
            std[idx]++
            std[idx+1]--
        }
    })

    std.splice(0,1)
    answer = std.reduce((acc, cur) => cur >= 0 ? acc + 1 : acc, 0)

    return answer;
}

Python

def solution(n, lost, reserve):
    answer = 0
    std = [0]*n
    for i in lost: std[i-1] -= 1
    for i in reserve: std[i-1] += 1
    for i, e in enumerate(std):
        if e >=0 : continue
        if i > 0 and std[i-1] == 1 :
            std[i-1] -= 1
            std[i] += 1
        elif i < n-1 and std[i+1] == 1:
            std[i+1] -= 1
            std[i] += 1

    return sum([1 if e >= 0 else 0 for e in std])

if __name__ == "__main__":
    print(solution(5, [2, 4], [1, 3, 5]), 5)
    print(solution(5, [2, 4], [3]), 4)
    print(solution(3, [3], [1]), 2)

CS231N Lec.10 Recurrent Neural Networks

Mon, 06 Sep 2021 04:47:32 GMT

본 게시물은 CS231n: Convolutional Neural Networks for Visual Recognition (2017) 강의의 영상과 슬라이드를 기반을 작성 되었습니다.

Recurrent Neural Networks

📌 RNN은 가변 길이(0~N) 데이터를 입출력으로 받아들일 수 있는 네트워크 구조

유형	입력	출력	예시
One to One	단일	단일	지금까지 강의에서 다룬 아키텍쳐(Vanilla Neural network)
One to Many	고정	가변	Image captioning
Many to One	가변	단일	Sentiment Classification, Video Classification
Many to Many	가변	가변	입출력의 길이가 다른 경우 : Machine Translation 입출력의 길이가 같은 경우 : Video classification on frame level

단일 입출력 예시 : 이미지, 숫자(라벨, 확률값, …)
가변 입출력 예시 : 문장, 비디오

RNN

1. 기본 구조

1-1️⃣ 기본 동작 방식

RNN이 입력(x)을 받는다.
RNN 내부의 hidden state를 업데이트한다.
RNN 뒤의 FC Layer에서 출력값을 내보낸다.

1-2️⃣ 기본 수식

현재 시점 t에 대하여 아래와 같은 점화식(recurrence formula)로 표현된다.

x_t : 입력값
h_{t_1} : hidden state의 이전(t-1) 상태
f_W : 파라미터 W를 이용하는 함수
h_t : 현재 시점의 hidden state 이때, 함수 f와 파라미터 W는 모든 시점에서 동일하다.

Vanilla RNN

📌 가장 단순한 RNN 예시

이전 hidden state와 현재 입력을 통하여 다음 hidden state를 출력하는 기본 형식은 동일
function을 tanh 사용
- 비선형성을 위해 적용됨
- tanh를 사용하는 이유
  
  tanh의 미분값은 sigmoid에 비하여 그 결과 값의 범위가 넓은 편이기 때문에 sigmoid에 비해 vanishing gradient 문제가 생길 가능적이 상대적으로 적다.
W_{hh} : t-1 시점에서 얻어진 h_{t-1}와 곱해지는 h시점의 가중치 W_{h}, hidden 사이의 가중치
W_{xh} : t 시점에서 입력값과 곱해지는 가중치
W_{hy} : t 시점에서 hidden state와 곱해서 y_t(출력값)을 도출하는 가중치

1. Computational graph로 살펴보는 RNN

RNN이 hidden state를 가지며 이를 재귀적으로 호출하며 반영한다. 위에서 살펴본 각 경우에 어떤식으로 RNN이 전개되는지 알아보자🤔

1-1️⃣ Many to Many

h_0, 입력 x_1 ⇒ h_1 = f_W(h_0, x_1) ⇒ y_1, L_1
h_1, 입력 x_2 ⇒ h_2 = f_W(h_1, x_2) ⇒ y_2, L_2
...
h_{t-1}, 입력 x_t ⇒ h_t = f_W(h_{t-1}, x_t) ⇒ y_t, L_t
L_{total} = sum(L_1, L_2, ..., L_t)

1-2️⃣ Many to One

위와 다르게 최종 hidden state에서만 결과값이 출력된다.

1-3️⃣ Many to One

고정 입력 x는 모델의 initial hidden state를 초기화 시키는데 사용된다.

1-4️⃣ Sequence to Sequence

(Many to one) + (One to many)

Many to one : Encoder, 가변입력을 받아 하나의 벡터로 요약한다.
One to many : Decoder, Encoder에서 요약된 정보를 입력으로 받아 가변 출력을 반환한다.
decoder의 output을 이용하여 loss를 계산하고 backpropagation을 진행한다.

2. 구체적 예시로 살펴보는 RNN : 언어모델

언어모델
- 강의 : 어떻게 자연어를 만들어낼지를 해결하려는 모델
- 통계기반의 확률모델, 단어 시퀀스 이후에 이후에 어떤 단어가 등장할 확률을 통해서 문장을 생성한다.

📌 Character-level Language Model

“hello” 학습시키기

사용하는 4개의 알파벳을 원-핫 인코딩을 통하여 벡터화하여 단어사전에 저장
train : ground truth와 ouput를 이용하여 Loss 계산
test
- h를 초기에 입력 → 출력 e를 얻음 → e를 입력 → 출력 l를 얻음 → l를 입력 → 출력 l를 얻음 → l를 입력 → 출력 o를 얻음 ⇒ h를 입력하여 hello를 얻음
- 흥미로운 점 : 마지막 시퀀스에서 “l”의 확률이 가장 높은데 “o”가 출력되었다. 👉 출력부에서 softmax로 확률을 도출하고 이들 중 가장 큰 값을 출력하는 것이 아닌 sampling을 통하여 값을 선택하기 때문이다. 👉 모델의 다양성을 높여 적절한 output을 얻게한다.

3. Backpropagation

Backpropagation through time
- 이전에 살펴보았던 모델들을 생각해보면 스텝마다 출력값이 존재하고 이 출력값들의 Loss를 계산하고 이를 조합하여 Final loss를 얻는다. 그리고 해당 값을 이용하여 역전파를 진행한다.
- RNN에서 만약 아주 긴 문서를 학습한다고 가정하였을 때, 이 작업은 매우 많은 메모리를 요구하게 된다.

Truncated Backpropagation through time
- 대체 근사 알고리즘
- Train time에서 전체 스퀀스를 적당한 step 단위로 잘라 해당 step이 지난 후 step만큼의 서브스퀀스 단위로 Loss를 계산하고 gradient를 계산한다.
- 이전 강의에서 mini batch를 이용하여 gradient를 계산했던 것과 유사한 아이디어

4. 예시

4-1️⃣ Example: Character generation

셰익스피어 작품을 학습시킨 문장 생성기
LaTex 코드를 포함한 위상 수학책을 학습시킨 문장 생성기
c언어 코드를 학습시킨 문장 생성기

4-2️⃣ Example: Interpretability

RNN에서 스퀀스 데이터를 학습이 되기는 하는데, 데이터에서 “무엇을” 학습하는지는 어떻게 알 수 있을까?
데이터를 특정 dataset으로 학습시킨후 hidden vector를 뽑아 어떤 값들이 들어있는지 살펴본다 👉 서로 다른 hidden states가 어떤 것들을 예의주시하는지 알 수 있을지도..?

색 : 시퀀스를 읽는 동안에 앞서 뽑은 hidden vector의 값
대부분의 hidden state는 아무 의미 없는 패턴으로 문장을 살펴보고 있다.
따옴표를 기준으로 패턴을 인식 👉 "를 추적
줄의 단어 갯수를 세는 것 같은 패턴도 존재 👉 \n을 추적
if 문 안에서 조건문 부분을 추적

👉 dataset을 학습시켰을 뿐인데 많은 것들을 찾아내고 있는 것을 확인할 수 있다.

4-3️⃣ Example: Image captioning

주어진 이미지에 대한 설명문을 출력하는 task
CNN에서 요약된 이미지 정보가 들어있는 vector(feature map)을 RNN의 초기 입력으로 사용
기존 Vanilla RNN 식에서 CNN의 출력 벡터에 새로운 가중치(W_ih)를 곱하여 더한다.

학습결과 어떤 경우에는 작 잘동하지만, 어떤 경우에는 그렇지 않음을 볼 수 있다.

✨ Image Captioning with Attention

CNN에서 하나의 벡터가 아닌 각 벡터의 공간정보를 가지고 있는 grid of vector를 만든다.
z : 모델이 이미지에서 보고 싶은 위치에 대한 분포 👉 모델이 어느 위치를 봐야하는지에 대한 attention
h0이 이미지의 위치에 대한 분포(a1)를 계산하고, 이 분포를 다시 벡터집합(LXD)와 연산하여 이미지 attention (z1)을 생성한다.
이 요약된 벡터는 다름 입력으로 들어간다. 결과로는 vocabulary의 각 단어들의 분포(d1), 그리고 다른 하나 (a2)는 이미지 위치에 대한 분포이다.
이것은 결국 feature map에 위치정보를 더하여 RNN이 해당 시간에 어떤 부분을 보아야 하지는를 떼어서 제공해 주는 역할을 한다고도 볼 수 있다.

문장 생성시 위의 그림에서처럼 이미지내에 여러 부분에 attention을 주는 것을 볼 수 있다.
Soft attention : 이미지의 모든 특징과 이미지 위치간의 가중합을 구해서 attention을 결정 👉 전체를 보는 대신 어떤 부분은 좀 힘을 줘서 본다.
Hard attention : 이미지의 위치를 한 번에 단 한곳만을 본다.

4-4️⃣ Example: Visual Question Answering

이미지와 질문을 입력받아 질문에 대한 답이 출력
CNN + RNN + Attention
- CNN을 통히여 이미지를 요약하고 RNN을 통하여 질문을 요약한다.
- 두 모델에서 나온 벡터를 조합하여 질문의 답변에 대한 분포를 예측하여 답변을 출력한다.
- 이 과정에선 attention을 사용하기도 한다.

RNN variants

1. Vanilla RNN의 문제점

backward pass시에 계속적으로 W Transpose가 관여하게 된다.

이 경우, 곱해지는 값이 1보다 크거나 1보다 작을 경우 각각 exploding과 vanishing의 문제가 발생하게 된다. exploding은 gradient clipping(gradient 의 L2 norm 이 기준값을 초과할 경우 threshold/L2 norm 을 곱하여 정규화)을 통하여 제어가 가능하나, vanishing은 결국 gradient vanishing을 야기한다.
RNN은 뒤로갈수록 앞의 내용를 잊게 되고 이런 문제를 장기 의존성 문제라고 한다.

2. Long Short Term Memory (LSTM)

2-1️⃣ 순전파

RNN에서의 장기 의존성 문제를 해결하기 위하여 gate를 도입
LST는 두개의 state(C_t : Cell state, h_t : Hidden state)를 유지하며 hidden state와 입력값(x)의 결과를 4개의 게이트(i, f, o, g)통과시켜 출력한다.

게이트	연산	의미
i(input gate)	sigmoid	현재 정보를 저장할지 결정
f(forget gate)	sigmoid	과거 정보를 버릴지 말지 결정
o(output gate)	sigomoid	cell state 를 얼마나 밖으로 출력할 것이냐를 결정
g(gate gate)	tanh	input을 얼마나 포함시킬 것인가를 결정

forget gate - C_{t_1}
- forget gate가 0~1 사이의 값을 가지며 C_{t_1}와 곱해진다.
- cell state를 다음 단계로 가지고 갈 것은가를 결정
input gate - gate gate
- gate gate는 -1~1 사이의 값을 가지고, input gate는 0~1 사이의 값을 가진다.
- gate gate는 방향(값을 빼고 싶은가 더하고 싶은가), input은 양(얼마나 뻬거나 더하고 싶은가)를 결정
- cell state의 어떤 값을 얼마나 쓰고 싶은가를 결정
output gate - tanh(C_t)
- t 시점에서의 cell state를 얼마나 hidden state로 넘겨 줄 것인가

2-2️⃣ 역전파

역전파시 Cell state는 정보를 잃지 않으면서 grdient 값을 구할 수 있다.
- C_t는 역전파 되면서 sum gate와 element wise gate만을 만난다.
- non-linearity에 의한 문제가 없다.
여러개의 cell을 연결하더라고 역전파 경로에 방해되는 것은 없다.
- gradient vanishing 문제를 해결

3. Other RNN Variants

GRU(Gated Recurrent Unit)
- Vanishing gradient 문제를 회피하기 위해 element-wise를 사용
LSTM: A Search Space Odyssey
- LSTM의 수식/모델을 변형시키며 실험을 진행
- 결론 : 전부 비슷하다
An Empirical Exploration of Recurrent Network Architectures
- 아주 많은 임의의 RNN 아키텍쳐를 실험
- GRU와 LSTM 보다 엄청나게 좋은 모델을 찾아내지는 못함

SUMMARY

RNN은 모델 설계에 있어서 유연성을 제공하고 많은 시도를 할 수 있게 해준다.
Vanilla RNN은 잘 작동하지 않는다.
대체로 LSTM이나 GRU를 사용한다.
RNN에서는 기울기가 exploding 또는 vanishing 될 수 있다.
- exploding - gradient clipping
- vanishing - LSTM

REF

CS231N Lec.02 Image Classification

Sun, 11 Jul 2021 15:47:32 GMT

본 게시물은 CS231n: Convolutional Neural Networks for Visual Recognition (2017) 강의의 영상과 슬라이드를 기반을 작성 되었습니다.

Image Classification

컴퓨터 비전 분야에서의 core task이자 CS231n에서 주로 다루기도하는 문제

Image Classification은 어떻게 이루어 지는가?

이미지를 입력받는다.
정해진 카테고리 집합에서 컴퓨터가 이미지를 보고 어디에 속할지를 고른다.

👉 인간에게는 쉽지만 컴퓨터에게는 매우 어렵다.
👉 컴퓨터에게 이미지 == 거대한 숫자판
👉 Semantic Gap : 컴퓨터가 실제로 보고 있는 숫자판과, 고양이라고 하는 의미 사이에 존재하는 간극

Image Classification은 컴퓨터에게 어렵다!

viewpoint variation
이미지에 미묘한 변화만 주더라고 픽셀 값이 광범위하게 변화한다.
예를들어 고양이가 가만히 있더라도 카메라의 이동에 따라 픽셀값이 달라진다.
조명 illumination
변형 deformation
가려짐 occlusion
배경과의 유사함 Background Clutter
클래스내의 다양성 Intraclass Variation

이런 것들을 모두 고려하였을 때, 컴퓨터가 이미지의 의미를 알아챈다는 것은 매우 어려워 보인다.
👉 일부 제한된 상황이라면 잘 동작하는 기술이 존재한다!
👉 앞으로의 강의에서는 이것이 어떻게 가능해졌는지 볼 것이다.

이전까지 이미지를 인식하기 위해 해왔던 시도

😺 고양이 인식하기

이미지에서 edgds를 계산, 다양한 corners와 edges를 각 카테고리(귀, 코, …)로 분류
이들로부터 고양이라는 특징(귀가 두 개 코가 하나 등 고양이를 인식하기 위한 규칙)을 찾아낸다.

이러한 방식은 잘 동작하지 않는다.

위에서 언급했던 문제들에 대해 강건하지 못하고
인식하고자 하는 새로운 객체가 등장하면 처음부터 모든 동작을 반복해 한다.

👉 다양한 객체들에 유연하게 적용가능한 알고리즘 필요
👉 ML key insight : Data-Driven Approach가 등장하게 됨

Data-Driven Approach

카테고리에 대한 규칙을 정하는 것이 아니라..!

카테고리에 해당하는 엄청 많이 데이터를 수집하고
데이터들을 이용하여 ML classifier(=model) 학습
학습된 classifier를 새로운 이미지로 테스트한다.

def train(images, labels):
  # Maching learning !
  return model

def predict(model, test_images):
  # Use model to predict labels
  return test_labels

🌟 지금부터 할 것 : 간단한 ML classifier부터 살펴보기

Nearest Neighbor

def train(images, labels):
  # Memorize all data and labels
  return model

def predict(model, test_images):
  # Predict the label of the most similar training image
  return test_labels

Train 단계 : 모든 데이터와 라벨을 기억
Predict 단계 : 새로운 이미지와 기존 이미지(학습에 사용된 이미지)를 비교하여 가장 유사한 학습 이미지의 라벨을 반환

예시로 보는 Nearest Neighbor의 동작(feat. CIFAR-10)

CIFAR-10은 10개의 클래스(비행기, 자동차, 새, …)로 분류되는 50000장의 학습용 이미지와 10000장의 테스트 이미지로 구성되어 있다.

오른편의 그림은 Nearest Neighbor를 이용하여 예측을 진행한 결과이다. 그림의 왼쪽열이 테스트 이미지이고 오른쪽 방향으로 학습 이미지를 테스트 이미지와 유사한 순으로 정렬한 것이다. 2번째 줄의 2번째까지는 테스트 이미지의 카테고리과 같은 개를 유사한 이미지로 출력하지만 그 이후로는 사슴 혹은 말과 같은 다른 카테고리의 요소들을 출력하고 있다.
👉 Nearest Neighbor 알고리즘 적용시 학습 데이터셋에서 가장 가까운 샘플을 찾아냄
👉 이게 성능면에서는 좋지 않지만, 지금 단계에서 예시로 보기에는 가치가 있다.

Nearest Neighbor 주요 안점

두 이미지 쌍을 어떻게 비교할 것인가?
비교를 위하여 어떤 비교함수를 사용할 것인가?

앞의 예제 L1 Distrance(Manhattan distance, 이하 L1 Dist)를 사용하였다.

이는 두 이미지에서 같은 픽셀 위치에 있는 값끼리 뺀 후 절대값을 취하고 이후 모든 픽셀에 대한 수행결과를 더하는 것으로 계산된다. 단순한 동작이지만 두 이미지간의 차이를 어떻게 측정할 것인가?에 대한 구체적 답변이 된다.

Nearest Neighbord의 한계점

예측 시간

N개의 training set이 존재할 때, Nearest Neighbor의 Train/Predict 함수의 속도는 어떻게 될까?

Train O(1) : 단순 저장
Predict O(N) : N개의 학습 이미지와 입력 이미지를 모두 비교해야하기 때문, 느림

모바일 혹은 브라우저 또는 다른 저전력 장치에서 실행되는 실제 서비스에서는 학습시간은 상대적으로 오래 걸려도 괜찮으나 예측 시간(test/prediction time)이 빠르기를 원한다. 하지만, Nearest Neighbor는 그 수요와 정반대로 동작한다.

분류 성능의 한계

Nearest Neighbor이 실제로 동작한 결과는 아래와 같은 결정 영역(decision regions)으로 그려낼 수 있다.

결정 영역에서 각 점은 학습 데이터이고 점의 색은 클래스(label)이 된다. 이 결정 영역의 색은 평면의 각 픽셀에 대해 훈련 데이터에서 가장 가까운 점을 찾아 해당 점의 클래스 레이블로 칠한 것이다. 이 경우 두가지 문제를 존재한다.

초록색 영역 한 가운데에 노란색 섬이 존재.
초록색 영역이 파란색 영역을 침범

이는 특정한 노란색 점 혹은 초록색 점이 잡음(noise)이거나 잘못된 정보(spurioius)인 경우 발생할 수 있다. 이를 통하여 Nearest Neighbor는 여러 상황에 대하여 충분히 강건하지 못하다 말할 수 있다.

K-Nearest Neighbors(KNN)

위에서 언급된 Nearest Neighbor의 문제점을 해결하고자 KNN이 등장하게 된다. 이는 Distance metric를 이용하여 가까운 이웃을 K개만큼 찾고 이웃끼리 투표(voting)를 하여 가장 많은 득표수를 올린 레이블로 예측하는 방식이다.

+) 추가 : 투표 결과의 결정방식에도 다양한 방법이 존재하고 위에 언급된 가장 많은 득표수를 올린 레디블을 선택하는 방식을 Majority voting이라 한다.

K

KNN에서 사용자가 선택하게 되는 값으로 투표에 참여할 이웃의 수를 의미한다.

대체로 K가 1보다 클때 결정경계가 부드러워지고 좋은 결과를 보이고 있다.

K가 1보다 클 때, 라벨이 결정되지 못한 흰색영역이 등장하는데 이는 투표 결과에서 승자를 확정할 수 없는 지역을 의미한다. 이 부분을 추론 혹은 랜덤으로 값을 채울 수도 있지만, 현재는 간단한 예제를 보는 것이 목적이기 때문에 흰색으로 칠해 두었다.

Distance Metric

KNN에서 사용자가 선택하게 되는 또 다른 값으로 서로 다른 점들을 어떻게 비교할 것인가에 대한 방법이다.

이전까지의 예제에서는 L1 Dist로 픽셀간 차이의 절대값의 합을 구하였다. 이번에 추가로 소개할 방법은 L2 Distance(Euclidean Distance, 이하 L2 Dist)로 두 거리의 차의 제곱합의 제곱근을 계산하는 것으로 구할 수 있다.

위의 그림은 그래프는 원점에서 떨어져 있는 거리가 같은 점들을 모아 놓은 것이다. 강의에서는 거리 척도(L1, L2)에 따라 공간의 근본적인 기하하적 구조 자체가 서로 다르게 된다고 표현하고 있다.

L1 Dist은 좌표계에 영향을 받는다.
- 어떤 벡터가 있고 각 요소가 어떤 특별한 의미를 가질 때 더 유용할 수도 있다. 즉, 특정 벡터의 각각 요소들이 개별적인 의미를 가진다면(키/몸무게) L1 Dist가 더 유용할 수도 있다.
그렇지 않고 각 요소간의 실직적인 의미를 잘 모르는 경우에는 L2가 더 유용할 수도 있다.
Problem-dependent 문제 의존적인 부분이기에 실제로 실험을 해보지 않는 이상 어떤것도 확신할 수는 없다.

위 그림에서는 거리 척도에 따라 발생하는 기하하적 변화를 확인 가능하다. 경계의 모양이 L1 Dist일 때, L2 Dist일 때가 서로 다른 것을 볼 수 있다. L1은 좌표축의 영향을 받기 때문에 경계가 수직 혹은 수평에 가깝다. L2는 축의 영향을 받지 않기 때문에 더 자연스럽게 결정경계가 만들어진다.

다양한 거리척도를 이용하면 KNN으로 다양한 데이터를 다룰 수 있다. 벡터/이미지/문장 등 데이터 사이에 거리를 구할 수 있는 척도가 존재한다면 KNN 적용이 모두 가능하다. 추가로 KNN은 아주 단순한 알고리즘이어서 새로운 문제를 접했을 때 가장 먼저 간단히 시도해볼만하다.

하이퍼 파라미터

이전 파트에서 다룬 K와 L1/L2 Dist와 같이 Train time에 학습되는 것이 아닌 학습전에 사용자가 선택하게 되는 값들을 하이퍼 파라미터라고 한다.

어떻게 구할까?
다양한 하이퍼 파라미터 값을 시도해보고 가장 좋은 값을 찾는다.
다양한 하이퍼 파라미터를 시도해 보는 것과 가장 좋은 값을 선택하는 것 은 어떻게 해야 할까? 강의에서는 4가지 아이디어를 제시하고 있다.

전체 데이터셋에 대하여 분류기의 정확도와 성능을 가장 높게 만들어 주는 값을 탐색
- 끔찍한 방법🤒
- K=1이 가장 정확하게 training data를 분류하며, K가 1보다 클 때는 학습 데이터 중 몇 개를 잘못 분류할 수 있다. 하지만 학습데이터에 포함되어 있지 않았던 데이터에 대해서는 후자가 더 좋은 성능을 보일 수 있다.
- ML에서는 학습데이터를 얼마나 잘 맞추는지는 중요하지 않고, 학습시킨 분류기가 처음 보는 데이터를 얼마나 잘 분류해내냐가 중요하다.
전체를 쪼개어 일부를 테스트 데이터로 사용한다.
- 학습 데이터를 사용하며 다양한 하이퍼 파라미터를 교체해가며 분류기를 학습시키고 테스트 데이터로 성능을 평가한다. 실험결과 테스트 데이터에서의 성능과 지표가 가장 좋은 하이퍼 파라미터를 선택한다.
- 끔찍한 방법 2🤒
- ML에서는 처음 보는 데이터를 얼마나 잘 맞추냐가 중요한데 이 경우는 테스트 데이터를 얼마나 잘 맞추냐를 기준으로 하이퍼 파라미터가 선택되었다.
- 테스트셋이 처음보는 데이터를 대표하지 못하게 되었다.
일반적인 방법 : 세개로 나눈다. trainig, validation, test
- 학습 데이터를 사용하며 다양한 하이퍼 파라미터를 교체해가며 분류기를 학습시키고 검증 데이터(validation)로 성능을 평가한다. 실험결과 validation 데이터에서의 성능과 지표가 가장 좋은 하이퍼 파라미터를 선택한다.
- 모든 것이 확정되고 난 후, 테스트 데이터로 “단 한번”의 검증을 수행한다. 테스트 데이터가 처음보는 데이터의 대표가 되며 이 값이 논문이나 보고서에 들어가는 값이 된다.
교차 검증
- 데이터셋이 작을 때 사용한다.
- 딥러닝에서는 많이 사용하지 않는다 → 큰 모델을 학습시킬때는 학습 자체가 계산량이 많아 이런 부가적인 연산이 필요한 작업을 거의 사용하지 않는다.
- 테스트 데이터를 따로 빼고 나머지 데이터를 여러 부분으로 쪼갠다.
- 쪼개진 부분을 번갈아가면서 validation set으로 사용

K의 변화에 따른 정확도 변화

x축 K, y축 분류 정확도를 의미한다.
이 그래프로 알 수 있는 것
- K에 따른 분류 정확도 변화
- 하이퍼 파라미터별 validation folds 별 성능 분산
이 그래프가 주어졌을 때, validaiton set 성능이 최대인 하이퍼 파라미터를 선택하게 된다.

KNN은 이미지 분류에 잘 사용되지 않는다

이유 1. test time이 너무 느리다.

이유 2. L1/L2 Dist가 이미지간의 거리 측정에 적절하지 않다.

기존 이미지에 세가지 왜곡을 주었을 때, 왜곡된 이미지와 원본 사이의 L2 Dist는 모두 동일(저스틴이 L2가 같도록 섬세하게 생성함)
L2 Dist는 perceptual distances를 측정하는데 적합하지 않다.

이유 3. 차원의 저주

KNN이 하는일 → 학습 데이터의 공간을 분할하는 것
KNN이 잘 동작하려면 공간을 분류하기에 충분할 만큼 조밀한 학습 데이터가 필요하다.
공간을 조밀하게 덮을려면 충분한 양의 학습 데이터 필요하며 차원이 증가함에 따라 더 많은 양의 데이터가 필요하게 된다. 고화질의 이미지일 수록 모든 공간을 매울만큼의 데이터를 구하기란 쉽지 않다.
추가 자료 : http://thesciencelife.com/archives/1001

👏 Summary 이미지 분류가 무엇인지 설명하기 위해 KNN을 예제로 들어보았다!

Linear Classification

간단하지만 아주 중요하며 neural networks(이하 NN)과 convolutional neural networks(이하 CNN)의 기반이 된다.
NN는 레고 블럭처럼 여러 구성요소(component)를 끼워 맞춰 거대한 네트워크를 구성하는 것이라 볼 수 있다.
이때 기본이 되는 NN이 Linear Classifiation이라 할 수 있다. 이것을 이해함으로써 전체 NN이 어떤식으로 작동하는지 이해할 수 있을 것이다.

Parametric Approach(feat. CIFAR-10)

Linear classification은 Parametric Model의 가장 단순한 형태이다.

Parametric Model(x, W) => y
- x : 입력값
- W : 가중치
- y : CIFAR-10의 각 10개의 클래스 점수, 점수가 높을 수록 해당 클래스일 확률이 높다는 것을 의미
파라미터 등장! 학습 데이터의 정보를 요약하여 파라미터에 모아둔다.
- test time에 training data가 더 이상 필요없어져 속도가 증가한다.
- 딥러닝은 함수 f 의 구조를 적절하게 잘 설계하는 것이 주요 task라 볼 수 있다.
- 어떤 식으로 가중치와 데이터를 조합할 것인가를 고민하는 과정이 다양한 NN 아키텍쳐를 설계하는 과정이 될 것이다.
- 가장 쉬운 방법 : 가중치와 데이터를 그냥 곱하는 것 → Linear classifier

f(x, W) = Wx
- 입력 이미지 32x32x3 → 평탄화 : 3072x1 dim → 10-class score
- (10x3072) * (3072x1) = (10x1) → W의 shape는 (10x3072)가 되어야 한다.
bias
- class수과 같은 1차원 벡터
- 데이터와 무관하게 특정 클래스에 우선권을 부가한다. 학습 이미지에 불균형이 있는 상황 등에 유용할 것이다.
계산 예시
- (0.2 × 56)+(-0.5 x 231)+(0.1 × 24)+(2 × 2)+1.1 = -96.8
linear classifier는 각 클래스를 구분시켜 주는 선형의 경계를 그어주는 역할

linear classification이 직면할 수 있는 문제

다양한 사례들이지만 결국 선분 하나로 데이터를 분류할 수 없다는 문제로 정리도니다.

summary

linear classifier의 수식 → 단순 행렬과 벡터의 곱
가중치 행렬 w를 학습시키고 나면 새로운 학습 데이터에도 스코어를 매길 수 있다.
W를 어떻게 구할 수 있는지는 배우지는 않았다. → 다음 언제가에 계속..

pg-promise basic usage

Sun, 21 Mar 2021 16:26:32 GMT

ref. v 9.3.3
https://www.npmjs.com/package/pg-promise
http://vitaly-t.github.io/pg-promise/
https://github.com/vitaly-t/pg-promise/wiki

기본 사용법 + 쓸 거 같은 기능 정리 + 예시

init

const pgp = require('pg-promise')({
  promiseLib: promise
  // Overrides the default (ES6 Promise) promise library for its internal use.
);

// Database connection details
// more details : https://github.com/vitaly-t/pg-promise/wiki/Connection-Syntax
const cn = {
  host: 'localhost', 
  port: 5432,
  database: 'products',
  user: 'user-name',    
  password: 'user-password'
};

const db = pgp(cn);
// const db = pgp('postgres://john:pass123@localhost:5432/products'

Database function for running query

http://vitaly-t.github.io/pg-promise/Database.html

any

0 이상의 결과(row)를 반환하는 쿼리

db.any('SELECT * FROM users')
  .then(function(data){
    console.log('>>>>', data);
    //[ { name : "aaa", email : "aaa@email.address" }, 
    //  { name : "bbb", email : "bbb@email.address" }, ... ]
  })
  .catch(function(e){
    console.log('>>>>', e);
  });

each

any의 결과로 얻은 각 row에 대해 함수를 실행 → (rows). forEach()

let index = 1;
db.each('SELECT * FROM users', [], row => {
  row.name = row.name + index++;
 })
 .then(data => {
   console.log(data);
   // [{ name : "aaa1", ... }, { name : "bbb2", ... }, ... ]
 })
 .catch(error => {
   console.log(error);
 });

func

SELECT * FROM funcName(values)

// function defined in postgresql
create or replace function foo()
returns Date as $cur$
  begin
    return now();
  end;
$cur$ language plpgsql;

// node
db.func('foo', [])
  .then(data => {
    console.log(data);
    // [ { "foo": "2019-10-03T15:00:00.000Z" } ]
  })
  .catch(error => {
    console.log(error);
  })

map

Creates a new array with the results of calling a provided function on every element in ther array of rows resolved by method any.라고 명시되어 then의 parm이 map 내부 return 값들의 배열이 되기를 기대하였으나, any의 결과를 return 한다.
api 문서와 다른 예시를 보았을 때 단독 사용보다는 task/tx와 함께 사용되는 것 같다.

http://vitaly-t.github.io/pg-promise/Database.html#map/ https://codeday.me/ko/qa/20190406/259937.html

db.each('SELECT * FROM users', [], row => return row.name )
  .then(data => {
    console.log(data);
    // expect
    //    [ "aaa", "bbb", ... ]
    // result
    //    [ { name : "aaa", email : "aaa@email.address" }, 
    //      { name : "bbb", email : "bbb@email.address" }, ... ]
  })
  .catch(error => {
    console.log(error);
  });

multi

return data를 가지도 별다른 행위를 하지 않는 복수의 쿼리를 실행하며, 쿼리들의 수행 결과들의 배열을 반환한다. BEGIN/COMMIT를 사용하지 않는 이상 쿼리들은 단일 트랜젝션으로 수행된다.

db.multi('SELECT * FROM users;SELECT * FROM class')
  .then(([users, class]) => {
    console.log('>>>>> users');
    console.log(users);
    console.log('>>>>> class');
    console.log(class);
    // >>>>> users
    // [ { name : "aaa", email : "aaa@email.address" }, 
    //   { name : "bbb", email : "bbb@email.address" }, ... ]
    // >>>>> class
    // [ { name : "c1", room : "1" }, 
    //   { name : "c2", room : "2" }, ... ]
  })
  .catch(error => {
    // error
  });

none

return 되는 데이터가 존재하지 않는 쿼리. return이 존재한다면 reject 된다.

db.none("UPDATE users SET last_locations=$1 WHERE email=$2", [value, email])
  .then(function(){
    console.log('>>>> success');
  })
  .catch(function(e){
    console.log('>>>>', e);
  });

one

단 하나의 row를 return 하는 쿼리. return이 0 또는 2 이상이면 reject 된다.

db.one('SELECT count(*) FROM Users', [], c => c.count)
  .then(count => {
    console.log(count); // integer
   });

query

query(query, values, qrm), qrm(Query Result Mask)의 입력값 형태의 리턴을 가지는 쿼리를 실행.

db.query('SELECT name FROM Users where name=\'xxx\'', [], pgp.queryResult.one + pgp.queryResult.none)
  .then(data => {
    console.log(data)
  })
  .catch(error => {
    console.log(error)
  });

result

return data에 대한 어떠한 기댓값이 없는 쿼리. 성공 시 Result를 결과값으로 가진다.

db.result('DELETE FROM users WHERE name=\'kkk\'')
  .then(data => {
    console.log(data);
  });
// Result {
//   command: 'DELETE',
//   rowCount: 1,
//   oid: null,
//   rows: [],
//   fields: [],
//   _parsers: [],
//   _types:
//   TypeOverrides {
//     _types:
//     { getTypeParser: [Function: getTypeParser],
//       setTypeParser: [Function: setTypeParser],
//       arrayParser: [Object],
//       builtins: [Object] },
//     text: {},
//     binary: {} },
//   RowCtor: null,
//   rowAsArray: false,
//   duration: 5 }

task

Executes a callback function with automatically managed connection.

db.task(t => {
    return t.map('SELECT email FROM congress_participants WHERE congress_id=\'C1\' and role = \'visitor\'', [], row => row.email)
            .then(rows => {
              let str =  '(\'' + rows.join('\', \'') + '\')';
              return t.any('SELECT * from users where email IN ' + str)
            });
  })
  .then(data => {
      console.log(data);
  })
  .catch(error => {
    console.log(error);
  })

tx

Executes a callback function as a transaction, with automatically managed connection.

it executes BEGIN just before invoking the callback function
it executes COMMIT, if the callback didn’t throw any error or return a rejected promise
it executes ROLLBACK, if the callback did throw an error or return a rejected promise

db.tx(t => {
  return t.one('INSERT INTO users(email, name) VALUES($1, $2) RETURNING email', ['nnn@email.address', 'nnn'])
          .then(email => {
            return t.
          })

        return t.one('INSERT INTO Users(name, age) VALUES($1, $2) RETURNING id', ['Mike', 25])
            .then(user => {
                return t.none('INSERT INTO congress_participants(email, congress_id, role) VALUES($1, $2, $3)', [user.eamil, 'C1', 'visitor'])
            });
    })
    .then(function(){
      console.log('>>>> success');
    })
    .catch(function(e){
      console.log('>>>>', e);
    });

QueryResultError

함수가 reject 될 시 발생하는 에러. api 문서에서 각 함수의 하단부에 어떤 값으로 리턴될지 명시되어 있다.
http://vitaly-t.github.io/pg-promise/errors.QueryResultError.html

db.one('SELECT name FROM Users where name=\'xxx\'', [], c => +c.count)
  .then(count => {})
  .catch(error => { console.log(error); });
  
// QueryResultError {
//    code: queryResultErrorCode.noData
//    message: "No data returned from the query."
//    received: 0
//    query: "SELECT name FROM Users where name='xxx'"
// }

return 되는 row에 따른 함수 정리

function	expects number of rows(n)
any(=manyOrNone)	0 or more
none	0
one	1
oneOrNone	1 or null(none)
many	1 or more

Helpers

update

update(data, columns, table, options), 하나 혹은 배열 객체에 대한 UPDATE 쿼리를 생성한다.

const data_single = { email: 'aaa@email.address', last_location: 'S1'};
pgp.helpers.update(data_single, ['last_location'], 'users') + ' WHERE email = ' + data_single.email;
// UPDATE 'data_single' SET 'last_location' = 'S1' WHERE email = 'aaa@email.address'

const data_multi = [{ email: 'aaa@email.address', last_location: 'S1'},
			        { email: 'bbb@email.address', last_location: 'S2'}]
pgp.helpers.update(data, ['?email', 'last_location'], 'users') + ' WHERE v.email = t.email';
// UPDATE 'data_multi' AS t SET 'last_location' = v.'last_location' 
//   FROM (VALUES('aaa@email.address','S1'),('bbb@email.address','S2'))
//   AS v('email', 'last_location')
//   WHERE v.email = t.email

values

values(data, columns), 쿼리에서 사용할 수 있는 쉼표로 구분된 문자열을 생성한다.

const dataSingle = {val: 123, msg: 'hello'};
const dataMulti = [{val: 123, msg: 'hello'}, {val: 456, msg: 'world!'}];

pgp.helpers.values(dataSingle);
//(123,'hello')

pgp.helpers.values(dataMulti, ['val', 'msg']);
//(123,'hello'),(456,'world!')