import numpy as np

N = int(input('크기를 입력하세요:'))
a = np.random.randint(1000, size=N)

# 버블정렬을 할 때 loop 횟수가 비교적 적은 것
def bubble_sort(data) :
    # loop = 0
    while 1 :
        count = 0
        for i in range(len(data)-1) :
            if data[i] > data[i+1] :
                temp = 0
                temp = data[i]
                data[i] = data[i+1]
                data[i+1] = temp
            else :
                count += 1
        # loop+=1
        if count == len(data)-1 :
            break
        
    return data # , loop

print(bubble_sort(a))

##########################################################

# 위와 비교했을 때 비교적 loop 횟수가 많은 것
def bubble_sort_ez(data) :
    # loop = 0
    for j in range(len(data)) :
        for i in range(len(data)-1) :
            if data[i] > data[i+1] :
                temp = 0
                temp = data[i]
                data[i] = data[i+1]
                data[i+1] = temp
        # loop += 1
    return data # , loop

print(bubble_sort_ez(a))

###########################################################

# 재귀함수로 풀이
a = [1,4,3,2,5,8,7,10]

def bubble_sort(data) :

    count = 0
    
    for i in range(len(data)-1) :
        if data[i] > data[i+1] :
            temp = data[i]
            data[i] = data[i+1]
            data[i+1] = temp
            count += 1
            
    if count == 0 :
        return data
        
    return bubble_sort(data)

bubble_sort(a)

###########################################################

# 찐또배기 재귀함수
a=[5,4,3,2,1,8,7,10]

def recur_bubble(a,i=1,b=[]):
    if i==len(a)-1: # 최대 범위 도달 시 다시 처음으로
        b.insert(0,a.pop())
        recur_bubble(a,1,b)    

    else:           
        if len(a)==1: # 길이가 1이면 정렬 완료
            print('정렬 완료')
            b.insert(0,a.pop())
            print(b)
            return b

        elif a[i-1]>a[i]:   # 길이가 1이 아니고, 순서가 다르면 
            a.insert(i-1,a.pop(i))
            recur_bubble(a,i+1,b)          

        else:               # 길이가 1이 아니고 , 순서가 맞으면
            recur_bubble(a,i+1,b)

recur_bubble(a)

 

while 문으로 풀려고 고생했는데 고생해봤자였다. 어차피 데이터가 10000개 이상이 되면 둘 다 더럽게 느리다!

버블 정렬 너무 구식이야.. ㅠ

 

 

 

 

 

 

 

 

# numpy.median 사용 / 슬라이싱, del 사용
import numpy as np

# 찾고자 하는 숫자가 있는 리스트 생성
a = [1,7,11,12,14,23,33,47,51,64,67,77,139,672,871]

# 리스트야! 내 숫자 담고 있늬? / binary함수야! 얼마나 빨리 찾길래 내가 널 손수 만들어야하늬?
def binary(list_data,find_num,count=0) :
    if np.median(list_data) < find_num : # 47 < 67
        count += 1
        del list_data[:list_data.index(np.median(list_data))+1]
    elif np.median(list_data) > find_num :
        count += 1
        del list_data[list_data.index(np.median(list_data)):]
    elif np.median(list_data) == find_num :
        return count, list_data
    else :
        return "없다 이놈아"
    return binary(list_data,find_num,count)
        
binary(a,67)


##########################################################################################

# 원래의 데이터 손상없는 ver.
import numpy as np

a = [1,7,11,12,14,23,33,47,51,64,67,77,139,672,871]

# 리스트야! 내 숫자 담고 있늬? / binary함수야! 얼마나 빨리 찾길래 내가 널 손수 만들어야하늬?
def binary(data,find_num,count=0) :
    list_data = list(data)
    median = np.median(list_data)
    if median < find_num :
        count += 1
        del list_data[:list_data.index(median)+1]
    elif median > find_num :
        count += 1
        del list_data[list_data.index(median):]
    elif median == find_num :
        count += 1
        return ("%d은(는) 이진탐색 %d번 만에 찾았습니다"%(find_num,count))
    else :
        return "없다 이놈아"
    return binary(list_data,find_num,count)
        
print(binary(a,67))
print(a) # a는 데이터에 대해서는 훼손되지 않았음

 

 

 

 

 

 

 

 

