Introduction
โข
๋ณ์์ ์๊ฐ ๋์ด๋๋ ๊ฒฝ์ฐ
โฆ
๋ฒ์ฃผํ ๋ณ์์ ๋ํ ๊ฐ๋ณ์ ์์ฑ
โฆ
๋ณ์ ๋ณํ (ex. log ๋ณํ ๋ฑ.)
โ ๋ณ์ ์ฌ์ด์ ๋์ ์๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง ๊ฐ๋ฅ์ฑ์ด ์ปค์ง๋ฉฐ, ์ด๋ ๊ณผ์ ํฉ ํ์์ ์์ธ์ด ๋๋ค.
์ฐจ์์ ์ ์ฃผ
โข
๋ชจ๋ธ์ ์ฐจ์
โฆ
๋ชจ๋ธ์ด ์ฌ์ฉํ ๋
๋ฆฝ ๋ณ์์ ๊ฐ์
โข
์ฐจ์์ ์ ์ฃผ
โฆ
๋ค๋ณ๋ ๋ฐ์ดํฐ ๋ชจ๋ธ์ ๋ณ์๋ฅผ ์ถ๊ฐํจ์ผ๋ก์จ ์ผ๊ธฐ๋๋ ๋ฌธ์
โฆ
๋ณ์๊ฐ ์ถ๊ฐ๋จ์ ๋ฐ๋ผ ๋ฐ์ดํฐ ๊ณต๊ฐ์ด ์ค์ด๋ค๊ณ , ์ด์ ๋ฐ๋ผ ๋ถ๋ฅ/์์ธก ๋ชจ๋ธ์ ๊ตฌํ๋ ๊ฒ์ด ์ด๋ ค์์ง๋ค.
โช
์๋ฅผ ๋ค์ด ์ด๋ค 2์ฐจ์ ๊ณต๊ฐ์์ ํน์ ๋ ์ ์ ๋งค์ฐ ๊ฐ๊น๊ณ ๋ค๋ฅธ ์ ๊ณผ์ ๊ฑฐ๋ฆฌ๋ ์๋นํ ๋ฉ ์ ์๋ค. ๊ทธ๋ฌ๋ ์ด๊ฒ์ 100์ฐจ์ ๊ณต๊ฐ์ผ๋ก ํ์ฅํ๋ค๋ฉด ๋ชจ๋ ์ ์ด ๋น์ทํ๊ฒ ๋ฉ์ด์ง๋ ํํ๋ฅผ ์ด๋ฃจ๊ฒ ๋ ๊ฒ์ด๋ค. ์ด๋ ๋ ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ ์ฌ์ฑ์ ํ๋จํ๊ธฐ ์ด๋ ต๊ฒ ๋ง๋๋ ์์ธ์ด ๋๋ค.
โ ์ ํ๋์ ํฌ์์ ์ต์๋ก ํ์ฌ ๋
๋ฆฝ ๋ณ์์ ์ฐจ์์ ์ถ์ํ๋ ๋ฐฉ๋ฒ์ ์ฐพ๋ ๊ฒ์ด ์ค์ํ๋ค.
๋ฐ์ดํฐ ์์ฝ
โข
ํต๊ณ๋ ํ์ธ
โฆ
๋ฐ์ดํฐ์ ๋ํ ์์น์ ์์ฝ์ ๋ฐ์ดํฐ ์ถ์ฝ์์ ์ค์ํ ์ ๋ณด๋ฅผ ์ ๊ณตํ๋ค.
import numpy as np
import pandas as pd
from sklearn import preprocessing
import matplotlib.pylab as plt
df = pd.read_csv('dmba/BostonHousing.csv')
df = df.rename(columns={'CAT. MEDV':'CAT_MEDV'})
# ๋ชจ๋ ๋ณ์์ ๊ฐ์
# ๊ด์ธก์น ๊ฐ์, ํ๊ท , ํ์ค ํธ์ฐจ, ์ต์๊ฐ, ์ต๋๊ฐ, ์ฌ๋ถ์ ์ ์ ๊ณต
df.describe()
# ๊ทน๋จ๊ฐ ๊ฒ์ถ
m = df.CRIM.min()
M = df.CRIM.max()
# ๋ณ์์ ์ค์ฌ๊ฐ์ ๋ํ ์ ๋ณด ์ ๊ณต
# ํ๊ท ๊ณผ ์ค์๊ฐ ๊ฐ์ ํธ์ฐจ๊ฐ ํฌ๋ค = ๋ฐ์ดํฐ๊ฐ ์น์ฐ์ณ์ ธ ์๋ค
# ex. ํ๊ท > ์ค์๊ฐ : ์ค๋ฅธ์ชฝ์ผ๋ก ๊ผฌ๋ฆฌ๊ฐ ๊ธด ๋ถํฌ
med = df.CRIM.median()
mea = df.CRIM.mean()
# ๋ฐ์ดํฐ๊ฐ ํผ์ง ์ ๋์ ๋ํ ์ ๋ณด -> ํ์คํธ์ฐจ
std_ = df.CRIM.std()
# ๊ฒฐ์ธก์น ์ ๋ณด
n = df.CRIM.isnull().sum()
print('Max:', M, 'Min:', m , 'Median:', med, 'Mean:', mea, 'Std:', std_, 'Null:', n )
Python
๋ณต์ฌ
โข
์๊ด๊ณ์
โฆ
๋ ๋ณ์ ์ฌ์ด์ ์๊ด ์ฌ๋ถ๋ฅผ ํ์
ํ๊ธฐ ์ํด ์๊ด ๊ณ์๋ฅผ ํ์ธํ๋ค.
โข
Pivot Table์ ํตํ ๋ฐ์ดํฐ ํ์
โฆ
์ด์ง ๋ถ๋ฅ ๋ฌธ์ ์์ ํด๋์ค ๊ตฌ๋ณ์ ํ์์ ์ธ ๋ณ์๋ฅผ ํ์
ํ๊ณ ์ ํ ๋ ์ ์ฉํ๋ค.
โช
์๋ฅผ ๋ค์ด, ์ด๋ค ๋ณ์์ ํ๊ท ๊ฐ์ด ๋ ๊ฐ์ ํด๋์ค์ ๋ฐ๋ผ ํฌ๊ฒ ๋ค๋ฅด๋ค๋ฉด ๊ทธ ๋ณ์๋ ์ค์ํ ๋ณ์์ผ ๊ฐ๋ฅ์ฑ์ด ๋๋ค.
# groupby() ์ด์ฉ
# ์ง์ญ๋น ํ๊ท ๋ฐฉ์ ๊ฐ์๋ฅผ ๊ตฌ๊ฐ ๋ณ๋ก ๋๋
df['RM_bin'] = pd.cut(df.RM, range(0,10), labels=False)
# ์ฐฐ์ค ๊ฐ ๊ฒฝ๊ณ, ๊ตฌ๊ฐํ๋ ํ๊ท ๋ฐฉ์ ๊ฐ์์ ์กฐํฉ์ผ๋ก ๊ทธ๋ฃน์ ๋๋๊ณ
# ๊ฐ ๊ทธ๋ฃน์์ ์ฃผํ ๊ฐ๊ฒฉ์ ์ค์๊ฐ์ ํ๊ท ์ ํ์ธ
df.groupby(['RM_bin','CHAS'])['MEDV'].mean()
Python
๋ณต์ฌ
# pivot_table() ์ด์ฉ
# margins=True์ ์๋ฏธ: ํผ๋ฒํ
์ด๋ธ์ ๋ง์ง๋ง ํ๊ณผ ๋ง์ง๋ง ์ด์ 'All' ์ด๋ผ๋ ์ด๋ฆ์ผ๋ก ์ ์ฒด ์์ฝ ๊ฐ์ ์ถ๊ฐ
pd.pivot_table(df, values='MEDV', index=['RM_bin'], columns=['CHAS'], aggfunc=np.mean, margins=True)
Python
๋ณต์ฌ
์๊ด๋ถ์
โข
์๊ด ํ๋ ฌ
โฆ
์ฃผ์ด์ง ๋ชจ๋ ๋ณ์์ ์์ผ๋ก๋ถํฐ ๊ตฌํ ์๊ด๊ณ์๋ฅผ ๋ณด์ฌ์ค๋ค.
โฆ
๋งค์ฐ ๊ฐํ ์๊ด๊ด๊ณ๊ฐ ์๋ ๋ณ์ ์์ ์ ๋ณด์ ๋ง์ ๋ถ๋ถ์ด ๊ฒน์น๋ฏ๋ก, ํ๋๋ฅผ ์ ๊ฑฐํ์ฌ ์ถ์ ๊ฐ๋ฅํ๋ค.
โช
๋ค์ค ๊ณต์ ์ฑ ๋ฌธ์ ํด๊ฒฐ ๊ฐ๋ฅ
โช
์ฃผ์ํ ์ : ์๊ด๊ณ์๋ ๋ ๋ณ์ ์ฌ์ด์ ์ ํ ๊ด๊ณ์ ์ฌ๋ถ๋ง์ ํ๋จํ๋ค. ๋ฐ๋ผ์ ์๊ด๊ณ์๊ฐ 0์ ๊ฐ๊น๋ค๋ ๊ฒ์ ๋ ๋ณ์ ์ฌ์ด์ ์ ํ ๊ด๊ณ๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ ๊ฒ์ด์ง, ์ด๊ฒ์ด ๋ ๋ณ์๊ฐ ์๋ก ์ฐ๊ด์ด ์์ ์์์ ์๋ฏธํ์ง๋ ์๋๋ค.
df.corr().round(2)
Python
๋ณต์ฌ
๋ฒ์ฃผํ ๋ณ์์ ๋ฒ์ฃผ ๊ฐ์ ์ถ์
โข
๊ฐ๋ณ์ ๋ณํ
โฆ
๋ฒ์ฃผํ ๋ณ์๊ฐ ๋
๋ฆฝ ๋ณ์์ธ ๊ฒฝ์ฐ ์ด๋ฅผ ๊ฐ๋ณ์๋ก ๋ณํํ๋ค.
โฆ
์ด๋ ๊ฐ ๋ณ์์ ๋ฒ์ฃผ์ ๊ฐ์๊ฐ ๋ง๋ค๋ฉด, ๋ณ์์ ๊ฐ์๊ฐ ๋์ด๋๊ฒ ๋๋ค.
โช
์๋ฅผ ๋ค์ด m๊ฐ์ ๋ฒ์ฃผ๋ฅผ ๊ฐ์ง ๋ณ์์ ๊ฒฝ์ฐ ๊ฐ๋ณ์ ๋ณํ์ ๊ฑฐ์น ์ดํ ๋ณ์์ ๊ฐ์๋ m-1๊ฐ๊ฐ ๋ชจ๋ธ์ ์ฌ์ฉ๋๋ค.
โฆ
์ ์ฌํ ๋ฒ์ฃผ๋ฅผ ํ๋๋ก ํฉ์นจ์ผ๋ก์จ ๋ฒ์ฃผ์ ์๋ฅผ ์ค์ผ ์ ์๋ค.
โช
Pivot-table์ ์ฌ์ฉํ์ฌ ๋ค์ํ ๋ฒ์ฃผ์์ ์ข
์ ๋ณ์๊ฐ ์ด๋ป๊ฒ ๋ฐ์ํ๋์ง๋ฅผ ํ์
ํ์ฌ ๋ฒ์ฃผ๋ฅผ ์ค์ผ ์ ์๋ค.
โช
๋๋ ๊ด์ธก์น ๊ฐ์๊ฐ ์ ์ ๋ฒ์ฃผ๋ค์ โ๊ธฐํโ ๋ฒ์ฃผ๋ก ํตํฉํ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค.
โช
์ด์ง ๋ถ๋ฅ ๋ฌธ์ ์์, ๋
๋ฆฝ ๋ณ์์ ๊ฐ ๋ฒ์ฃผ์ ๋ํ ์ข
์ ๋ณ์์ ๋ถํฌ๋ฅผ ํ์
ํ์ฌ ๋ถ๋ฅ์ ์ํฅ์ ์ฃผ์ง ์๋ ๋ฒ์ฃผ๋ฅผ ํ์
ํ์ฌ ํ๋์ ๋ฒ์ฃผ๋ก ๊ฒฐํฉํ ์ ์๋ค.
โข
์๊ณ์ด ๋ถ์
โฆ
๊ฐ ๋ถ๊ธฐ๊ฐ ๋
๋ฆฝ ๋ณ์์ธ ๊ฒฝ์ฐ, ์ ์ฌํ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์ค๋ ๋ถ๊ธฐ๋ฅผ ํตํฉํ ์ ์๋ค.
โช
์๋ฅผ ๋ค์ด, 1~3๋ถ๊ธฐ ์ค์ ์ ๋งค๋
์ ์ฌํ์ง๋ง 4๋ถ๊ธฐ ์ค์ ์์๋ ์ฐจ์ด๋ฅผ ๋ณด์ด๋ ๊ฒฝ์ฐ 1~3๋ถ๊ธฐ๋ฅผ ํ๋์ ๋ณ์๋ก ํตํฉํ ์ ์๋ค.
โข
์์นํ ๋ณ์ ๋ณํ
โฆ
๊ตฌ๊ฐ์ ๋ํ๋ด๋ ๋ฒ์ฃผ์ธ ๊ฒฝ์ฐ ๋ฒ์ฃผํ ๊ฐ์ ๊ตฌ๊ฐ์ ์ค๊ฐ๊ฐ์ผ๋ก ๋์ฒดํ์ฌ ๊ฐ๋ณ์ ๋ณํ ์์ด ์ฌ์ฉํ ์ ์๋ค.
โช
๋ง์ฝ ๊ฐ๋ณ์ ๋ณํ์ ํ๋ค๋ฉด ๋ฒ์ฃผ์-1๊ฐ์ ๋ณ์๊ฐ ๋ชจ๋ธ์ ์ฌ์ฉ๋์ง๋ง, ์ด ๊ฒฝ์ฐ ๋ณ์๋ฅผ 1๊ฐ๋ง ์ฌ์ฉํ๊ฒ ๋๋ค.
PCA(Principal Component Analysis)
โข
PCA
โฆ
๋ฐ์ดํฐ ๋ถํฌ๋ฅผ ๊ฐ์ฅ ์ ์ค๋ช
ํ ์ ์๋ ์ถ, ๋ถ์ฐ์ด ์ต๋๊ฐ ๋๋ ์ถ์ ์ฐพ๋ ๊ฒ
โฆ
๋ฐ์ดํฐ์ ๋ถ์ฐ์ด ํฌ๋ค๋ ๊ฒ์, ๊ทธ ๋ฐฉํฅ์ผ๋ก ๋ฐ์ดํฐ๊ฐ ๋ง์ด ํผ์ ธ ์๋ค๋ ๊ฒ
โช
์ด๋ ํด๋น ์ถ์ ๋ฐํ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ํ์
ํ๋ค๋ฉด ๋ ๋ง์ ์ ๋ณด๋ฅผ ํ์
ํ ์ ์๋ค๋ ์๋ฏธ
โช
์๋ฅผ ๋ค์ด, ์ด๋ค ๋ฐฉํฅ์์ ๋ชจ๋ ๋ฐ์ดํฐ๊ฐ ๊ฑฐ์ ํ ์ ์ ๋ชฐ๋ ค ์๋ค๋ฉด, ๊ทธ ์ถ์ ๋ฐ์ดํฐ์ ๋ณ๋ณ๋ ฅ์ด ์๋ค๋ ๊ฒ์ด๋ค.
โช
๋ฐ๋ฉด์ ์ด๋ค ์ถ์์๋ ๋ฐ์ดํฐ๊ฐ ์ซ ํผ์ ธ ์๋ค๋ฉด ๊ทธ ๋ฐฉํฅ์ผ๋ก ๋ณด๋ฉด ๋ฐ์ดํฐ ๊ฐ ์ฐจ์ด๊ฐ ๋ ๋๋ ทํ๊ฒ ๋ํ๋๋ค.
โฆ
๊ทธ๋์ PCA๋ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ฅ ์ ํผ์ ธ ์๋ ์ถ(=๋ถ์ฐ์ด ํฐ ์ถ) ์ ์ฐพ๋ ๊ฒ์ ๋ชฉ์ ์ผ๋ก ํ๋ค.
โช
์ ์ฒด ๋ณ๋์ ๊ฐ ๋ณ์๊ฐ ๋ฏธ์น๋ ๊ธฐ์ฌ๋๋ฅผ ์ต๋ํ ํ์ฉํ๋ฉด์๋ ๋ณ์์ ์๋ฅผ ์ถ์ํ๋ ๋ฐฉ์์ด๋ผ๊ณ ํด์ํ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค.
โฆ
์ผ๋ฐ์ ์ธ PCA์ Kernel PCA๊ฐ ์กด์ฌํจ.
โฆ
์ฐ์์ ์ธ ์ ์ฌ ๋ณ์(latent variable)์ ๋ํด ์ฌ์ฉ
โข
Latent variable
โฆ
๊ฐ ๋ฐ์ดํฐ์ ๋ํด ํ ๋น๋์ด์๋ ๋ฐ์ดํฐ๋ฅผ ํํํ๋ ์๋ ค์ง์ง ์์ ๋ณ์
โฆ
PCA์์๋ ๊ฐ ๋ฐ์ดํฐ ํฌ์ธํธ๋ฅผ ๋ช ๊ฐ์ ์ ์ฌ์ ์ธ ์ฐ์ ๋ณ์(latent continuous variables)์ ์กฐํฉ์ผ๋ก ํํ
โฆ
๊ฐ ์ฃผ์ฑ๋ถ ์ถ (principal component axis)์ ๊ณ ์ ๋ ๋ฐฉํฅ ๋ฒกํฐ
โฆ
PCA๋ ์ด ์ถ๋ค์ ๋ฐ๋ผ ๋ฐ์ดํฐ๋ฅผ ํฌ์ํด์, ๊ฐ ๋ฐ์ดํฐ๊ฐ ์ด ์ถ ์์์ ์ผ๋ง๋งํผ์ ๊ฐ์ ๊ฐ์ง๋์ง(=์ขํ)๋ฅผ ๊ณ์ฐ
โฆ
์ฌ๊ธฐ์ ์ขํ ๊ฐ๋ค์ ์ฐ์์ ์ธ ์ค์ ๊ฐ์ด๊ธฐ ๋๋ฌธ์, ๊ฒฐ๊ตญ ๊ฐ ๋ฐ์ดํฐ ํฌ์ธํธ๋ ์ฐ์์ ์ธ ์ค์๊ฐ๋ค์ ๊ฐ๋ ์ ์ฌ๋ณ์์ ์กฐํฉ์ผ๋ก ํํ๋จ
โข
๋ชฉ์ : ๋ฐ์ดํฐ์ ๋ถ์ฐ์ด ์ต๋ํ ๋๋ ์ถ์ ์ฐพ๋๋ค
โฆ
ํฌ์ฌํ ๋ฐ์ดํฐ๊ฐ ๋ถ์ฐ์ด ์ต๋๊ฐ ๋๋๋กํ๋ ์ถ์ ์ฐพ๋ ๊ฒ
โฆ
์๋ ๊ทธ๋ฆผ์์ ๊ฐ ๋ฐ์ดํฐ๋ฅผ ๋ฒกํฐ๋ก ํฌ์ฌํ์ ๋ ๋ค์ ๋ถ์ฐ์ด ์ต๋๊ฐ ๋์ด์ผ ํ๋ค (2์ฐจ์ โ 1์ฐจ์ ์ถ์)
โข
๋ด์ = Projection
โฆ
๊ธฐํํ์ ์ ์ :
โฆ
โฆ
โช
ํฌ์ฌ๋ ๋ฒกํฐ ๋ ๋ด์ ์ ํฌ๊ธฐ๋งํผ ๋จ์ ๋ฒกํฐ๋ฅผ ์ด๋์ํจ ๋ฒกํฐ์ด๋ค.
โข
๋ถ์ฐ์ ์ต๋ํ ์ํค๋ ๊ฒ์ ์์ํ
โฆ
๋ฐ์ดํฐ์ ๋ถ์ฐ-๊ณต๋ถ์ฐ ํ๋ ฌ ๊ตฌํ๊ธฐ
โฆ
์ด๋ค ๋ฒกํฐ ์ผ๋ก ํฌ์ฌ ํ์ ๋ถ์ฐ์ ์ต๋ํ
โ ๊ฒฐ๊ณผ์ ์ผ๋ก ์ ๋ง์กฑํ๋ ์ ์ฐพ๋ ๋ฌธ์ ์ด๋ฉฐ, ๊ณ ์ณ๊ฐ ๋ถํด(Eigenvalue Decomposition)์ ํตํด ํ์ดํ ์ ์๋ค.
โข
๊ณ ์ณ๊ฐ ๋ถํด(Eigenvalue Decomposition)
(์ ์ฌ๊ฐํ๋ ฌ) ์ด๊ณ ๋ฒกํฐ ๊ฐ ๋ฅผ ๋ง์กฑํ๋ฉฐ ์๋ฒกํฐ๊ฐ ์๋๋ผ๋ฉด, ๋ ๊ณ ์ ๋ฒกํฐ(Eigen-vector) ๋ ๊ณ ์ณ๊ฐ(Eigen-value)์ด๋ผ ํ๋ค.
โข
๊ณ ์ณ๊ฐ ๋ถํด์ ๊ธฐํํ
โฆ
ํ๋ ฌ A๋ฅผ ์ด์ฉํ ์ด๋ค ๋ฒกํฐ์ ๋ณํ์ด ๊ณ ์ณ๊ฐ์ ํตํด ์ด ๋ฒกํฐ๋ฅผ ์ค์ผ์ผ๋งํ ๊ฒ๊ณผ ๊ฐ๋ค. ๋ค์ ๋งํด, ์ ํ ๋ณํ์ ํ๋๋ผ๋ ๋ณธ์ธ์ ๋ฐฉํฅ์ผ๋ก ๋์์ค๋๋ก ๋ง๋๋ ๋ฒกํฐ๋ฅผ ๋งํ๋ฉฐ ์ด๋ฅผ ๊ณ ์ ๋ฒกํฐ๋ผ๊ณ ํ๋ค.
โข
๊ณ ์ณ๊ฐ ๋ถํด์ ๊ณ์ฐ ๊ณผ์
โข
๊ณ ์ณ๊ฐ ๋ถํด ์์
โข
๊ฒฐ๋ก
โฆ
๋ถ์ฐ์ ์ต๋๋ก ํ๋ ์ถ(๋ฒกํฐ)๋ ๋ถ์ฐ-๊ณต๋ถ์ฐ ํ๋ ฌ์ ๊ณ ์ ๋ฒกํฐ์ด๋ฏ๋ก, PCA๋ ๋ถ์ฐ-๊ณต๋ถ์ฐ ํ๋ ฌ์ ๊ณ ์ณ๊ฐ ๋ถํด๋ฅผ ํตํด ์ป์ ๊ณ ์ ๋ฒกํฐ ์ค ์ผ๋ถ๋ฅผ ์ฌ์ฉํด(๊ณ ์ ๊ฐ์ด ํฐ ์์๋๋ก ๊ณ ์ ๋ฒกํฐ๋ฅผ ์ ํ) ์ฐจ์์ ์ถ์ํ๋ค.
โฆ
๊ณ ์ณ๊ฐ์ ๋ถ์ฐ์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ด๊ธฐ ๋๋ฌธ์, ์ ๋ณด ๋ณด์กด์ ์ธก๋ฉด์์ ์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ณ ์ ๋ฒกํฐ๋ฅผ ์ ํํ๋ค.
โข
๋ฐ์
โฆ
Kernel์ ์ฌ์ฉํ Kernel PCA๋ ์กด์ฌํ๋, Kernel Method์ ๋ํด ๋ค๋ฃฌ ์ดํ ์ ๋ฆฌํ๋๋ก ํ๊ฒ ๋ค.
โข
์ฃผ์ฑ๋ถ ์ ์(์๋ก์ด ์ขํ)
โฆ
PCA์์๋ ๋ถ์ฐ์ด ๊ฐ์ฅ ํฐ ๋ฐฉํฅ(=๊ณ ์ ๋ฒกํฐ, ์ฃผ์ฑ๋ถ ์ถ)์ ์ฐพ์ ํ, ๊ฐ ๋ฐ์ดํฐ๋ฅผ ํด๋น ์ถ์ ์ฌ์(projection) ํด์ ์๋ก์ด ์ขํ(=์ฃผ์ฑ๋ถ ์ ์)๋ฅผ ๊ตฌํ๋ค.
โฆ
์ด๋, ๋ฐ์ดํฐ์ ๋ถ์ฐ ๋ฐฉํฅ์ ์ฌ๋ฐ๋ฅด๊ฒ ํ์
ํ๊ธฐ ์ํด ๊ฐ ๋ฐ์ดํฐ์์ ํ๊ท ์ ๋จผ์ ๋บ ํ, ๊ณ ์ ๋ฒกํฐ์ ๋ด์ ํ์ฌ ์ฃผ์ฑ๋ถ ์ ์๋ฅผ ๊ณ์ฐํ๋ค.
โฆ
์๋ก์ด ์ถ์์์ ์ขํ (์ฃผ์ฑ๋ถ ์ ์) :
โฆ
์๋กญ๊ฒ ์์ฑ๋ ์ฃผ์ฑ๋ถ๋ค์ ์๋ก ์๊ด๋์ด ์์ง ์์ผ๋ฏ๋ก, ์๋ก์ด ์ถ์ผ๋ก ์ฌ์ํ ๋ฐ์ดํฐ๋ฅผ ํ์ฉํ์ฌ ํ๊ท ๋ชจ๋ธ์ ๋ง๋ค๋ฉด, ๋ค์ค ๊ณต์ ์ฑ ๋ฌธ์ ์์ ์์ ๋ก์ธ ์ ์๋ค.
from sklearn.decomposition import PCA
import pandas as pd
cereal = pd.read_csv('dmba/Cereals.csv')
pcs = PCA(n_components=2)
pcs.fit(cereal[['calories','rating']]) # 2๊ฐ์ ๋ณ์๋ก PCA ์ํ
pcs.fit(cereal.iloc[:,3:].dropna(axis=0)) # ์ ์ฒด ์์นํ ๋ณ์๋ก PCA, ์ด์์ ๊ฒฐ์ธก์น ์ ๊ฑฐ
pcs.components_ # ์๋ก์ด ์ถ(๋ฒกํฐ)
score = pcs.transform(cereal[['calories','rating']]) # ์ฌ์
Python
๋ณต์ฌ
โข
๋ฐ์ดํฐ ์ ๊ทํ
โฆ
์๋์ ๋ณ์๊ฐ ์๋ก ๋ค๋ฅธ ๋จ์๋ก ์ธก์ ๋์๋ค๋ฉด, ์ฃผ์ฑ๋ถ ๊ตฌ์ฑ์ ์์ด ํด๋น ๋ณ์์ ์ํฅ์ด ์ปค์ง ์ ์๋ค.
โฆ
๋ฐ๋ผ์ PCA๋ฅผ ์ํํ๊ธฐ ์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ทํํ๋ ๊ฒ์ด ํ์ํ๋ค.
โฆ
์ ๊ทํ๋ ๋ฐ์ดํฐ์์์ ๊ฐ์ค์น(๊ณ ์ ๋ฒกํฐ์ ์ฑ๋ถ)๋ ํด๋น ์ฃผ์ฑ๋ถ์ ์ด๋ค ๋ณ์๊ฐ ๋ฏธ์น๋ ์ํฅ๋ ฅ์ ๋ํ๋ธ๋ค.