02-2 ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ
์ง๋ ์ฑํฐ์์ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ์ ๋ขฐํ ์ ์์์ ๋ณด์ฌ ์ฃผ๊ธฐ ์ํด ํ๋ จ ๋ฐ์ดํฐ๋ฅผ ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ๋ก ๋๋์๊ณ , ์ด๋ ์ ํ๋ 100%๋ฅผ ๋ฌ์ฑํ๋ค. ๊ทธ๋ฐ๋ฐ ์๋ก์ด ์์ ์ผ๋ก ํ ์คํธ๋ฅผ ํด๋ดค๋๋ ๋๋ฏธ๋ฅผ ๋น์ด๋ก ์์ธกํ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค. ์ด ๋ฌธ์ ๋ ์ ๋ฐ์ํ์๊น?
๋ํ์ด๋ก ๋ฐ์ดํฐ ์ค๋นํ๊ธฐ
๋ฌธ์ ์ ๋ํด ์ดํด๋ณด๊ธฐ ์ ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ์ค๋นํด๋ณด์. ์ด๋ฒ์๋ ๋ํ์ด์ column_stack() ํจ์๋ก ๋ฐ์ดํฐ๋ฅผ ํฉ์น์.
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]
import numpy as np
fish_data = np.column_stack((fish_length, fish_weight))
ํ๊น ๋ฐ์ดํฐ๋ ๋ง์ฐฌ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ๋ง๋ค์ด๋ณด์. ๋ํ์ด์ np.ones()์ np.zeros() ํจ์๋ ๊ฐ๊ฐ ์ํ๋ ๊ฐ์์ 1๊ณผ 0์ ์ฑ์ด ๋ฐฐ์ด์ ๋ง๋ค์ด์ค๋ค. ์ฌ๊ธฐ์ np.concatenate() ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ๊ฒฐ์ํจ๋ค.
fish_target = np.concatenate((np.ones(35),np.zeros(14)))
์ฌ์ดํท๋ฐ์ผ๋ก ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ ๋๋๊ธฐ
์ ๋ฌ๋๋ ๋ฆฌ์คํธ๋ ๋ฐฐ์ด์ ๋น์จ์ ๋ง๊ฒ ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ๋ก ๋๋์ด ์ฃผ๋ train_test_split() ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ๋๋์ด๋ณด์.
from sklearn.model_selection import train_test_split
train_input,test_input, train_target, test_target = train_test_split(fish_data, fish_target, random_state=42)
fish_data๋ train_input๊ณผ test_input์ผ๋ก ๋๋๊ณ , fish_target์ train_target๊ณผ test_target์ผ๋ก ๋๋์ด ์ด 4๊ฐ์ ๋ฐฐ์ด์ด ๋ฐํ๋๋ค. ์ด ํจ์๋ ๊ธฐ๋ณธ์ ์ผ๋ก 25%๋ฅผ ํ ์คํธ ์ธํธ๋ก ๋ผ์ด ๋ธ๋ค. ๊ทธ๋ฐ๋ฐ ์ด๋ ์ํ์ด ๊ณจ๊ณ ๋ฃจ ์์ด์ง ์์ ์ ์๋ค. ํ๋ จ ๋ฐ์ดํฐ๊ฐ ์๊ฑฐ๋ ํน์ ํด๋์ค์ ์ํ ๊ฐ์๊ฐ ์ ์ ๋ ํนํ ์ด๋ฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค. stratify ๋งค๊ฐ๋ณ์์ ํ๊น ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๋ฉด ํด๋์ค ๋น์จ์ ๋ง๊ฒ ๋ฐ์ดํฐ๋ฅผ ๋๋์ด์ค๋ค.
train_input,test_input, train_target, test_target = train_test_split(fish_data, fish_target, stratify=fish_target, random_state=42)
์ํ๋ง ํธํฅ ๋ฌธ์ ๋ ํด๊ฒฐํ์์ผ๋ ๋ฐ์ดํฐ๋ ๋ชจ๋ ์ค๋น๋์๋ค. ์ด์ ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ํ์ธํด๋ณด์.
์์ํ ๋๋ฏธ ํ ๋ง๋ฆฌ
์ค๋นํ ๋ฐ์ดํฐ๋ก k-์ต๊ทผ์ ์ด์์ ํ๋ จํด๋ณด์.
from sklearn.neighbors import KNeighborsClassifier
kn = KNeighborsClassifier()
kn.fit(train_input, train_target)
kn.score(test_input, test_target)
1.0
๊ทธ๋ฆฌ๊ณ ๋๋ฏธ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํด๋ณด์.
print(kn.predict([[25,150]]))
[0.]
๋๋ฏธ(1)๋ก ์์ธกํ์ง ์์๋ค. ์ ์ด๋ฐ ๊ฒฐ๊ณผ๊ฐ ๋์๋์ง, ์ด์ ์ํ์ ํ์ํ ์ฐ์ ๋๋ฅผ ๊ทธ๋ ค์ ํ์ธํด๋ณด์.
import matplotlib.pyplot as plt
distances, indexes = kn.kneighbors([[25,150]])
plt.scatter(train_input[:,0], train_input[:,1])
plt.scatter(25,150,marker='^')
plt.scatter(train_input[indexes,0], train_input[indexes,1],marker='D')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()
๊ฐ์ฅ ๊ฐ๊น์ด ์ด์์๋ ๋น์ด๊ฐ ์๋์ ์ผ๋ก ๋ง๋ค. ์ฐ์ ๋๋ฅผ ๋ณด๋ฉด ์ง๊ด์ ์ผ๋ก ๋๋ฏธ์ ๊ฐ๊น๊ฒ ๋ณด์์๋ ๋ถ๊ตฌํ๊ณ ๋ง์ด๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋ '๊ธฐ์ค'์ ๋ง์ถ๋ ๊ฒ์ด ํ์ํ๋ค.
๊ธฐ์ค์ ๋ง์ถฐ๋ผ
์์ ์ฐ์ ๋๋ฅผ ๋ณด๋ฉด x์ถ์ ๋ฒ์๊ฐ ์ข๊ณ (10~40), y์ถ์ ๋ฒ์๊ฐ ๋๋ค(0~1000). ๊ทธ๋์ y์ถ์ผ๋ก ์กฐ๊ธ๋ง ๋ฉ์ด์ ธ๋ ๊ฑฐ๋ฆฌ๊ฐ ์์ฃผ ํฐ ๊ฐ์ผ๋ก ๊ณ์ฐ๋์๋ ๊ฒ์ด๋ค. ์ด๋ ๋ฏ ํน์ฑ ๊ฐ์ ์ค์ผ์ผ์ด ๋ค๋ฅผ ๋๋ ํน์ฑ๊ฐ์ ์ผ์ ํ ๊ธฐ์ค์ผ๋ก ๋ง์ถฐ์ฃผ๋ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ ์์ ์ด ํ์ํ๋ค. ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉํ๋ ์ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ์ ํ์ค์ ์(z ์ ์)๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ํ์ค์ ์๋ ๊ฐ ํน์ฑ๊ฐ์ด 0์์ ํ์คํธ์ฐจ์ ๋ช ๋ฐฐ๋งํผ ๋จ์ด์ ธ ์๋์ง๋ฅผ ๋ํ๋ด๊ณ , ์ด๋ฅผ ํตํด ์ค์ ํน์ฑ๊ฐ์ ํฌ๊ธฐ์ ์๊ด์์ด ๋์ผํ ์กฐ๊ฑด์ผ๋ก ๋น๊ตํ ์ ์๊ฒ ๋๋ค.
๊ณ์ฐํ๋ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ๋ค. ํ๊ท ์ ๋นผ๊ณ ํ์คํธ์ฐจ๋ฅผ ๋๋์ด์ฃผ๋ฉด ๋๋ค. ์ฌ๊ธฐ์ ํน์ฑ๋ง๋ค ๊ฐ์ ์ค์ผ์ผ์ด ๋ค๋ฅด๋ฏ๋ก ํ๊ท ๊ณผ ํ์คํธ์ฐจ๋ ๊ฐ ํน์ฑ๋ณ๋ก ๊ณ์ฐํด์ผ ํ๋ค. ์ด๋ฅผ ์ํด axis=0์ผ๋ก ์ง์ ํด์ค๋ค.
mean = np.mean(train_input, axis=0)
std = np.std(train_input, axis=0)
train_scaled = (train_input - mean) / std
๋ํ์ด์์๋ ๋ธ๋ก๋์บ์คํ ์ด๋ผ๋ ๊ธฐ๋ฅ์ด ์์ด์ ์์ ๊ฐ์ด ๋ช ๋ นํ๋ฉด, train_input์ ๋ชจ๋ ํ์์ mean์ ์๋ ๋ ํ๊ท ๊ฐ์ ๋นผ๊ณ , std์ ์๋ ๋ ํ์คํธ์ฐจ๋ฅผ ๋ค์ ๋ชจ๋ ํ์ ์ ์ฉํ๋ค.
์ ์ฒ๋ฆฌ ๋ฐ์ดํฐ๋ก ๋ชจ๋ธ ํ๋ จํ๊ธฐ
์์์ ๊ธฐ์ค์ ๋ง์ถฐ ๋ฐ์ดํฐ๋ฅผ ๋ง๋ค์์ง๋ง, ๊ฐ์ ๋ฒ์๊ฐ ๋ฌ๋ผ์ก๊ธฐ ๋๋ฌธ์ ์ํ๋ ๋์ผํ ๋น์จ๋ก ๋ณํํด์ผํ๋ค. ์ฌ๊ธฐ์ ์ค์ํ ์ ์ 'ํ๋ จ ์ธํธ์ mean๊ณผ std'๋ฅผ ์ฌ์ฉํด์ ๋ณํํด์ผ ํ๋ค๋ ์ ์ด๋ค.
new=([25,150] - mean) / std
plt.scatter(train_scaled[:,0], train_scaled[:,1])
plt.scatter(new[0],new[1],marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()
์ด์ ํ๋ จ ๋ฐ์ดํฐ์ ๋ ํน์ฑ์ด ๋น์ทํ ๋ฒ์๋ฅผ ์ฐจ์งํ๊ฒ ๋์๋ค. ๋ค์ ํ๋ฒ k-์ต๊ทผ์ ์ด์ ๋ชจ๋ธ์ ํ๋ จํ๊ณ , ํ๊ฐํด๋ณด์.
๊ทธ๋ฆฌ๊ณ ์ด๋ ์ํ์ ํ๋ จ ์ธํธ์ ํ๊ท ๊ณผ ํ์คํธ์ฐจ๋ก ๋ณํํ ๊ฒ์ฒ๋ผ, ํ ์คํธ ์ธํธ๋ ํ๋ จ ์ธํธ์ ํ๊ท ๊ณผ ํ์คํธ์ฐจ๋ก ๋ณํํด์ผ ํ๋ค.
kn.fit(train_scaled, train_target)
test_scaled = (test_input - mean) / std
kn.score(test_scaled, test_target)
1.0
ํ ์คํธ ์ธํธ์ ์ํ์ ์๋ฒฝํ๊ฒ ๋ถ๋ฅํ๋ค. ์ด์ ์๊น ๊ทธ ๋ฌธ์ ์ ์ํ์ ์์ธกํด๋ณด๋ฉด
print(kn.predict([new]))
[1.]
๋๋ฏธ๋ก ์ฌ๋ฐ๋ฅด๊ฒ ์์ธกํ ๊ฒ์ ํ์ธํ ์ ์๋ค.
๊ทธ๋ผ ๋ค์ ์ฐ์ ๋๋ฅผ ๊ทธ๋ ค ๊ฐ๊น์ด ์ด์์ด ์ด๋ป๊ฒ ๋ณํํ๋์ง ์ดํด๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ฐ์ฅ ๊ฐ๊น์ด ์ํ์ด ๋ชจ๋ ๋๋ฏธ์ธ ๊ฒ์ ํ์ธํ ์ ์๋ค.
distances, indexes = kn.kneighbors([new])
plt.scatter(train_scaled[:,0], train_scaled[:,1])
plt.scatter(new[0],new[1],marker='^')
plt.scatter(train_scaled[indexes,0], train_scaled[indexes,1],marker='D')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()
(์ ๋ฆฌ) ์ค์ผ์ผ์ด ๋ค๋ฅธ ํน์ฑ ์ฒ๋ฆฌ
๊ธฐ์กด์ ๋ง๋ค์๋ ๋ชจ๋ธ์ ์๋ฒฝํ๊ฒ ํ ์คํธ ์ธํธ๋ฅผ ๋ถ๋ฅํ๋ค. ๊ทธ๋ฌ๋ ์๋ก์ด ์ํ์ ๋ํด์ ์๋ชป ์์ธกํ๋ค. ์ด๋ ์ํ์ ๋ ํน์ฑ์ธ ๊ธธ์ด์ ๋ฌด๊ฒ์ ์ค์ผ์ผ์ด ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์๊ธด ๋ฌธ์ ์ด๋ค. ๊ทธ๋์ ํน์ฑ์ ํ์ค์ ์๋ก ๋ณํํ์ฌ ์ค์ผ์ผ์ ์กฐ์ ํ๋ ์์ ์ ํ๋ค. ์ด๋, ํ๋ จ ์ธํธ๋ฅผ ๋ณํํ ๋ฐฉ์ ๊ทธ๋๋ก ํ ์คํธ ์ธํธ๋ฅผ ๋ณํํด์ผ ํ๋ค๋ ๊ฒ์ ๊ผญ ๊ธฐ์ตํด์ผ ํ๋ค.
์ถ์ฒ : ๋ฐํด์ , ํผ์ ๊ณต๋ถํ๋ ๋จธ์ ๋ฌ๋+๋ฅ๋ฌ๋, ํ๋น๋ฏธ๋์ด, 2021