합성곱 이해를 위한 이미지

 

 

 

위의 이미지에서 맨 마지막 연산이 15가 되도록 하는 파이썬 코드

1
2
3
4
5
6
import numpy as np
        
= np.array([[1,2,3,],[0,1,2],[3,0,1]])
filter = np.array([[2,0,1],[0,1,2],[1,0,2]])
 
print(np.sum(x*filter)) # 15
cs

 

 


 

covolution 과정을 이해하기 위한 빌드업 문제와 코드

 

문제 1.

1
2
3
= np.array([[1,2,3,0],[0,1,2,3],[3,0,1,2],[2,3,0,1]])
 
print(a[0:3,0:3])
cs

 

 

문제 2.

1
print(a[0:3,1:4])
cs

 

 

문제 3.

1
print(a[1:4,0:3])
cs

 

 

문제 4.

1
print(a[1:,1:])
cs

 

 

 


 

 

 

import numpy as np

# data array인 a와 filter array인 filter를 생성한다.
a = np.array([[1,2,3,0],[0,1,2,3],[3,0,1,2],[2,3,0,1]])
filter = np.array([2,0,1,1]).reshape(2,2)

# matrix_convolution 함수
def matrix_convolution (data,filter_data,stride) :
	# stirde * (filter_data[열] or filter_data[행])이 data의 열, 혹은 행보다 크면 안됨
    if stride*filter_data.shape[0] > data.shape[0] or stride*filter_data.shape[1] > data.shape[1] :
        return 'stride가 너무 큽니다.'
        
    # 결과 리스트 생성, 결과를 담을 행렬의 shape을 위해서 count_i, count_j 만듦
    result = []
    count_i = 0
    count_j = 0
    
    # convolution 코드
    for i in range(0,data.shape[0]-filter_data.shape[0]+1,stride) :
        count_i += 1
        for j in range(0,data.shape[1]-filter_data.shape[1]+1,stride) :
            count_j += 1
            result.append(np.sum(data[i:filter_data.shape[0]+i,j:filter_data.shape[1]+j]*filter_data))
	
    # 결과 list를 count_i와 count_j를 이용하여 배열로 생성
    result = np.array(result).reshape(int(count_j/count_i),count_i)
    return result

matrix_convolution(a,filter,2)

 

 

 

 

 

 

 

https://dog-developers.tistory.com/20

 

MySQL 8.0.15 다운로드 및 설치방법 (Windows 10)

광고 클릭은 개발자(저) 에게 큰 힘이 됩니다!!'ㅁ' MySQL 8.0.15 다운로드 및 설치방법(Windows 10) https://www.mysql.com/ MySQL 홈페이지 주소입니다. https://dev.mysql.com/downloads/mysql/ 다운로드 페이..

dog-developers.tistory.com

 

블로그 참고해서 MySQL 다운로드 받기

 

 

mysql 테이블 스크립트.txt
0.00MB

 

-- MySQL 8.0 Command Line Client 창에 들어가서 비밀번호 입력하고 MySQL 들어간 후 실행

CREATE DATABASE ORCL;
USE ORCL;

-- 올린 txt 파일 붙여넣기 (EMP, DEPT 테이블 생성)

 

 

 

 

나보다 돈 많이 벌고 잘 사는 사람이 예쁘게 잘 만든 numpy 모듈을 굳이 굳이 for문으로 만들어 보자.

numpy를 for문으로 구현하기 위해서는 디지털 논리회로로 생각하면 쉽다.

 


 

예를 들어 행렬이 아래와 같이 있고, 행렬곱을 한다고 하면 다음과 같다.

 

                1 2             2 3          (1*2 + 2*1) (1*3 + 2*4)

                3 4             1 4          (3*2 + 4*1) (3*3 + 4*4)

 

 

 

위의 행렬곱을 요소로 생각하면 다음과 같다.

 

                00 01          00 01      (00*00+01*10) (00*01+01*11)

                10 11          10 11      (10*00+11*10) (10*01+11*11)

 

 

 

요소를 활용해 행렬곱을 나타낸 식을 세로로 세우면 다음과 같다.

                                                          a[0]    a[1]   b[0]   b[1]       실제 위치

                                                          [0]      [1]     [2]     [3]

                00*00                                   0        0       0       0

