โ ๋จธ์ ๋ฌ๋์ด๋ ?
์ธ๊ณต์ง๋ฅ์ ํ ๋ถ์ผ๋ก ์ปดํจํฐ๊ฐ ํ์ตํ ์ ์๋๋ก ํ๋ ์๊ณ ๋ฆฌ์ฆ๊ณผ ๊ธฐ์ ์ ๊ฐ๋ฐํ๋ ๋ถ์ผ
๋จธ์ ๋ฌ๋์ ํฌ๊ฒ 3๊ฐ์ง๋ก ๋ถ๋ฅํ ์ ์๋ค.
๋จธ์ ๋ฌ๋์์ ๋ฌธ์ ๋ฅผ ํ๋, ํด๋ต์ ๋ด๋ ๋ฐฉ๋ฒ์ ํฌ๊ฒ ๋๊ฐ์ง๊ฐ ์๋ค.
* ํ๊ท (Regression)
์ฌ๋ฌ๊ฐ์ ๋
๋ฆฝ๋ณ์์ ํ ๊ฐ์ ์ข
์๋ณ์ ๊ฐ์ ์๊ด๊ด๊ณ๋ฅผ ๋ชจ๋ธ๋งํ๋ ๊ธฐ๋ฒ
๐งฉ ์ ์ฉ ์์
๐ ์ฌ๋์ ์ผ๊ตด ์ฌ์ง์ ๋ณด๊ณ ๋ช ์ด์ธ์ง ์์ธกํ๋ ๋ฌธ์
input๊ฐ: ์ผ๊ตด์ฌ์ง
output๊ฐ: ์์ธกํ ๋์ด
์ฌ๊ธฐ์ ๋์ด์ ๊ฐ์ ์ฐ์์ (1์ธ~n์ธ,,)์ผ๋ก ์ฐ์์ ์ธ ์์์ ์ผ๋ก ์์ธกํ์ฌ ํ์์๋ค.
* ๋ถ๋ฅ (Classification)
์ฃผ์ด์ง ๋ฐ์ดํฐ๋ฅผ ํด๋์ค ๋ณ๋ก ๊ตฌ๋ณํด ๋ค์ํ ๋ถ๋ฅ ์๊ณ ๋ฆฌ์ฆ์ ํตํด์ ํ์ต์์ผ ๋ชจ๋ธ๋งํ๋ ๊ธฐ๋ฒ
๐งฉ ์ ์ฉ ์์ ( ์ด์ง๋ถ๋ฅ )
๐ ๋ํ๊ต ์ํ ์ ๋ ๊ณต๋ถํ ์๊ฐ์ ๊ฐ์ง๊ณ ํด๋น ๊ณผ๋ชฉ์ ์ด์ ์ฌ๋ถ(Pass or fail)๋ฅผ ์์ธกํ๋ ๋ฌธ์
input๊ฐ: ๊ณต๋ถํ ์๊ฐ
output๊ฐ: ์ด์์ฌ๋ถ(Pass or Fail)
์ฌ๊ธฐ์ ์ด์์ฌ๋ถ๋ฅผ 0,1์ด๋ผ๋ ์ด์งํด๋์ค(Binary class)๋ก ๋๋ ์ ์๊ณ , ์ด๋ฐ ๊ฒฝ์ฐ๋ฅผ ์ด์ง ๋ถ๋ฅ(Binary classification)๋ผ๊ณ ๋ถ๋ฅธ๋ค.
๐งฉ ์ ์ฉ ์์ ( ๋ค์ค๋ถ๋ฅ )
๐ ๋ํ๊ต ์ํ ์ ๋ ๊ณต๋ถํ ์๊ฐ์ ๊ฐ์ง๊ณ ํด๋น ๊ณผ๋ชฉ์ ์ฑ์ (A, B, C, D, F)์ ์์ธกํ๋ ๋ฌธ์
input๊ฐ: ๊ณต๋ถํ ์๊ฐ
output๊ฐ: ๊ณผ๋ชฉ์ ์ฑ์ (A,B,C,D,F)
์ฌ๊ธฐ์๋ 5๊ฐ์ output๊ฐ์ด๋ผ 5๊ฐ์ ํด๋์ค๋ก ๋๋ ์ ์๊ธฐ๋๋ฌธ์ ์ด๋ฐ ๊ฒฝ์ฐ๋ฅผ ๋ค์ค ๋ถ๋ฅ(Multi-class classification)๋ผ๊ณ ๋ถ๋ฅธ๋ค.
โ ์ ํ ํ๊ท๋ ?
๋ฐ์ดํฐ๋ฅผ ๋๊ณ ๊ฐ์ฅ ์ ์ค๋ช ํ ์ ์๋ ์ ์ ์ฐพ์ ๋ณ์ ์ฌ์ด์ ์ ํ์ ์ธ(=์ง์ ์ ์ธ) ๊ด๊ณ๋ฅผ ๋ชจ๋ธ๋ง ํ ๊ฒ
์ ํ๋ชจ๋ธ์ ์์ (์ง์ = 1์ฐจํจ์)
H(x) = Wx + b
์ฌ๊ธฐ์ ์ ํํ ๊ฐ์ ์์ธกํ๊ธฐ ์ํด์๋ ๋ด๊ฐ ๋ง๋ ์์์ ์ง์ (๊ฐ์ค)๊ณผ ์ (์ ๋ต)์ ๊ฑฐ๋ฆฌ๊ฐ ์ต๋ํ ๊ฐ๊น์์ ธ์ผํ๋ค. ์ฆ, cost(์์คํจ์)๊ฐ ๋ฎ์์ ธ์ผํ๋ค. ๋ํ ๋ง์ฝ ์ ๋ ฅ๊ฐ์ด 2๊ฐ ์ด์์ด ๋๋ ๋ฌธ์ ๋ฅผ ์ ํํ๊ท๋ก ํ๊ณ ์ ํ๋ค๋ฉด ๋ค์ค์ ํํ๊ท๋ฅผ ์ ์ฉํ๋ค.
โ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ด๋ ?
ํจ์์ ๊ธฐ์ธ๊ธฐ(๊ฒฝ์ฌ)๋ฅผ ๊ตฌํ์ฌ ๊ธฐ์ธ๊ธฐ๊ฐ ๋ฎ์ ์ชฝ์ผ๋ก ๊ณ์ ์ด๋์์ผ ๊ทน๊ฐ(์ต์ ๊ฐ)์ ์ด๋ฅผ ๋๊น์ง ๋ฐ๋ณตํ์ฌ ํ์ตํ๋ ๋ฐฉ๋ฒ
์ฌ๊ธฐ์ ํ์นธ์ฉ ์ ์งํ๋ ๋จ์๋ฅผ Learning rate๋ผ๊ณ ๋ถ๋ฅด๋๋ฐ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ด ํ์ต์ ์ํ๊ธฐ ์ํด์๋ ์ ๋นํ Learning rate๋ฅผ ์ฐพ๋ ๊ฒ์ด ์ค์ํ๋ค. Learning rate๊ฐ ์์ผ๋ฉด ์ต์์ ์ ์ฐพ๊ธฐ๊น์ง ์๊ฐ์ด ์ค๋๊ฑธ๋ฆฌ๊ณ , ๊ทธ๋ ๋ค๊ณ ๋ฐ๋๋ก ๋๋ฌด ํฌ๋ค๋ฉด ์ต์์ ์ ์ง๋ ์ง๋ํ๋ค๊ฐ Overshooting ๋ ์๋ ์๋ค.
โ ๋ฐ์ดํฐ์
๋ถํ
Training set (ํ์ต ๋ฐ์ดํฐ์
)
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ํ์ต์ํค๋ ์ฉ๋๋ก ์ ์ฒด ๋ฐ์ดํฐ์
์ ์ฝ 80% ์ ๋๋ฅผ ์ฐจ์งํ๋ค.
Validation set (๊ฒ์ฆ ๋ฐ์ดํฐ์
)
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ๊ฒ์ฆํ๊ณ ํ๋ํ๋ ์งํ์ ์ฉ๋๋ก ์ ๋ต ๋ผ๋ฒจ์ด ์๊ณ , ๋ชจ๋ธ์ ์ฑ๋ฅ์ ์ํฅ์ ๋ฏธ์น์ง๋ ์์ผ๋ฉฐ ์์ค ํจ์, Optimizer ๋ฑ์ ๋ฐ๊พธ๋ฉด์ ๋ชจ๋ธ์ ๊ฒ์ฆํ๋ ์ฉ๋๋ก ์ฌ์ฉํ๋ค.
Test set (ํ๊ฐ ๋ฐ์ดํฐ์
)
์ ๋ต ๋ผ๋ฒจ์ด ์๋ ์ค์ ํ๊ฒฝ์์์ ํ๊ฐ ๋ฐ์ดํฐ์
import os # ํ๊ฒฝ๋ณ์ ์ง์ ํ๊ธฐ
os.environ['KAGGLE_USERNAME'] = '[๋ด_์บ๊ธ_username]' # username
os.environ['KAGGLE_KEY'] = '[๋ด_์บ๊ธ_key]' # key
```bash # ์ํ๋ ๋ฐ์ดํฐ์
์ API ์คํํ๊ธฐ๊ณ ์์ถํ๊ธฐ
!unzip /content/advertising-dataset.zip
```
!unzip /content/advertising-dataset.zip
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam, SGD
import numpy as np
import pandas as pd # csvํ์ผ์ ์ฝ์๋ ์ฌ์ฉ
import matplotlib.pyplot as plt # ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆด๋ ์ฌ์ฉ
import seaborn as sns # ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆด๋ ์ฌ์ฉ
from sklearn.model_selection import train_test_split # sklearn(๋จธ์ ๋ฌ๋์ ๋์์ฃผ๋ ํจํค์ง) ์ฌ๊ธฐ์ train_test_split(ํธ๋ ์ด๋์
๊ณผ ํ
์คํธ์
์ ๋ถ๋ฅ)ํด๋์ค๋ฅผ ์ธ๊ฑฐ์
df = pd.read_csv('advertising.csv') # csvํ์ผ์ ์ฝ์๋ ์ฌ์ฉ
df.head(5) # ๋งจ์์์ 5์ค ์ถ๋ ฅํด๋ผ df.tail(5)์ ๋ค์์ 5์ค์ถ๋ ฅํ๋ผ๋๋ป
print(df.shape) # ๋ชจ์ ์ดํผ๊ธฐ (200์ค์ง๋ฆฌ ๋ฐ์ดํฐ์
์ด์ 4๊ฐ(ํฐ๋น,๋ผ๋์ค๋ฑ๋ฑ) )
sns.pairplot(df, x_vars=['TV', 'Newspaper', 'Radio'], y_vars=['Sales'], height=4) # ๋ฐ์ดํฐํ๋ ์(df)๋ฅผ ํต์ผ๋ก ๋ฃ๊ณ ๋ด๊ฐ ๋ณด๊ณ ์ถ์ variable๋ง ๋ฝ์์ ํฐ๋น,์ ๋ฌธ,๋ผ๋์ค์ sales ๊ฐ์ ๊ด๊ณ๋ฅผ ๋ณด์ฌ์ค๋ผ๋ ๋ป ๋์ด๋4
x_data = np.array(df[['TV']], dtype=np.float32) # ์
๋ ฅ๊ฐ ํฐ๋น๋ง ์ถ์ถ
y_data = np.array(df['Sales'], dtype=np.float32) # ์ถ๋ ฅ๊ฐ ์ธ์ผ์ฆ๋ง ์ถ์ถ
print(x_data.shape) # ๋ชจ์์ถ๋ ฅ
print(y_data.shape)
x_data = x_data.reshape((-1, 1)) # reshape((-1, 1)์ฌ๊ธฐ์ -1์ ๋จ์ ์๋งํผ ์์์ ๋ณํํด๋ผ ๋ค์๋ ๋ฌด์กฐ๊ฑด1์ด๋์ผํ๋ค.
y_data = y_data.reshape((-1, 1))
print(x_data.shape)
print(y_data.shape)
x_train, x_val, y_train, y_val = train_test_split(x_data, y_data, test_size=0.2, random_state=2021) #20%๋ ํ
์คํธ๋ฐ์ดํฐ์
์ผ๋ก ์ฐ๊ณ 80%๋ ํธ๋ ์ธ์
์ผ๋ก ๋๋ ์ค๋ผ / random_state ๋๋ค์ผ๋ก ๋ณ์ ์ง์
print(x_train.shape, x_val.shape) # ๋ฐ์๋ ํธ๋ ์ด๋๋ฐ์ดํฐ๋ 160๊ฐ๊ณ , ๋ฐธ๋ฆฌ๋ฐ์ด์
๋ฐ์ดํฐ๋ 40๊ฐ๋ค ์ฆ 160๊ฐ ๋ฐ์ดํฐ๋ก ํ์ต์ํค๊ณ 40๊ฐ๋ก ๊ฒ์ฆํ๊ฒ ๋ค.
print(y_train.shape, y_val.shape)
model = Sequential([
Dense(1) # ์ธ์ผ์ฆ ํ๋๋ง ์์ธก
])
model.compile(loss='mean_squared_error', optimizer=Adam(lr=0.1))
model.fit(
x_train,
y_train,
validation_data=(x_val, y_val), # ๊ฒ์ฆ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ํ epoch์ด ๋๋ ๋๋ง๋ค ์๋์ผ๋ก ๊ฒ์ฆ
epochs=100 # epochs ๋ณต์ํ์ผ๋ก ์ฐ๊ธฐ! / 100๋ฒ ๋ฐ๋ณต ํ์ตํด๋ผ
)
y_pred = model.predict(x_val)
plt.scatter(x_val, y_val) # scatter ์ ์ฐ๋ ๊ทธ๋ํ
plt.scatter(x_val, y_pred, color='r') # ์ ๋ต๊ฐ๊ณผ ์์ธก๊ฐ์ ๊ทธ๋ฆฌ๋๋ฐ ์์ธก๊ฐ์ ๋นจ๊ฐ์
plt.show()
๊ฐ์๋ฅผ ๋ฃ๊ธฐ ์ ๊น์ง ๋จธ์ ๋ฌ๋์ ๊ธฐ๊ณ๋ฅผ ํ์ต์ํจ๋ค๋ ๋ป์ด๋ผ๋ ๊ฒ๋ง ์๊ณ ์์๋ค. ์์ด์ ์ํ๊น์ง ๋ฐฐ์ธ๊ฑฐ๋ผ๊ณ ๋ ์์์น๋ชปํ๋๋ฐ ๋ฐฐ์ฐ๋ ์ฃผ๋ ๋ถ๋ถ์ด ์์ด์ ์ํ์์ ๊นจ๋ซ๊ณ ๋ง์ด ๊ฑฑ์ ๋์๋ค. ๋จธ์ ๋ฌ๋์ ์ด์ฉํด์ ์ด๋ป๊ฒ ์ฌ๋ฌผ์ธ์์ ํ ์ ์๋ ๊ฑด์ง ์์ง ๊ฐ์ด ์กํ์ง ์์์ ๊ฑฑ์ ๋ ๋๋ ํํธ ๋๋ฌด ๊ถ๊ธํ๊ธฐ๋ ํ๋ค.
์ค๋๋ถํฐ ํ์ด ์๋ก ๊ตฌ์ฑ๋์๋ค. ์คํ๋ ํธ๋น๋ ์ฐ์ง๋ ์ฐ๋ฆฌ ํํ๋ก์ ํธ ์ํด๋ด
์๋ค์ ๐
๐ ์์ธํ ์ฝ๋๋ colab ์ ๊ฒ์ํ์ต๋๋ค