[머신러닝2] 불확실성/샘플링편향/훈련세트/테스트세트

불확실성¶

• 미래는 언제나 불확실하며 지능이 있는 생명체는 생존을 위해서 불확실성을 제거하는 데 모든 것을 집중한다.
• 예측이 곧 지능의 핵심 기능이다.

1. 불확실성의 유형¶

1. 자료의 불확실성
   • 자료를 획득할 수 있는 기계 또는 센서 장치의 부정확성에서 기인한다.
   • 따라서 이렇게 얻어진 자료는 오차를 포함하고 있다.
   • 게다가 자료 수집 단계에서 관측되지 않는 미확인 자료들도 있으니 수집한 자료가 완벽하다고 할 수 없다.

1. 정보(Infomation)의 불완전성
   • 무인 자동차의 경우 주행 시 발생하는 모든 상황에 대한 방대한 정보를 모두 다 입력받아 처리할 수 없다.
   • 따라서 일부의 정보만 받아들여 판단해야 하므로 정보가 불완전하다고 할 수 있다.

1. 지식(Knowledge)의 불확실성
   • 지식의 표현이 자연어로 처리될 때 인간이 사용하는 모호한 표현을 사용하게 되며 이 모호한 내용으로 인해 여러 가지 해석을 불러일으키게 된다.
   • 또 시스템에 획득한 지식의 표현 및 저장 시 문제점으로 발생하기도 한다.

1. 확률적 불규칙성
   • 예측 불가능한 요인에 따라 발생하는 불규칙성이다.
   • 고속도로의 운전에서 갑작스럽게 튀어오는 돌멩이나 축구의 수비수가 자살골을 넣는 행동 등이 대표적인 확률적 불규칙성이다.

2. 불확실성의 표현 : 확률¶

• 불확실한 지식을 표현하는 방법은 통계를 바탕으로 하는 확률입니다.
• 내일 눈이 올 확률이 70%라거나 10명 중 1명은 영화를 봤다는 표현은 불확실한 지식을 표현한 예라고 할 수 있습니다.
• 전통적인 확률의 표현은 사건이 일어나는 가능성의 정도를 의미합니다. 어떠한 사건 A가 일어날 확률을 수식으로 표현하면 아래와 같습니다.

$ P(A) = \frac{사건 A가 일어날 수 있는 경우의 수}{일어날 수 있는 모든 경우의 수} $

3. 불확실성의 처리 : 베이지안 정리¶

• 일어나지 않은 일에 대해 앞선 일이 영향을 미칠 확률은 베이지안 확률로 이야기를 할 수 있습니다.
• 베이지안 확률은 주어진 사건과 관련 있는 사전 확률과 사후 확률 사이의 관계를 조건부 확률로 이용해 새롭게 일어날 수 있는 사건을 추론할 수 있습니다.

확률적 접근법¶

• 사건의 발생이 아주 빈번해 사전 확률이나 조건부 확률 등의 값이 충분히 추정될 경우 유용하게 사용할 수 있다.
• 데이터의 부족 때문에 주관적으로 확률값을 추정할 수 밖에 없다면 제약이 있다.

---

2. 훈련 세트와 테스트 세트¶

• 연습 문제와 시험 문제가 달라야 올바르게 모델의 능력을 평가할 수 있습니다. ##### 훈련 세트
• 훈련에 사용되는 데이터를 훈련 데이터(training set)이라고 부릅니다. ##### 테스트 세트
• 평가에 사용하는 데이터를 테스트 데이터(test set)이라고 부릅니다.

3. 샘플링 편향 (sampling bias)¶

• 상식적으로 훈련하는 데이터와 테스트하는 데이터에는 도미와 빙어가 골고루 섞여 있어야 합니다.
• 일반적으로 훈련 세트와 테스트 세트에 샘플이 골고루 섞여 있지 않으면 샘플링이 한쪽으로 치우졌다는 의미

4. 생선 분류 문제2¶

• 49개의 샘플

In [1]:

fish_length = [25.4, 26.3, 26.5, 29.0, 29.0, 29.7, 29.7, 30.0, 30.0, 30.7, 31.0, 31.0, 
                31.5, 32.0, 32.0, 32.0, 33.0, 33.0, 33.5, 33.5, 34.0, 34.0, 34.5, 35.0, 
                35.0, 35.0, 35.0, 36.0, 36.0, 37.0, 38.5, 38.5, 39.5, 41.0, 41.0, 9.8, 
                10.5, 10.6, 11.0, 11.2, 11.3, 11.8, 11.8, 12.0, 12.2, 12.4, 13.0, 14.3, 15.0]
fish_weight = [242.0, 290.0, 340.0, 363.0, 430.0, 450.0, 500.0, 390.0, 450.0, 500.0, 475.0, 500.0, 
                500.0, 340.0, 600.0, 600.0, 700.0, 700.0, 610.0, 650.0, 575.0, 685.0, 620.0, 680.0, 
                700.0, 725.0, 720.0, 714.0, 850.0, 1000.0, 920.0, 955.0, 925.0, 975.0, 950.0, 6.7, 
                7.5, 7.0, 9.7, 9.8, 8.7, 10.0, 9.9, 9.8, 12.2, 13.4, 12.2, 19.7, 19.9]