+              01*10                                   0        1       1       0

------------------------

                00*01                                   0        0       0       1

+              01*11                                   0        1       1       1

------------------------

                10*00                                   1        0       0       0

+              11*10                                   1        1       1       0

------------------------

                10*01                                   1        0       0       1

+              11*11                                   1        1       1       1

 

 

 

[0]은     00001111

[1][2]는  01010101

[3]은     00110011 로 위치가 변한다.

 

따라서 for문을 3개 중첩할 때

for i :

    for j :

        for k :

 

[0]에는 [i]를 / [1][2]에는 [k]를 / [3]에는 [j]를 넣으면 된다.

a[0][1] * b[2][3]

a[ i][k] * b[k][ j]

 


 

곱행렬을 넣을 행렬을 선언하기 위해서 알아야 하는 기본적인 개념은

행렬 (2*4) 와 (4*2) 의 행렬 곱은 (2*2) 가 나온다는 것이다.

즉, 첫번째 행렬의 행과 두번째 행렬의 열로 행렬이 구성된다.

행렬 (i*j) 와 (n*m) 의 행렬 곱은 (i*m) 로 나온다.

 

따라서 np_dot이라는 빈 array, 혹은 list를 구현할 때 a[0]의 크기와 b[1]의 크기로 np_dot을 생성한다.

 

 


 

 

# 행렬곱만 list로 구현
import numpy as np
def np_dot(a,b) :                                  # 행렬곱함수
    np_dot= np.zeros((a.shape[0],b.shape[-1]))     # np_dot이라는 곱행렬을 담을 빈 행렬 만듦
    for i in range(len(a)) :							
        for j in range(a.shape[0]) :               # 행렬의 shape은 (n,n)임을 참고
            for k in range(a.shape[1]) :
                np_dot[i][j] += a[i][k]*b[k][j]    # 디지털 논리회로 참고
    return np_dot

print(np_dot(a,b))


# ------------------------------------------------------------------------------------------------


# list로 행렬곱 구하기
def np_dot(a,b) :
    a_shape = [len(a),len(a[0])]
    b_shape = [len(b),len(b[0])]
    
    # np_dot 생성
    np_dot = []
    for i in range(a_shape[0]) :
        np_dot.append([0]*b_shape[-1])
       
    # 행렬곱 수행
    for i in range(len(a)) :
        for j in range(a_shape[0]) :
            for k in range(a_shape[1]) :
                np_dot[i][j] += a[i][k]*b[k][j]
    return np_dot

# 세로 출력
for i in np_dot(a,b) :
    print(i)
    
 # 가로 출력
print(np_dot(a,b))

 

 

 

 

'코딩 > 문제' 카테고리의 다른 글

문제6. (파이썬) 합병정렬  (0) 2020.06.05
문제5. (파이썬) 삽입정렬  (0) 2020.06.04
문제4. (파이썬) 버블정렬  (0) 2020.06.03
문제3. (파이썬) 이진탐색  (0) 2020.06.02
문제2. (파이썬) matrix_convolution 구현  (0) 2020.06.01

 

 

 

 

Perceptron (퍼셉트론)

 

퍼셉트론은 딥러닝에서 사용된다. 이것은 인간의 뉴런을 본 떠 만들었다. 퍼셉트론은 다수의 신호(Input)를 입력받아서 하나의 신호(Output)를 출력한다. 이는 뉴런이 전기신호를 내보내 정보를 전달하는 것과 비슷하게 동작한다. 퍼셉트론의 Weight(가중치)는 뉴런끼리 서로의 신호를 전달하는 것과 같은 역할을 한다.

 

 

 

 

Weight(가중치)는 각각의 입력신호에 부여되어 입력신호와의 계산을 하고 신호의 총합이 정해진 임계값(θ; theta,세타)을 넘었을 때 1을 출력한다. (이를 뉴련의 활성화activation 으로도 표현) 넘지 못하면 0 또는 -1을 출력한다. 결론적으로 우리는 딥러닝을 통해 Weight(가중치)의 값을 조정함으로서 원하는 모델을 만들어내고자 한다.

 

