๋ฐ์ํ
ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ
์ง๋ ํ์ต๊ณผ ๋น์ง๋ ํ์ต
- ๋จธ์ ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํฌ๊ฒ ์ง๋ ํ์ต(Supervised Learning)๊ณผ ๋น์ง๋ ํ์ต(Unsupervised Learning)์ผ๋ก ๋๋์ ์์ต๋๋ค.
- ์ง๋ ํ์ต (Supervised Learning)์์๋ ๋ฐ์ดํฐ์ ์ ๋ต์ ์
๋ ฅ(Input)๊ณผ ํ๊น(Target)์ด๋ผ๊ณ ํ๊ณ , ์ด ๋์ ํฉ์ณ ํ๋ จ ๋ฐ์ดํฐ(Training Data)๋ผ๊ณ ๋ถ๋ฆ
๋๋ค.
- K-์ต๊ทผ์ ์๊ณ ๋ฆฌ์ฆ์ Input data์ Target์ ์ฌ์ฉํ์ผ๋ฏ๋ก ๋น์ฐํ ์ง๋ ํ์ต ์๊ณ ๋ฆฌ์ฆ ์ ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ Input์ผ๋ก ์ฌ์ฉ๋ ๊ธธ์ด & ๋ฌด๊ฒ๋ฅผ ํน์ฑ(feature)์ด๋ผ๊ณ ํฉ๋๋ค.
- ๋น์ง๋ ํ์ต(Unsupervised Learning)์ Target ์์ด Input ๋ฐ์ดํฐ๋ง ์ฌ์ฉํฉ๋๋ค. ์ด๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ์ ๋ต์ ์ฌ์ฉํ์ง ์์ผ๋ฏ๋ก, ๋ฌด์ธ๊ฐ๋ฅผ ๋งํ ์๊ฐ ์์ต๋๋ค. ๋์ ๋ฐ์ดํฐ๋ฅผ ์ ํ์ & ๋ณํํ๋๋ฐ ๋์์ ์ค๋๋ค.
ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ
- ๋จธ์ ๋ฌ๋์ ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ์ ๋๋ก ํ๊ฐํ๋ ค๋ฉด, ํ๋ จ ๋ฐ์ดํฐ & ํ๊ฐ์ ์ฌ์ฉํ ๋ฐ์ดํฐ๊ฐ ๊ฐ๊ฐ ๋ฌ๋ผ์ผ ํฉ๋๋ค.
- ์ด๋ ๊ฒ ํ๋ ๊ฐ๋จํ ๋ฐฉ๋ฒ์, ๋ ๋ค๋ฅธ ๋ฐ์ดํฐ๋ฅผ ์ค๋น or ์ด๋ฏธ ์ค๋น๋ ๋ฐ์ดํฐ ์ค์์ ์ผ๋ถ๋ฅผ ๋ผ์ด ๋ด์ด ํ์ฉํ๋ ๊ฒ์
๋๋ค.
- ๋ณดํต ์ค๋น๋ ๋ฐ์ดํฐ ์ค์์ ์ผ๋ถ๋ฅผ ๋ผ์ด ๋ด์ด ํ์ฉ ํ๋ ๋ฐฉ๋ฒ์ ๋ง์ด ์ฌ์ฉ ํฉ๋๋ค.
- ํ๊ฐ์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ๋ฅผ Test Set, ํ๋ จ์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ๋ฅผ Training Set ๋ผ๊ณ ํฉ๋๋ค.
- ๊ทธ๋ฌ๋ฉด ํ๋ฒ ๋ฐ์ดํฐ๋ฅผ ์ค๋นํด๋ณด๊ฒ ์ต๋๋ค. CH.1 ์์ ๋๋ฏธ & ๋น์ด์ ๋ฐ์ดํฐ๋ฅผ ํฉ์ณ ํ๋์ Python list ํํ๋ก ๋ฐ์ดํฐ๋ฅผ ์ค๋นํฉ๋๋ค.
# ์์ ์ ๊ธธ์ด
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]
- ๊ทธ๋ฆฌ๊ณ ์ด 49๊ฐ์ ๊ฐ ์์ ์ ๊ธธ์ด & ๋ฌด๊ฒ๋ฅผ ํ๋์ list๋ก ๋ด์ 2์ฐจ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค.
# ์ด 49๊ฐ์ sample, 35๊ฐ๋ training dataset, 14๊ฐ๋ test dataset
fish_data = [[l,w] for l,w in zip(fish_length, fish_weight)]
fish_target = [1]*35+[0]*14
- ์ฌ๊ธฐ์ ํ๋์ ์์ ๋ฐ์ดํฐ๋ฅผ Sample ์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค. ๋๋ฏธ & ๋น์ด๋ ๊ฐ๊ฐ 35๋ง๋ฆฌ, 14๋ง๋ฆฌ๊ฐ ์์ผ๋ฏ๋ก, ์ ์ฒด ๋ฐ์ดํฐ๋ 49๊ฐ์ sample์ด ์์ต๋๋ค. ์ฌ์ฉํ๋ ํน์ฑ์ ๊ธธ์ด, ๋ฌด๊ฒ 2๊ฐ์ ๋๋ค.
์ด์ ์ฌ๊ธฐ์ 35๊ฐ๋ฅผ Training set๋ก, ๋๋จธ์ง 14๊ฐ๋ Test set๋ก ์ฌ์ฉํด ๋ณด๊ฒ ์ต๋๋ค.
# ์ด์ ์ฌ๊ธฐ์ train data, test data๋ฅผ ๋ถ๋ฅํด์ data๋ฅผ input ํฉ๋๋ค.
train_input = fish_data[:35] # training_set ์ค 0~34๋ฒ์งธ index
train_target = fish_target[:35]# training_target๊ฐ ์ค 35๋ฒ~๋ง์ง๋ง index
test_input = fish_data[35:] # test_set์ค 35๋ฒ~๋ง์ง๋ง index
test_target = fish_target[35:]# test_target๊ฐ ์ค 35๋ฒ~๋ง์ง๋ง index
- ๊ทธ๋ฆฌ๊ณ scikit-learn์ KNeighborsClassifier ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ importํ๊ณ ๋ชจ๋ธ ๊ฐ์ฒด๋ฅผ ๋ง๋ญ๋๋ค.
from sklearn.neighbors import KNeighborsClassifier
kn = KNeighborsClassifier()
kn.fit(train_input, train_target)
# kn - ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ. fit - ๋ ๋ฐ์ดํฐ๋ฅผ ํ์ต์์ผ ๋๋ฏธ๋ฅผ ์ฐพ๊ธฐ ์ํ ๊ธฐ์ค์ ์ฐพ๋๋ค.
- ๊ทผ๋ฐ, ๋ชจ๋ธ์ ํ๋ จํ๊ณ ํ๊ฐํ๋ฉด ๋๋ฏธ & ๋น์ด๊ฐ ๊ณจ๊ณ ๋ฃจ ์์ด์ง ์์์ ์ ํ๋๊ฐ 0.0์ด ๋์ต๋๋ค.
- ์ด๋ฐ ๊ฒฝ์ฐ๋ ์ํ๋ง์ด ํ์ชฝ์ผ๋ก ์น์ฐ์ณค๋ค๋ ์๋ฏธ๋ก ์ํ๋ง ํธํฅ(Sampling bias)์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ ํน์ ์ข ๋ฅ์ ์ํ์ด ๊ณผ๋ํ๊ฒ ๋ง์ ์ํ๋ง ํธํฅ์ ๊ฐ์ง๊ณ ์์ผ๋ฉด ์ ๋๋ก๋ ์ง๋ํ์ต ๋ชจ๋ธ์ ๋ง๋ค์ ์์ต๋๋ค.
- ๊ทธ๋ฌ๋ฉด ์ํ๋ง ํธํฅ์ ๋ฐฉ์งํ๊ธฐ ์ํ์ฌ ํ๋ จ, ํ ์คํธ ์ํ์ ๊ณจ๊ณ ๋ฃจ ์์ด๊ธฐ ์ํ ์์ ์ ๊ฐํธํ๊ฒ ์ฒ๋ฆฌํ๊ธฐ ์ํ Numpy Library์ ๋ํ์ฌ ์ค๋ช ํ๋๋ก ํ๊ฒ ์ต๋๋ค.
Numpy ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- Python์ ๋ํ์ ์ ๋ฐฐ์ด(array)๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ด๋ฉฐ, ๊ณ ์ฐจ์์ ๋ฐฐ์ด์ ์์ฝ๊ฒ ๋ง๋ค๊ณ , ์กฐ์ํ ์ ์๋ ๊ฐํธํ ๋๊ตฌ๋ฅผ ๋ง์ด ์ ๊ณตํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ๋๋ค.
import numpy as np - ๋ณดํต ์ด๋ ๊ฒ import ํด์ ์ฌ์ฉํฉ๋๋ค.
- ๊ทธ๋ฌ๋ฉด ์ด์ ์์ ๋ฐ์ดํฐ๋ฅผ 2์ฐจ์ Numpy ๋ฐฐ์ด๋ก ๋ณํํด๋ณด๊ฒ ์ต๋๋ค.
# ๊ทธ๋์ ๋ฐ์ดํฐ์
์ด ๊ณจ๊ณ ๋ฃจ ์์ด๊ฒ ํด์ผ ํด์, numpy library (ํ๋ ฌ)์ฌ์ฉ
import numpy as np
input_arr = np.array(fish_data)
target_arr = np.array(fish_target)
print(input_arr)
print(input_arr.shape)
# (sample ์, ํน์ฑ ์ ์ถ๋ ฅ)
# (49, 2) ์ถ๋ ฅ.
๊ทธ๋ฌ๋ฉด ์ด์ ๋ฐ์ดํฐ๋ฅผ Numpy ๋ฐฐ์ด๋ก ์ค๋นํ์ผ๋ฏ๋ก, ์ด Array์์ Randomํ๊ฒ Sample์ ์ ํํด training_set, test_set๋ก ๋ง๋ค์ด๋ณด๊ฒ ์ต๋๋ค.
- ์ฃผ์ํ ์ ์, input_arr๊ณผ target_arr์์ ๊ฐ์ ์์น๋ ํจ๊ป ์ ํ๋์ด์ผ ํ๋ค๋ ์ ์ ๋๋ค. ์ฆ, target๊ณผ sample์ ๊ฐ์ด ์ด๋ํด์ผ ์ฌ๋ฐ๋ฅด๊ฒ ํ๋ จ๋ฉ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ ์ด์ , ๋ฌด์์๋ก training_set๋ฅผ ๋๋๊ธฐ ์ํด์๋ index์ ๊ฐ๋ค์ randomํ๊ฒ ์์ด์ผ ํจ์ผ๋ก, Numpy Library์ shuffle()ํจ์๋ฅผ ์ฌ์ฉํด, ๋ฐฐ์ด์ index๋ฅผ ์์ ์ ์์ต๋๋ค. ํ๋ฒ ์์ด๋ณด๊ฒ ์ต๋๋ค.
# ๋ฐ์ดํฐ ์๊ธฐ - index๋ฅผ ์์ด์ ๋ถ๋ฅํ๋ ๋ฐฉ๋ฒ.
np.random.seed(42) # "42"๋ผ๋ ๊ณ ์ ๋ ์ซ์๋ฅผ ์๋๋ก ์ค์ ํจ์ผ๋ก์จ, ํด๋น ์ธ์
์์ NumPy๋ก ์์ฑ๋ ๋ชจ๋ ๋๋ค ๋ฒํธ๊ฐ ์คํฌ๋ฆฝํธ๋ฅผ ์คํํ ๋๋ง๋ค ๋์ผํ๊ฒ ์ ์ง๋ฉ๋๋ค.
index = np.arange(49) # 0~48๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋ง๋ค์ด์ mix
np.random.shuffle(index)
- Numpy์ arange() ํจ์์ ์ ์ N์ ์ ๋ฌํ๋ฉด 0์์๋ถํฐ N-1๊น์ง 1์ฉ ์ฆ๊ฐํ๋ ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค. 49๋ฅผ ์ ๋ฌํ๋ฉด 0์์ 48๊น์ง 1์ฉ ์ฆ๊ฐํ๋ Array๋ฅผ ๋ง๋ค๊ฒ ์ฃ ?
๊ทธ๋ฆฌ๊ณ Numpy๋ Slicing ์ธ์ ๋ฐฐ์ด ์ธ๋ฑ์ฑ(Array Indexing)์ด๋ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ์ด ๊ธฐ๋ฅ์ 1๊ฐ์ index๊ฐ ์๋, ์ฌ๋ ค๊ฐ์ index๋ก ํ๋ฒ์ ์ฌ๋ฌ๊ฐ์ ์์๋ฅผ ์ ํํ ์ ์์ต๋๋ค.
print(input_arr[[1,3]]) #input_arr์ ์ 2๋ฒ์งธ, 4๋ฒ์งธ์ sample์ ์ ํํ์ฌ ์ถ๋ ฅ
[[26.3 290. ]
[29. 363. ]]
์ด์ , ์์ ๋ง๋ index ๋ฐฐ์ด์ ์ฒ์ 35๊ฐ๋ฅผ input_arr, target_arr์ ์ ๋ฌํ์ฌ ๋๋คํ๊ฒ 35๊ฐ์ ์ํ์ training_set๋ก ๋ง๋ค๊ฒ ์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ , ๋๋จธ์ง 14๊ฐ๋ test_set๋ก ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค.
# ์ด์ ์ฌ๊ธฐ์ train data, test data๋ฅผ ๋ถ๋ฅํด์ data๋ฅผ input ํฉ๋๋ค.
train_input = input_arr[index[:35]]
train_target = target_arr[index[:35]]
test_input = input_arr[index[35:]]
test_target = target_arr[index[35:]]
- ์ด์ , ์ฐ์ ๋๋ก ํ๋ฒ training_set(ํ๋ จ ์ธํธ), test_set(ํ ์คํธ ์ธํธ)์ ๋๋ฏธ & ๋น์ด๊ฐ ์ ์์ฌ ์๋์ง ๊ทธ๋ ค ๋ณด๊ฒ ์ต๋๋ค.
# ๋ฐ์ดํฐ ๋๋๊ณ ํ์ธ(by plot)
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()
๋๋ฒ์งธ ML Program
ํ๋ฒ, training_set, test_set๋ก K-์ต๊ทผ์ ์ด์ ๋ชจ๋ธ์ ํ๋ จ์ํค๊ณ ํ ์คํธ ํด๋ณด๊ฒ ์ต๋๋ค.
kn.fit(train_input, train_target)
kn.score(train_input, train_target)
- output(๊ฒฐ๊ณผ๊ฐ)์ผ๋ก 1.0์ด ๋์์ต๋๋ค. ์ ํ๋๊ฐ 100%๋ผ๋ ๋ป์ ๋๋ค.
์ฃผ์ Keyword
- ์ง๋ํ์ต (Supervised Learning)์ ์ ๋ ฅ๊ณผ ํ๊น์ ์ ๋ฌํ์ฌ ๋ชจ๋ธ์ ํ๋ จํ ๋ค์, ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ์์ธกํ๋๋ฐ ํ์ฉํฉ๋๋ค.
- ๋น์ง๋ ํ์ต(Unsupervised Learning)์ ํ๊น ๋ฐ์ดํฐ๊ฐ ์์ต๋๋ค. ๋ฐ๋ผ์ ๋ฌด์์ ์์ธกํ๋ ๊ฒ์ด ์๋๋ผ ์ ๋ ฅ ๋ฐ์ดํฐ์์ ์ด๋ค ํน์ง์ ์ฐพ๋ ๋ฐ ์ฃผ๋ก ํ์ฉํฉ๋๋ค.
- ํ๋ จ ์ธํธ(training_set)๋ ๋ชจ๋ธ์ ํ๋ จํ ๋ ์ฌ์ฉ ํ๋ ๋ฐ์ดํฐ์ ๋๋ค. ๋ณดํต ํ๋ จ ์ธํธ๊ฐ ํด์๋ก ์ข์ต๋๋ค. ๋ฐ๋ผ์ ํ์คํธ ์ธํธ๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์์ฉํฉ๋๋ค.
- ํ ์คํธ ์ธํธ(test_set)๋ ์ ์ฒด ๋ฐ์ดํฐ์์ 20∼30%๋ฅผ ํ ์คํธ ์ธํธ๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ์ ์ฒด ๋ฐ์ดํฐ๊ฐ ์์ฃผ ํฌ๋ค๋ฉด 1%๋ง ๋์ด๋ด๋ ์ถฉ๋ถํ ์ ์์ต๋๋ค.
ํต์ฌ ํจํค์ง์ ํจ์
Numpy
- seed()๋ ๋ํ์ด์์ ๋์๋ฅผ ์์ฑํ๊ธฐ ์ํ ์ ์ ์ด๊น๊ฐ์ ์ง์ ํฉ๋๋ค. ์ด๊น๊ฐ์ด ๊ฐ์ผ๋ฉด ํต ์ผํ ๋์๋ฅผ ๋ฝ์ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ๋๋ค ํจ์์ ๊ฒฐ๊ดด๋ฅผ ๋์ผํ๊ฒ ์ฌํํ๊ณ ์ถ์ ๋ ์ฌ์ฉํฉ๋๋ค.
- arange()๋ ์ผ์ ํ ๊ฐ๊ฒฉ์ ์ ์ ๋๋ ์ค์ ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค. ๊ธฐ๋ณธ ๊ฐ๊ฒฉ์ 1์ ๋๋ค. ๋งค๊ฐ๋ณ์ ๊ฐ ํ๋์ด๋ฉด ์ข ๋ฃ ์ซ์ง๋ฅผ ์๋ฏธํฉ๋๋ค. 0์์ ์ข ๋ฃ ์ซ์๊น์ง ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค. ์ข ๋ฃ ์ซ์๋ ๋ฐฐ์ด์ ํฌํจ๋์ง ์์ต๋๋ค.
print(np.arange(3))
# [0,1,2]
- ๋งค๊ฐ๋ณ์๊ฐ 2๋ฉด ์์ ์ซ์, ์ข ๋ฃ ์ซ์๋ฅผ ์๋ฏธํฉ๋๋ค.
print(np.arange(1, 3))
# [1, 2]
- ๋งค๊ฐ๋ณ์๊ฐ 3๊ฐ๋ฉด ๋ง์ง๋ง ๋งค๊ฐ๋ณ์๊ฐ ๊ฐ๊ฒฉ์ ๋ํ๋ ๋๋ค.
print(np.arange(1, 3, 0.2))
# [1. , 1.2, 1.4, 1.6, 1.8, 2. , 2.2, 2.4, 2.6, 2.8]
- shuffle()์ ์ฃผ์ด์ง ๋ฐฐ์ด์ ๋๋คํ๊ฒ ์์ต๋๋ค. ๋ค์ฐจ์ ๋ฐฐ์ด์ผ ๊ฒฝ์ฐ ์ฒซ ๋ฒ์งธ ์ถ(ํ)์ ๋ํด์๋ง ์์ต๋๋ค.
arr = np.array([[1, 2], [3, 4], [5, 6]])
np.random.shuffle(arr)
print(arr)
[[3 4]
[5 6]
[1 2]]
๋ฐ์ํ
'๐น๏ธ ํผ๊ณต๋จธ์ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ML] ํน์ฑ ๊ณตํ๊ณผ ๊ท์ (0) | 2023.09.24 |
---|---|
[ํผ๊ณต๋จธ์ ] Linear Regression (0) | 2023.09.23 |
[ํผ๊ณต๋จธ์ ] K-์ต๊ทผ์ ์ด์ ํ๊ท (0) | 2023.09.22 |
[ํผ๊ณต๋จธ์ ] ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ [๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ] (0) | 2023.09.18 |
[ํผ๊ณต๋จธ์ ] ๋์ ์ฒซ ๋จธ์ ๋ฌ๋ (0) | 2023.09.11 |