• 훈련 세트

In [2]:

fish_data = [[l, w] for l, w in zip(fish_length, fish_weight)]
fish_target = [1]*35 + [0]*14

• KNN 알고리즘

In [3]:

from sklearn.neighbors import KNeighborsClassifier
kn = KNeighborsClassifier()

• 샘플링 편향을 막기 위한 numpy

In [4]:

import numpy as np

In [5]:

index = np.arange(49)
np.random.seed(42)
np.random.shuffle(index)

In [6]:

index

Out[6]:

array([13, 45, 47, 44, 17, 27, 26, 25, 31, 19, 12,  4, 34,  8,  3,  6, 40,
       41, 46, 15,  9, 16, 24, 33, 30,  0, 43, 32,  5, 29, 11, 36,  1, 21,
        2, 37, 35, 23, 39, 10, 22, 18, 48, 20,  7, 42, 14, 28, 38])

• 훈련 세트 2차원 배열로 만들어주기

In [7]:

input_arr = np.array(fish_data)
print(input_arr)

[[  25.4  242. ]
 [  26.3  290. ]
 [  26.5  340. ]
 [  29.   363. ]
 [  29.   430. ]
 [  29.7  450. ]
 [  29.7  500. ]
 [  30.   390. ]
 [  30.   450. ]
 [  30.7  500. ]
 [  31.   475. ]
 [  31.   500. ]
 [  31.5  500. ]
 [  32.   340. ]
 [  32.   600. ]
 [  32.   600. ]
 [  33.   700. ]
 [  33.   700. ]
 [  33.5  610. ]
 [  33.5  650. ]
 [  34.   575. ]
 [  34.   685. ]
 [  34.5  620. ]
 [  35.   680. ]
 [  35.   700. ]
 [  35.   725. ]
 [  35.   720. ]
 [  36.   714. ]
 [  36.   850. ]
 [  37.  1000. ]
 [  38.5  920. ]
 [  38.5  955. ]
 [  39.5  925. ]
 [  41.   975. ]
 [  41.   950. ]
 [   9.8    6.7]
 [  10.5    7.5]
 [  10.6    7. ]
 [  11.     9.7]
 [  11.2    9.8]
 [  11.3    8.7]
 [  11.8   10. ]
 [  11.8    9.9]
 [  12.     9.8]
 [  12.2   12.2]
 [  12.4   13.4]
 [  13.    12.2]
 [  14.3   19.7]
 [  15.    19.9]]

In [8]:

target_arr = np.array(fish_target)
print(target_arr)

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0
 0 0 0 0 0 0 0 0 0 0 0 0]

• 훈련 세트, 테스트 세트 랜덤으로 나누기

In [9]:

train_input = input_arr[index[:35]]
print(train_input)

[[  32.   340. ]
 [  12.4   13.4]
 [  14.3   19.7]
 [  12.2   12.2]
 [  33.   700. ]
 [  36.   714. ]
 [  35.   720. ]
 [  35.   725. ]
 [  38.5  955. ]
 [  33.5  650. ]
 [  31.5  500. ]
 [  29.   430. ]
 [  41.   950. ]
 [  30.   450. ]
 [  29.   363. ]
 [  29.7  500. ]
 [  11.3    8.7]
 [  11.8   10. ]
 [  13.    12.2]
 [  32.   600. ]
 [  30.7  500. ]
 [  33.   700. ]
 [  35.   700. ]
 [  41.   975. ]
 [  38.5  920. ]
 [  25.4  242. ]
 [  12.     9.8]
 [  39.5  925. ]
 [  29.7  450. ]
 [  37.  1000. ]
 [  31.   500. ]
 [  10.5    7.5]
 [  26.3  290. ]
 [  34.   685. ]
 [  26.5  340. ]]

In [10]:

train_target = target_arr[index[:35]]
print(train_target)

[1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 0 1 1 1 1 0 1 1 1]

In [11]:

test_input = input_arr[index[35:]]
print(test_input)

[[ 10.6   7. ]
 [  9.8   6.7]
 [ 35.  680. ]
 [ 11.2   9.8]
 [ 31.  475. ]
 [ 34.5 620. ]
 [ 33.5 610. ]
 [ 15.   19.9]
 [ 34.  575. ]
 [ 30.  390. ]
 [ 11.8   9.9]
 [ 32.  600. ]
 [ 36.  850. ]
 [ 11.    9.7]]

In [12]:

test_target = target_arr[index[35:]]
print(test_target)

[0 0 1 0 1 1 1 0 1 1 0 1 1 0]

• 훈련 세트, 테스트 세트 그래프

In [13]:

import matplotlib.pyplot as plt

plt.scatter(train_input[:, 0], train_input[:, 1])
plt.scatter(test_input[:, 0], test_input[:, 1])
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

• 훈련 시키기

In [14]:

kn = kn.fit(train_input, train_target)

• 정확도

In [15]:

kn.score(test_input, test_target)

Out[15]:

1.0

• 예측하기

In [16]:

kn.predict(test_input)

Out[16]:

array([0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0])

In [17]:

test_target

Out[17]:

array([0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0])