+) 추가적으로 편향(Bias)에 대해 설명하자면 편향은 학습 데이터가 가중치와 계산되어 넘어야 하는 임계점으로, 이 값이 높으면 높을수록 분류의 기준이 엄격하고 낮을수록 한계점이 낮아져 데이터의 허용 범위가 넓어진다. Bias가 높을수록 모델이 간단해지는 경향이 있고 (변수가 적고 일반화됨) 과소적합(Underfitting : 모델이 너무 단순해서 데이터의 내재된 구조를 학습하지 못하는 현상)이 발생할 수 있다. 반대로 편향이 낮을수록 모델이 복잡해지고 오버피팅(Overfitting)이 발생할 수 있으며 필요없는 노이즈가 포함될 가능성이 높아진다.

 

Bias 값이 클 경우 모델이 간단해지는 경향
Underfitting 발생
Bias 값이 작을 경우 모델이 복잡해지는 경향
Overfitting 발생

 

편향에 대한 이러한 내용은 여기를 참고하면 좋은데, 이러한 내용은 편향과 분산의 트레이드오프 관계라고 한다.

(근데 이 트레이드오프가 머신러닝, 특히 회귀 쪽의 개념이기 때문에 이 트레이드오프가 신경망에서도 해당되는지에 대해서는 사실 정확하게 모르겠다... 어차피 신경망의 편향은 학습을 통해 자체적으로 갱신되는 파라미터이기 때문에 노란색 밑줄 정도로만 이해해도 충분하다고 생각한다. 그럼 왜 쓴건데)

 

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

24.07.06 ChatGPT 내용 추가

과적합(overfitting)은 모델이 학습 데이터에 너무 잘 맞아서, 새로운 데이터(테스트 데이터)에 대해서는 성능이 떨어지는 현상을 말합니다.

모델이 학습 데이터의 노이즈까지 학습해버리면, 일반화(generalization) 능력이 떨어집니다.

 

편향과 분산

  1. 편향 (Bias):
    • 모델이 실제 데이터의 패턴을 단순화해서 나타내는 정도를 의미합니다.
    • 높은 편향: 모델이 지나치게 단순해서 데이터의 복잡한 패턴을 잘 잡아내지 못하는 경우.
    • 예: 선형 회귀 모델이 비선형 데이터에 적합하려 할 때.
  2. 분산 (Variance):
    • 모델이 학습 데이터의 변동에 얼마나 민감하게 반응하는지를 나타냅니다.
    • 높은 분산: 모델이 학습 데이터의 작은 변동에도 지나치게 민감하게 반응하여 과적합되는 경우.
    • 예: 복잡한 다항 회귀 모델이 학습 데이터에 지나치게 잘 맞추는 경우.

 

편향, 분산, 과적합의 상관관계 표

낮은 분산 적절한 모델 미적합 (Underfitting)
높은 분산 과적합 (Overfitting) 적절한 모델

 

  • 낮은 편향 - 낮은 분산: 이상적인 상황으로, 모델이 학습 데이터와 테스트 데이터 모두에서 좋은 성능을 보입니다.
  • 낮은 편향 - 높은 분산: 과적합(overfitting)이 발생하는 상황으로, 모델이 학습 데이터에 너무 잘 맞춰져서 테스트 데이터에서 성능이 떨어집니다.
  • 높은 편향 - 낮은 분산: 미적합(underfitting)이 발생하는 상황으로, 모델이 너무 단순해서 학습 데이터와 테스트 데이터 모두에서 성능이 낮습니다.
  • 높은 편향 - 높은 분산: 이는 드물지만, 모델이 복잡하면서도 데이터의 패턴을 잘 학습하지 못하는 경우입니다. 이 경우 모델이 학습 데이터와 테스트 데이터 모두에서 성능이 낮습니다.

 

예시

  1. 선형 회귀 (높은 편향, 낮은 분산):
    • 선형 회귀 모델은 비선형 데이터에서 높은 편향으로 인해 패턴을 제대로 잡아내지 못합니다. 그러나 분산은 낮아서 데이터 변동에 민감하게 반응하지 않습니다.
  2. 복잡한 다항 회귀 (낮은 편향, 높은 분산):
    • 복잡한 다항 회귀 모델은 낮은 편향으로 인해 데이터의 복잡한 패턴을 잘 잡아내지만, 높은 분산으로 인해 과적합이 발생할 수 있습니다.

 

