A A
[ํ˜ผ๊ณต๋จธ์‹ ] ํ›ˆ๋ จ ์„ธํŠธ์™€ ํ…Œ์ŠคํŠธ ์„ธํŠธ [๋ฐ์ดํ„ฐ ๋‹ค๋ฃจ๊ธฐ]

ํ›ˆ๋ จ ์„ธํŠธ์™€ ํ…Œ์ŠคํŠธ ์„ธํŠธ

์ง€๋„ ํ•™์Šต๊ณผ ๋น„์ง€๋„ ํ•™์Šต

  • ๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ํฌ๊ฒŒ ์ง€๋„ ํ•™์Šต(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)

์ด๋Ÿฐ ํ˜•์‹์œผ๋กœ array๊ฐ€ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.

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]]