Introduction
โข
Datamining Process
โฆ
๋ชฉ์ ๊ฒฐ์ โ ๋ฐ์ดํฐ ์์ง โ ๋ฐ์ดํฐ ํ์ ๋ฐ ์ ์ โ ๋ฐ์ดํฐ ๋ง์ด๋ ๋ฐฉ๋ฒ ๊ฒฐ์ โ ์ต์ข
๋ชจ๋ธ ๊ฒฐ์ โ ์ฑ๋ฅ ํ๊ฐ โ ์ ์ฉ
โข
Programming vs Machine Learning
โฆ
์ ํต์ ์ธ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ๋ฐ์๊ฐ ์ง์ ๋ฌธ์ ํด๊ฒฐ์ ์ํ ๊ท์น์ ์์ฑํ์ฌ ์ปดํจํฐ์ ์
๋ ฅํ๋ค. ์ปดํจํฐ๋ ์
๋ ฅ๋๋ ๋ฐ์ดํฐ์ ๊ท์น์ ์ ์ฉํ์ฌ ์ถ๋ ฅ์ ์์ฑํ๋ค.
โฆ
๋จธ์ ๋ฌ๋์ ์ํ๋ ์ถ๋ ฅ์ ์์ฑํ๋ ๊ท์น์ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ ์์ฑํ์ฌ ๋ฐ์ดํฐ์ ํจ๊ป ์
๋ ฅํ์ฌ ๋ชจ๋ธ์ ํ์ตํ๋ค. ํ์ต๋ ๋ชจ๋ธ์ ์๋กญ๊ฒ ์ฃผ์ด์ง๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐํ์ผ๋ก ์์ธก/๋ถ๋ฅ ๋ฑ์ ์ํํ๋ค.
Main idea
โข
๋ถ๋ฅ์ ์์ธก(ํ๊ท)
โฆ
๋ถ๋ฅ
โช
๋ถ๋ฅ๋ ๊ฐ ๋ฐ์ดํฐ๊ฐ ์ด๋ค Class์ ์ํ๋์ง ํ๋จํ๋ ๋ฌธ์ ์ด๋ค.
โช
๋ถ๋ฅ ๋ชจ๋ธ ํ์ต์ x(๋ฐ์ดํฐ) ๋ฅผ y(๋ฒ์ฃผ)๋ก ์ ์ ํ๊ฒ mappingํ๋ ํจ์ f๋ฅผ ์ฐพ๋ ๊ณผ์ ์ด๋ค.
โช
๋ฐ๋ผ์ ๊ฐ ๋๋๋ก ๋ชจ๋ธ์ ํ์ตํ๋ค.
โฆ
์์ธก(ํ๊ท)
โช
์์ธก(ํ๊ท)๋ ๊ฐ ๋ฐ์ดํฐ๊ฐ ์ด๋ค ์ฐ์์ ์ธ ๊ฐ์ ๊ฐ๊น์ด์ง๋ฅผ ํ๋จํ๋ ๋ฌธ์ ์ด๋ค.
โช
ํ๊ท ๋ชจ๋ธ์ ํ์ต์ x(๋ฐ์ดํฐ) ๋ฅผ y(์ฐ์ํ)๋ก ์ ์ ํ๊ฒ mappingํ๋ ํจ์ f๋ฅผ ์ฐพ๋ ๊ณผ์ ์ด๋ค.
โช
๋ฐ๋ผ์ ๊ฐ ์ต์๊ฐ ๋๋๋ก ๋ชจ๋ธ์ ํ์ตํ๋ค.
โข
์ฐ๊ด ๊ท์น๊ณผ ์ถ์ฒ์์คํ
โฆ
์ฐ๊ด์ฑ ๋ถ์
โช
์ด๋ค ์์ดํ
๋ค์ด ํจ๊ป ๋ฐ์ํ๋ ๊ฒฝํฅ์ด ์๋๊ฐ?๋ฅผ ์ฐพ๋ ๊ธฐ๋ฒ
โช
๋งํธ์์๋ ์ ํ ๊ฐ ์ฐ๊ด์ฑ์ ๋ถ์ํ์ฌ ์ฐ๊ด์ฑ์ด ๋์ ์ ํ์ ๊ฐ์ ์์น์ ์ง์ดํ๋ค.
โฆ
์ถ์ฒ ์์คํ
-ํ์
ํํฐ๋ง
โช
์ฌ์ฉ์๋ค์ ์ ํธ๋๋ฅผ ํ์ตํด์ ๊ฐ์ธํ๋ ์ถ์ฒ์ ํ๋ ๊ธฐ๋ฒ
โช
A ์ฌ์ฉ์๊ฐ B ์ฌ์ฉ์์ ์ ์ฌํ ์ทจํฅ์ด๋ผ๋ฉด, B๊ฐ ๋ณธ ์ํ๋ฅผ A์๊ฒ ์ถ์ฒ
โข
๋ฐ์ดํฐ ์ถ์์ ์ฐจ์ ์ถ์
โฆ
๋ง์ ์์ด ๊ด์ธก์น๋ฅผ ์ ์ ์์ ๊ทธ๋ฃน์ผ๋ก ์์ฝํ๋ ๊ณผ์ ์ ๋ฐ์ดํฐ ์ถ์๋ผ๊ณ ํ๋ฉฐ, ๋ํ์ ์ผ๋ก ๊ตฐ์ง ๋ถ์์ด ์๋ค.
โฆ
๋ณ์์ ๊ฐ์๋ฅผ ์ค์ด๋ ๊ณผ์ ์ ์ฐจ์ ์ถ์๋ผ ํ๋ฉฐ, ๋ํ์ ์ผ๋ก PCA(์ฃผ์ฑ๋ถ ๋ถ์)์ด ์๋ค.
โข
๋ฐ์ดํฐ ํ์๊ณผ ์๊ฐํ
โฆ
๋ฐ์ดํฐ ํ์ ์ ๊ฐ ๋ณ์์ ํน์ง, ๋ณ์ ์ฌ์ด์ ๊ด๋ จ์ฑ ๋ถ์์ด ๊ฐ๋ฅํ๋ค.
โฆ
์๋ฅผ ๋ค์ด ๋ฐ์ดํฐ ์๊ฐํ๋ฅผ ํตํด ์ด์์น ๋ฑ์ ํ์์ด ๊ฐ๋ฅํ๋ค.
โข
์ง๋ํ์ต๊ณผ ๋น์ง๋ํ์ต
โฆ
์ง๋ํ์ต
โช
์ ๋ต ๊ฐ y๋ฅผ ๊ธฐ๋ฐ์ผ๋ก x๋ฅผ y๋ก mappingํ๋ ํจ์๋ฅผ ํ์ตํ๋ ๋ฐฉ๋ฒ (ํจ์์ parameter๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ)
โช
๋ํ์ ์ผ๋ก ๋ฒ์ฃผํ ์ ๋ต ๊ฐ์ ๊ฐ์ง ๋ถ๋ฅ(๋ก์ง์คํฑ ํ๊ท, SVM ๋ฑ)์ ์ฐ์ํ ์ ๋ต ๊ฐ์ ๊ฐ์ง ํ๊ท(๋จ์ ์ ํ ํ๊ท, ๋คํญ ํ๊ท ๋ฑ)๋ก ๊ตฌ๋ถ๋๋ค.
โฆ
๋น์ง๋ํ์ต
โช
์
๋ ฅ๊ฐ x์ ๋ํด์ ๋ด์ฌ๋ ๊ตฌ์กฐ/ํจํด์ ์ฐพ๋ ๊ฒ์ ๋ชฉํ๋ก ํ๋ค.
โช
์ ๋ต ๊ฐ์ด ์กด์ฌํ์ง ์์ผ๋ฉฐ ๋ฒ์ฃผํ ์ถ๋ ฅ๊ฐ(์ ์ฌ๋ณ์)๋ฅผ ๊ฐ์ง Clustering๊ณผ ์ฐ์ํ ์ถ๋ ฅ๊ฐ์ ๊ฐ์ง PCA๋ก ํฌ๊ฒ ๊ตฌ๋ถ๋๋ค.
Preprocessing
โข
๋ฐ์ดํฐ ๊ตฌ์กฐ
โฆ
์ผ๋ฐ์ ์ผ๋ก ๋ฐ์ดํฐ๋ ๊ด์ธก์น์ ๋ณ์๋ก ๊ตฌ์ฑ๋๋ฉฐ ๊ด์ธก์น๋ ํ, ๋ณ์๋ ์ด์ ์์นํ๋ค.
โข
Pandas๋ฅผ ํ์ฉํ ๋ฐ์ดํฐ ๊ตฌ์กฐ ๋ถ์
import pandas as pd
df = pd.read_csv('dmba/WestRoxbury.csv') # ๋ฐ์ดํฐ ๋ถ๋ฌ์ค๊ธฐ
df.shape # ๋ฐ์ดํฐ ๊ตฌ์กฐ ํ์ธ
df.head() # ์ฒ์ 5๊ฐ ํ ํ์ธ
df.describe() # ๊ฐ์ข
ํต๊ณ๋ ์์ฝ
df = df.rename(columns={'TOTAL VALUE':'TOTAL_VALUE'}) # ๋ณ์๋ช
๋ณ๊ฒฝ
df.columns = [s.strip().replace(' ','_') for s in df.columns] # 1. ์ ๋ค ๊ณต๋ฐฑ ์ ๊ฑฐ 2. ์ค๊ฐ ๊ณต๋ฐฑ _๋ก ๋ณ๊ฒฝ
# ์ฌ๋ผ์ด์ฑ (๋์ผ ๊ฒฐ๊ณผ)
df['TOTAL_VALUE'].iloc[0:10] # iloc (index ๊ธฐ๋ฐ ์ ๊ทผ), loc(๋ณ์๋ช
๊ธฐ๋ฐ ์ ๊ทผ)
df.iloc[0:10,0]
df.iloc[0:10].TOTAL_VALUE #๋ณ์๋ช
์ ๊ณต๋ฐฑ์ด ์๋ ๊ฒฝ์ฐ ์ฌ์ฉ ๊ฐ๋ฅ
# concat (0=rows, 1=columns)
pd.concat([df.iloc[0:5,0:2], df.iloc[0:5,6:8]], axis=1)
# ํต๊ณ๋ ํ์ธ
df['TOTAL_VALUE'].mean()
# ๊ด์ธก์น ๊ฐ์ (n_obs)
len(df['TOTAL_VALUE'])
Python
๋ณต์ฌ
โข
Dataset Sampling/Data imbalance
์์์ ํ๊ณ๋ก ๋ชจ๋ธ ๊ตฌ์ถ ์ ๋ชจ๋ ๊ด์ธก์น๋ฅผ ์ฌ์ฉํ์ง๋ ์๋๋ค. ๋ง์ฝ ์ ์ ๋ฐ์ดํฐ๋ก๋ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ์ฉํ์ ๋์ ๊ฐ์ ํจ๊ณผ๋ฅผ ๋ณผ ์ ์๋ค๋ฉด, ์ ์ ๋ฐ์ดํฐ๋ฅผ ํ์ฉํ๋ ๊ฒ์ด ํจ์จ์ ์ด๋ค.
โฆ
Oversampling & Undersampling
โช
๋ถ๋ฅ ๋ฌธ์ ์ ๊ฒฝ์ฐ ์ง๋จ ๊ฐ ๋ฐ์ดํฐ ๋น์ค์ด ๋ถ๊ท ํํ ์ ์์ผ๋ฉฐ ์ด ๊ฒฝ์ฐ ๋ชจ๋ธ ์ฑ๋ฅ ์ ํ๊ฐ ๋ฐ์ํ ์ ์๋ค.
โช
Oversampling์ ์ง๋จ ๊ฐ ๋น์ค์ด ๋น์ทํด์ง๋๋ก ๋น์ค์ด ์์ ์ง๋จ์ ์ํ๋ ๊ด์ธก๊ฐ์ ๋๋ค์ผ๋ก ์ฌ์ถ์ถํ๊ฑฐ๋ ์์ ์ง๋จ์ ๋ ํฐ ๊ฐ์ค์น๋ฅผ ์ฃผ์ด ์ถ์ถํ๋ ๋ฐฉ์์ด๋ค. (์. SMOTE)
โช
Undersampling์ ๋น์ค์ด ํฐ ์ง๋จ์ ์ํ๋ ๊ด์ธก์น๋ฅผ ๋๋ค์ผ๋ก ์ ๊ฑฐํ๋ ๋ฐฉ์์ด๋ค.
w = [0.9 if rooms>10 else 0.01 for rooms in df.ROOMS ] # ๋ฐฉ์ด 10๊ฐ ์ด์์ธ ๊ฒฝ์ฐ ๊ฐ์ค์น 0.9
df.sample(5,weights=w)
Python
๋ณต์ฌ
โฆ
Sampling ๋ฟ ์๋๋ผ ์ค๋ถ๋ฅ์ ๊ฐ์ค์น๋ฅผ ์ฃผ์ด ๋ถ๊ท ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
โช
์๋ฅผ ๋ค์ด, ์ฌ๊ธฐ ๊ฑฐ๋ ํ์ง์ ์์ด ํ์งํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ์ ๋ํ penalty๋ฅผ ๋์ฑ ๊ฐํ๊ฒ ์ฃผ์ด ๋ถ๊ท ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
โฆ
๋ถ๊ท ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผํ๋ ์ด์
โช
Accuracy ์ธก๋ฉด์์ ๋ชจ๋ ์์ class๋ฅผ ์ค๋ถ๋ฅํ์ฌ๋ ์ ์ฒด Accuracy๋ ๋์ ์ ์๋ค.
โข
Variable/obs
โฆ
๋ณ์ ์ข
๋ฅ
โช
์ฐ์ํ/๋ฒ์ฃผํ
โช
๋ฒ์ฃผํ์ ๊ฒฝ์ฐ ๋ณ์ ๊ฐ์ ์์๊ฐ ์๋ ๋ช
๋ชฉํ ๋ณ์์ ์์๋ก ํํ ๊ฐ๋ฅํ ์์ํ ๋ณ์๋ก ๊ตฌ๋ถํ ์ ์๋ค.
df.REMODEL=df.REMODEL.astype('category') # ๋ฒ์ฃผํ ๋ณ์๋ก ๋ณํ
df.REMODEL.cat.categories # ๋ฒ์ฃผ ํ์ธ
df.REMODEL.dtype
Python
๋ณต์ฌ
โฆ
๋ฒ์ฃผํ ๋ณ์ ์ฒ๋ฆฌ
โช
์์ํ ๋ณ์์ ๊ฒฝ์ฐ ์ฐ์ํ ๋ณ์๋ก ๊ฐ์ฃผํ๋ค.
โช
๋ฒ์ฃผ์ ์์๊ฐ ์๋ค๋ฉด ๊ฐ๋ณ์(Dummy variable)๋ก ์ฒ๋ฆฌํ๊ฑฐ๋, One-hot-encoding์ ์ฌ์ฉํ๋ค.
โช
์ฃผ๋ก ์ ํ ํ๊ท์ ๋ก์ง์คํฑ ํ๊ท์์๋ ๊ฐ๋ณ์๋ฅผ ํ์ฉํ๋ฉฐ, ์ ๊ฒฝ๋ง ๊ธฐ๋ฐ ๋ถ๋ฅ ๋ชจ๋ธ์ ๊ฒฝ์ฐ One-hot-encoding์ ์ฃผ๋ก ํ์ฉํ๋ค.
df = pd.get_dummies(df,prefix_sep = "_", drop_first=True) # ์ฒซ ๋ฒ์ฃผ๋ฅผ ๊ฐ๋ณ์ ์์ฑ์์ ์ ๊ฑฐํ์ฌ ์์ ๊ณต์ ์ฑ ๋ฌธ์ ํด๊ฒฐ
Python
๋ณต์ฌ
๊ฐ๋ณ์ ์์ฑ ์ ๋ฒ์ฃผ ์์ ๋์ผํ ๊ฐ๋ณ์๋ฅผ ์์ฑํ ๊ฒฝ์ฐ ๋ค๋ฅธ ๋ณ์๊ฐ ๋๋จธ์ง ๋ณ์์ ์ ํ ๊ฒฐํฉ์ผ๋ก ํํ๋ ์ ์์ด ์์ ๊ณต์ ์ฑ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. ์์ ๊ณต์ ์ฑ ๋ฌธ์ ๋ ํนํ ํ๊ท๋ถ์์์ ํ๊ท ๊ณ์ ์ถ์ ์ ์ฌ์ฉํ๋ ํ๋ ฌ์ด singular matrix๊ฐ ๋์ด, ๊ณ์ ์ถ์ ์ด ๋ถ๊ฐํ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ๋ฏ๋ก ์ค์ํ ๋ฌธ์ ์ด๋ค.
โฆ
๋ณ์ ์ ํ
โช
๋ชจ๋ธ ๊ตฌ์ถ ์ ๋ง์ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋์ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ฅํ์ง๋ ์๋๋ค.
โช
์๋ฅผ ๋ค์ด ํ๊ท๋ถ์์์๋ ์ ์ง์ ํ๋ฒ, ํ์ง์ ๊ฑฐ๋ฒ, ๋จ๊ณ์ ํ๋ฒ ๋ฑ์ ํ์ฉํ์ฌ ๋ชจ๋ธ์ ํฌํจ๋ ๋ณ์๋ฅผ ๊ฒฐ์ ํ๋ฉฐ, ๊ฐ๋ฅํ ์ ์ ์์ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ชจ์ ์ถ์ ์ ๋ํ ๋ถ์ฐ์ ๊ฐ์์ํด์ด ์๋ ค์ ธ์๋ค.
โฆ
ํ์ ๋ณ์์ ๊ด์ธก์น ์
โช
ํต๊ณ์์๋ โํ์ ๊ณ์ฐ์ ํตํด ๋ชจ์ง๋จ์ ์ ์ค๋ช
ํ ์ ์๋ ์ ์ ํ๋ณธ ์๋ฅผ ์ ์ ์์ผ๋, ๋ฐ์ดํฐ ๋ง์ด๋์์๋ ๋ชจ์ง๋จ์ ์ ์ค๋ช
ํ๋ ๊ฒ๋ณด๋ค ์ ํํ ๋ถ๋ฅ/์์ธก์ด ์ค์ํ๋ฏ๋ก ๋ ๋ง์ ๊ด์ธก์น๋ฅผ ํ์๋ก ํ๋ค.
โช
์ผ๋ฐ์ ์ผ๋ก ๋ณ์๋น 10๊ฐ์ ๊ด์ธก์น๋ก ์ ์ ๊ด์ธก์น ๊ฐ์๋ฅผ ์ ํ๋ค.
โช
Delmaster-Hancock ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ๋ถ๋ฅ ๋ฌธ์ ์ ํ์ํ ์ต์ ๊ด์ธก์น๋ฅผ ๋ก ์ค์ ํ๋ค. (๊ฐ๊ฐ์ Class ๊ฐ์์ ๋ณ์ ๊ฐ์)
โฆ
์ด์์น
โช
๊ธฐ์กด ๋ฐ์ดํฐ๋ค๋ก๋ถํฐ ๋ฉ๋ฆฌ ๋จ์ด์ง ๋ฐ์ดํฐ๋ฅผ ์ด์์น๋ผ๊ณ ํ๋ค.
โช
์ผ๋ฐ์ ์ผ๋ก ํ๊ท ์ผ๋ก๋ถํฐ ํ์คํธ์ฐจ์ ์ธ ๋ฐฐ๊ฐ ๋๋ ๋ฒ์๋ฅผ ๊ธฐ์ค์ผ๋ก ํ๋ค.
โช
๊ฐ๋จํ ๋ฐฉ๋ฒ์ผ๋ก๋ ๋ณ์๋ณ๋ก ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ/์ต๋๊ฐ/์ต์๊ฐ์ ์ด์ฉํ๋ ๊ฒ์ด๋ค.
df['TOTAL_VALUE'].max()
df['TOTAL_VALUE'].min()
df.sort_values(by='TOTAL_VALUE', ascending=False)
Python
๋ณต์ฌ
โฆ
๊ฒฐ์ธก์น
โช
๊ฒฐ์ธก์น๊ฐ ์๋ ๊ฒฝ์ฐ ํด๋น ๊ด์ธก์น ์ ์ฒด๋ฅผ ์ญ์ ํ๊ฑฐ๋ ํ๊ท /์ค์๊ฐ ๋ฑ์ ํ์ฉํ์ฌ ๋์ฒดํ๋ค.
โช
๊ฐ์ ๋์ฒดํ๋ ๊ฒฝ์ฐ ์ค์ ๋ฐ์ดํฐ๋ณด๋ค ๋ถ์ฐ์ด ์์์ง๋ ๋ฌธ์ ๊ฐ ์๋ค.
# ๊ฒฐ์ธก์น ์์ฑ
m_rows = df.sample(10).index
df.loc[m_rows,'BEDROOMS'] = np.nan
print(df['BEDROOMS'].count())
# ๊ฒฐ์ธก์น ์ ๊ฑฐ
df_new = df.dropna()
print(df_new['BEDROOMS'].count())
# ๊ฒฐ์ธก์น ์ค์๊ฐ ๋์ฒด
med = df['BEDROOMS'].median()
df.BEDROOMS = df.BEDROOMS.fillna(value=med)
print(df['BEDROOMS'].count())
Python
๋ณต์ฌ
โฆ
ํ์คํ
โช
์ผ๋ฐ์ ์ธ ๋ฐ์ดํฐ ์ ๊ทํ ๊ณผ์ ์ ๊ฐ ๊ด์ธก์น์์ ํด๋น ๋ณ์์ ํ๊ท ๊ฐ์ ๋นผ๊ณ ํ์คํธ์ฐจ๋ก ๋๋ z-score๋ฅผ ์ป๋ ๋ฐฉ์์ผ๋ก ์งํ๋๋ค.
โช
๋ชจ๋ ๋ณ์๋ฅผ [0,1] ์ค์ผ์ผ๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ๋ ์กด์ฌํ๋ค.
โช
์ ๊ทํ/ํ์คํ๋ ๊ฐ ๋ฐ์ดํฐ๊ฐ ์๋ก ๋ค๋ฅธ ๋จ์ (์. m์ km)๋ก ์์ฑ๋ ๊ฒฝ์ฐ ๋ฐ๋์ ํ์ํ ์์
์ด๋ค.
# pandas
df1 = pd.read_csv('dmba/WestRoxbury.csv')
df1 = df.rename(columns={'TOTAL VALUE':'TOTAL_VALUE'})
df1.columns = [s.strip().replace(' ','_') for s in df.columns]
norm_df = (df1-df1.mean())/df1.std()
norm_df
# scikit-learn
# train data -> fit_transform, validation data -> transform
# validation data์ train data์ ๊ฐ์ ์์ค์ scaling์ ์ ์ฉํ๊ธฐ ์ํจ
scaler = StandardScaler()
norm_df = pd.DataFrame(scaler.fit_transform(df1), index= df1.index, columns = df1.columns) #np_array -> pandas
norm_df
# pandas
norm_df = (df1-df1.min())/(df1.max()-df1.min())
norm_df
# scikit-learn
scaler = MinMaxScaler()
norm_df = pd.DataFrame(scaler.fit_transform(df1), index= df1.index, columns = df1.columns)
norm_df
Python
๋ณต์ฌ
Overfitting/Underfitting
โข
Overfitting
โฆ
Train data error๋ ๋ฎ์ผ๋, Test data error๊ฐ ๋์ ๊ฒฝ์ฐ
โฆ
Low Bais, High Variance
โฆ
๊ด์ธก์น์ ์๊ฐ ๋ณ์์ ์๋ณด๋ค ์ ์ ๊ฒฝ์ฐ ๋ฐ์
โข
Underfitting
โฆ
Train data error, Test data error๊ฐ ๋์ ๊ฒฝ์ฐ
โฆ
High Bais, Low Variance
โ ์ด๋ค์ ํด๊ฒฐํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ๋ฐ์ดํฐ ์๋ฅผ ๋๋ฆฌ๋ ๊ฒ์ด๋ค.
โข
Train/Validation/Test Data
โฆ
์ ํฉํ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํ๊ฐํ ๋, ํ์ต ๊ณผ์ ์์ ์ฌ์ฉํ ๋ฐ์ดํฐ๋ฅผ ํตํด ํ๊ฐํ๋ค๋ฉด, overfitting ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค.
โฆ
์ด๋ฅผ ๋ฐฉ์งํ๊ณ ์ ๋ฐ์ดํฐ๋ฅผ ํฌ๊ฒ Train/Validation/Test Data์ผ๋ก ๋๋คํ๊ฒ ๋ถํ ํ์ฌ ์ฌ์ฉํ๋ค.
โฆ
์ฌ๊ธฐ์ ํ์ต ๋ฐ์ดํฐ๋ ๋ชจ๋ธ ๊ตฌ์ฑ์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ์ด๊ณ , ๊ฒ์ฆ ๋ฐ์ดํฐ๋ ํ์ต๋ ๋ชจ๋ธ์ ์ฑ๋ฅ ํ๊ฐ ๋ฐ hyperparameter๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐ ์ฌ์ฉํ๋ค. ํ๊ฐ ๋ฐ์ดํฐ๋ ์๋ก์ด ๋ฐ์ดํฐ์ด๊ฑฐ๋ hyperparameter๊น์ง ๊ฒฐ์ ๋์ด ์ ํฉ๋ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํ๊ฐํ๋๋ฐ ์ฌ์ฉ๋๋ค.
โข
Cross-Validation(CV)
โฆ
๋ชจ๋ธ์ ์ฑ๋ฅ์ ๊ฒ์ฆํ๋ ๊ณผ์ ์์ ๋ชจ๋ธ์ด ์ฐ์ฐํ ์ ํ๋ test data์์ ์ฑ๋ฅ์ด ๋์ ๊ฐ๋ฅ์ฑ์ด ์๋ค. ๋๋ ๋ฐ์ดํฐ ์์ด ์ ์ ๊ฒฝ์ฐ ์ด๋ค์ ๋ถํ ํ์ฌ ์ฌ์ฉํ๋ ๋ฐฉ์์ด ์ ํฉํ์ง ์์ ์ ์๋ค.
โฆ
CV๋ ์ ์ฒด ๋ฐ์ดํฐ๋ฅผ ์ค์ฒฉ๋์ง ์๋๋ก k๊ฐ์ fold๋ก ๋๋๊ณ k-1๊ฐ๋ฅผ ์ฌ์ฉํด ๋ชจ๋ธ์ ๊ตฌ์ถํ๊ณ ๋๋จธ์ง 1๊ฐ fold๋ก ๊ฒ์ฆํ๋ ๊ณผ์ ์ k๋ฒ ๋ฐ๋ณตํ๋ค. ์ดํ k๊ฐ์ ๊ฒ์ฆ ๊ณผ์ ์์์ ํ๊ท ์ ํตํด ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํ๊ฐํ๋ค.
# Train(60%) Validation(30%) Test(10%)
trn, temp = train_test_split(df, test_size=0.4, random_state=1 )
val, tst = train_test_split(temp, test_size=0.1, random_state=1)
Python
๋ณต์ฌ
์์ : ์ ํ ํ๊ท ๋ถ์์ ํ์ฉํ ์ฃผํ ๊ฐ๊ฒฉ ์์ธก
1.
TAX ๋ณ์๋ ์ฃผํ ๊ฐ๊ฒฉ์ด ๊ฒฐ์ ๋์ด์ผ ๊ฒฐ์ ํ ์ ์๋ ๋ด์ฉ์ด๋ฏ๋ก ์ ์ธ
2.
๋ฒ์ฃผํ ๋ณ์์ ๊ฐ๋ณ์ ๋ณํ
3.
์ฐ์ํ ๋ณ์์ ์์ธก ๋ฌธ์ ์ด๊ณ , ์ ๋ต์ด ์๋ ๋ฐ์ดํฐ์ด๋ฏ๋ก ํ๊ท๋ถ์์ ํ์ฉ
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.linear_model import LinearRegression
df = pd.read_csv('dmba/WestRoxbury.csv')
df = df.rename(columns={'TOTAL VALUE':'TOTAL_VALUE'})
df.columns = [s.strip().replace(' ','_') for s in df.columns]
df = pd.get_dummies(df,prefix_sep = "_", drop_first=True)
ex_col = ['TOTAL_VALUE','TAX']
pre = [i for i in df.columns if i not in ex_col]
out = 'TOTAL_VALUE'
x = df[pre]
y = df[out]
trn_x,tst_x,trn_y, tst_y = train_test_split(x,y,test_size=0.3, random_state=1)
model = LinearRegression()
model.fit(trn_x,trn_y)
pred = model.predict(tst_x)
# MAE
mae = metrics.mean_absolute_error(tst_y, pred)
# MSE
mse = metrics.mean_squared_error(tst_y, pred)
# RMSE
rmse = mse ** 0.5
print(f'MAE: {mae}, MSE: {mse}, RMSE: {rmse}')
Python
๋ณต์ฌ