요약

  • 편향 (Bias): 모델이 단순해서 데이터의 패턴을 잘 잡아내지 못하는 경우.
  • 분산 (Variance): 모델이 학습 데이터의 변동에 민감하게 반응하여 과적합되는 경우.
  • 과적합 (Overfitting): 모델이 학습 데이터에 너무 잘 맞아서 테스트 데이터에서 성능이 떨어지는 현상.

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

퍼셉트론은 AND, OR , NAND, XOR 게이트 등으로 구성되어있다. 그냥 디지털논리회로와 비슷하다고 보면 되겠다. 입력값에 따라 원하는 출력값을 만들어내기 위해 이런 저런 단순한 게이트들을 이용하여 원하는 결과를 도출해낸다. 하지만 단층 퍼셉트론은 원하는 결과를 모두 도출해낼 수는 없다. 예를 들어 내가 0부터 9까지 차례대로 나타내는 프로그램을 만든다고 가정하자. 딱 하나의 게이트로는 절대 이런 프로그램을 만들어낼 수 없다. 하지만 여러 개의 게이트를 사용할 수 있다면 어떻게될까? 당연히 가능할 것이다. 이렇게 단층 퍼셉트론으로 불가능한 것을 하기 위해 우리는 다층 퍼셉트론을 사용한다.

 

단층 퍼셉트론을 쉽게 이해할 수 있는 예제가 있는 블로그를 남겨두겠다. 다들 참고하길 바란다.

'인공지능 > 인공지능 이론' 카테고리의 다른 글

15. 항등함수와 Softmax 함수  (2) 2020.08.03
14. 다층퍼셉트론 / Sigmoid / ReLU  (0) 2020.07.01
12. Clustering  (0) 2019.09.13
11. 차원의 저주 / PCA  (0) 2019.09.13
10. ROC Curve  (1) 2019.09.12

 

 

 

 

Clustering (군집화)

 

앞서도 설명했지만 까먹었을까봐 다시 한 번 언급하겠다. Clustering과 Classification(분류)은 굉장히 비슷한 개념이다. 하지만 Clustering은 비지도학습(Unsupervised)으로, 정답이 없는 데이터들을 비슷한 것 끼리 묶을 때 사용한다. 그와 반대로 Classification(분류)은 정답이 있는 데이터들을 사용하므로 지도학습(Supervised)이다.

 

클러스터링은 (1) 군집 간 분산(inter-cluster variance) 최대화 (2) 군집 내 분산(inner-cluster variance) 최소화 를 목표로 둔다.

 


 

 

어떻게 해야 잘 군집화했다고 소문이 날까? 위의 그림처럼 잘 구분되어 있는 데이터들같은 경우는 군집화하기가 쉬울것이다. 하지만 아래와 같은 경우는 어떨까?

 

데이터를 몇 개로 군집화시켜야할까?

 

위의 그림처럼 우리는 데이터들을 2개로도, 6개로도 혹은 그 이상으로 군집화할 수 있다. 왜냐하면 정답이 없기 때문이다. 하지만 군집화 개수에 따라 우리의 모델은 천차만별로 달라질 수 있다. 깔끔하고 정확하게 군집화하기 위해서는 어떻게 해야할까? 이러한 고민을 해결하기 위해 우리는 군집 타당성 지표를 생각한다. 간단하게 설명하자면 각 데이터 간의 거리를 계산하여 군집화하는 것을 의미한다. 이에 대해 자세한 내용은 블로그를 참고하기를 바란다.

 

 

 

 

 

- K-means

 

K-means 방법

 

K-means의 K는 클러스터 수를 의미한다. 위의 예는 K가 2인 경우이다. 군집의 무게중심(빨간색 점)을 랜덤으로 초기화한다. 그 후 모든 점들(파란색 점)의 가장 가까운 무게중심을 기준으로 클러스터링한다. (E스텝) 그리고 클러스터의 무게중심을 업데이트한다. (M스텝)

이렇게 E스텝과 M스텝을 반복하며 최종적으로 결과가 바뀌지 않거나(=해가 수렴), 사용자가 정한 반복수를 채우게 되면 학습을 끝내는 것을 K-means라고 한다.

 

하지만 K-means는 초기값 위치에 따라 원하는 결과가 나오지 않을 수 있고  클러스터의 밀도나 크기가 다를 경우 원하는 결과가 나오지 않을 수 있으며 데이터의 분포가 특이한 경우에도 잘 적용되지 않는다. 이에 대한 시각적인 부분은 블로그를 참고하기를 바란다.

 

 

 

+ KNN (K-Nearest Neighbors) : KNN은 Classification이다.

 

KNN은 새로운 데이터가 주어졌을 때 기존 데이터 가운데 가장 가까운 K개 이웃의 정보로 새로운 데이터를 예측하는 방법론으로 지도학습(Supervised)이다. 레이지(Lazy)모델이라고도 불리는데 딱히 학습할만한 것이 없기 때문이다. KNN에 대해 궁금하다면 더 자세히 설명한 블로그를 참고하기를 바란다.

 

K가 1이면 오렌지색, K가 3라면 녹색으로 분류하게 될 것이다. (+ K는 홀수개여야함)

 

+) K-means와 KNN의 공통점과 차이점

  KNN K-means
공통점 데이터를 비슷한 집단으로 묶는 방법
차이점 지도학습 (분류) 비지도학습 (군집화)

 

 

- GMM (Gaussian Mixture Model)

 

GMM은 전체 데이터의 확률분포가 여러개의 정규분포의 조합으로 이루어져 있다고 가정하고 각 분포에 속할 확률이 높은 데이터끼리 클러스터링 하는 방법이다. GMM은 K-means등의 클러스터링 알고리즘으로 잘 묶을수 없었던 아래 데이터에서도 잘 작동한다. 자세한 내용은 블로그를 참고하길 바란다.

 

 

 

- Hierarchical Clustering (계층적 군집화)

 

Hierarchical Clustering은 계층적 트리 모형을 이용해 개별 개체들을 순차적, 계층적으로 유사한 개체 내지 그룹과 통합하여 군집화를 수행하는 알고리즘이다. Hierarchical Clustering은 클러스터의 수를 사전에 정하지 않아도 학습 수행가능하다. 이에 대해 자세한 내용은 블로그를 참고하길 바란다.

 

 

 

 


 

 

 

 

정리

 

 

 

'인공지능 > 인공지능 이론' 카테고리의 다른 글

14. 다층퍼셉트론 / Sigmoid / ReLU  (0) 2020.07.01
13. Perceptron (퍼셉트론)  (0) 2019.09.14
11. 차원의 저주 / PCA  (0) 2019.09.13
10. ROC Curve  (1) 2019.09.12
9. Classification (분류)  (0) 2019.09.11

 

 

 

Curse Of Dimensionality (차원의 저주)

 

우리는 데이터가 많으면 많을수록 더 좋은 학습 모델을 만들 수 있다고 얘기했다. 반대로 데이터가 적을 경우, 그 데이터를 늘리기 위해 여러가지 방법들에 대해서도 이야기했다. 하지만 데이터가 적음에도 불구하고 용량이 큰 경우에 대해서는 이야기하지 않았다. 지금부터 그러한 경우에 대해서 얘기해보고자 한다. 데이터가 적은데 용량이 크다니 이게 무슨 어불성설인가! 이 말은 즉슨 데이터량은 적지만 각각의 데이터에 할당된 정보량, 즉 차원(Dimension)이 많은 경우를 뜻한다. 쉽게 이해하기 어려우니 예를 들자면 대표적으로 이미지를 들 수 있겠다. 우리가 다루는 이미지는 대부분 픽셀로 이루어져있다. 픽셀이 많을수록 고해상도이다. 하지만 이미지는 단 하나이다. 이런 경우가 차원이 많은 경우라고 볼 수 있다. 데이터(그림)는 하나이지만, 그 안에 있는 차원(픽셀)이 많은 경우 우리는 학습을 하는데 어려움을 겪게 되고 많은 데이터를 필요로 한다. 이러한 것을 Curse Of Dimensionality(차원의 저주)라고 한다.

 

차원이 커질수록 필요한 데이터도 많아진다.

 

 

이러한 경우는 우리가 여태까지 공부해왔던 것처럼 직관이 성립하지 않으며 차원이 적으면 데이터들이 가깝게 뭉쳐있지만 차원이 크면 데이터들간의 거리가 커지면서 전체 공간에서 데이터가 차지하는 공간이 적어진다. 데이터가 차지하는 공간이 적어진다는 것은 새롭게 예측한 데이터도 훈련에 사용한 데이터와 멀리 떨어져 있을 가능성이 높다는 것을 뜻하고 예측모델을 만들기 위해 훨씬 더 많은 작업을 해야하지만 저차원보다 예측 결과가 좋지 못할 가능성이 높아진다.

 

 

차원이 커질수록 데이터가 차지하는 공간이 적어진다.

 

 

우리는 어떻게 차원의 저주에서 벗어날 수 있을까? 우선 첫째로 데이터의 양을 늘리는 방법이 있겠다. 하지만 데이터의 양을 늘리는 것도 어느정도의 한계가 존재한다. 그렇다면 어떻게 해야할까? 그 방법으로 바로 차원 축소가 있다.

 

 

 

 


 

 

 

 

Dimensionality Reduction (차원 축소)

 

차원 축소는 말 그대로 차원 축소이다. 어떻게 차원 축소가 차원의 저주에서 벗어날 수 있는걸까? 당연스럽게 느껴지지만 정확한 이유에 대해서는 잘 모르겠다. 이에 대한 이해를 돕기 위해 우리는 다양한 동물 중 고양이에 대해 분류하는 모델을 만드려고 한다고 가정해보자. 우리가 학습을 위해 수집한 데이터들은 다양한 픽셀(차원)의 고양이 이미지로 구성되어 있을 것이다. 또, 고양이는 먼치킨, 코숏, 아메리칸 숏헤어, 샴 등 다양한 종류의 고양이가 존재할 것이다. 이런 다양한 이미지의 전체 픽셀(차원)을 고려하여 학습하는 것은 굉장히 까다롭고 어려울 것이다. 하지만 자세히 보면 고양이를 특정 짓는 것은 일정하다. 고양이의 눈, 코, 입이 가장 대표적인 고양이의 특징일 것이다. 또한 이러한 고양이의 특징을 파악할 수 있는 픽셀(차원) 또한 한정되어있다. 이러한 경우 우리는 일정 픽셀(차원)에 대해서만 학습해도 충분히 우리가 원하는 모델을 만들어 낼 수 있다. 이러한 경우처럼 전체 차원인 관찰 공간(Observation Space)이 아닌 유의미한 특정 차원인 잠재 공간(Latent Space)에 대해서만 학습하여 원하는 모델을 만들어내기 위해 차원 축소를 사용한다.

 

 

- PCA (주성분 분석)

 

 

주성분 분석은 말 그대로 전체 차원에서 가장 주요한 성분을 순서대로 추출하는 기법을 말한다. 여러 변수의 값을 합쳐서 그 보다 적은 수의 주요 성분을 새로운 변수로 하여 데이터를 표현하기 때문에 차원을 축소할 때 사용할 수 있는 기법이다. PCA에 대해 친절하고 자세히 설명해주는 유튜브 영상을 첨부하겠다. 또 이 유튜브 영상에 대해 자세히 설명해주는 블로그 또한 첨부하겠다.

 

https://www.youtube.com/watch?v=FgakZw6K1QQ

 

 


 

 

 

PCA 방법

 

가장 폭 넓은, 즉 분산이 가장 크게 되는 축은 데이터를 가장 폭 넓게 설명할 수 있다. 따라서 분산이 가장 큰 축을 제 1주성분이라고 한다. 이처럼 분산의 정도에 따라 차등적으로 주성분을 만들어나가는데, 몇까지의 주성분을 사용하는지에 대해서는 맨 위의 PCA를 누르면 참고할 수 있는 블로그를 참고하길 바란다.

 

 

 

 

'인공지능 > 인공지능 이론' 카테고리의 다른 글

13. Perceptron (퍼셉트론)  (0) 2019.09.14
12. Clustering  (0) 2019.09.13
10. ROC Curve  (1) 2019.09.12
9. Classification (분류)  (0) 2019.09.11
8. Regression (회귀)  (0) 2019.09.08

+ Recent posts