์ด๋ฒ ์ธ์ ์์๋ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ ์ค์์ ๋๋ฝ ๋ฐ์ดํฐ์ ๋ฒ์ฃผํ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค!
1. ๋๋ฝ๋ ๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ
์ค์ ๋ชจ๋ธ์์๋ ์ฌ๋ฌ ์ด์ ๋ก ๊ฐ์ด ๋๋ฝ๋ ์ํ์ด ์๋ ๊ฒฝ์ฐ๊ฐ ํ๋คํฉ๋๋ค. ๋ณดํต ๋๋ฝ๋ ๊ฐ์ ๋ฐ์ดํฐ ํ ์ด๋ธ์ ๋น ๊ณต๊ฐ์ด๋ ์์ฝ๋ ๋ฌธ์์ด(NULL, NaN)์ผ๋ก ์ฑ์์ง๋๋ค. ๊ทธ๋ผ ์ด์ ์ํ์ ์ ๊ฑฐํ๊ฑฐ๋ ๋ค๋ฅธ ์ํ์ด๋ ํน์ฑ์์ ๋๋ฝ๋ ๊ฐ์ ๋์ฒดํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํ๊ฒ ์ต๋๋ค.
์ฒซ๋ฒ์งธ ๊ณผ์ ์ ๋น์ฐํ ๋๋ฝ๋ ๊ฐ์ ์๋ณํ๋ ๊ฒ์ด๊ฒ ์ฃ . ์ผ๋จ ์์ ๋ฐ์ดํฐ์ ์ ๋ง๋ค์ด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค. read_csvํจ์๋ csvํฌ๋งท ๋ฐ์ดํฐ๋ฅผ ํ๋ค์ค์ ๋ฐ์ดํฐ ํ๋ ์์ผ๋ก ์ฝ์ด์ต๋๋ค. ์ฌ๊ธฐ ์์ ์์๋ ๋๋ฝ ๋ฐ์ดํฐ๋ NaN์ผ๋ก ํ์๋ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์๋ ์ฝ๋์ ์ฐ์ธ StringIO ๋ csv_data์ ์ ์ฅ๋ ๋ฌธ์์ด์ ํ๋ค์ค ๋ฐ์ดํฐ ํ๋ ์์ผ๋ก ์ฎ๊ฒจ์ค๋๋ค.
import pandas as pd
from io import StringIO
csv_data = \
'''A,B,C,D
1.0,2.0,3.0,4.0
5.0,6.0,,8.0
10.0,11.0,12.0,'''
# ํ์ด์ฌ 2.7์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ
# ๋ค์์ฒ๋ผ ๋ฌธ์์ด์ ์ ๋์ฝ๋๋ก ๋ณํํด์ผ ํฉ๋๋ค.
# csv_data = unicode(csv_data)
df = pd.read_csv(StringIO(csv_data))
df
๋ง์ฝ์ ๋ฐ์ดํฐ๊ฐ ๋๋ฌด ํฌ๋ฉด ๋น์ฐํ ์๋์ผ๋ก ๋๋ฝ๋ ๊ฐ์ ์ฐพ๋ ๊ฒ ์ด๋ ต๊ฒ ์ฃ ? ์ด ๊ฒฝ์ฐ์ isnull ๋ฉ์๋๋ ์ ์ ์์น๋ฅผ ๋ด๊ณ ์๋์ง, ์๋๋ฉด ๋๋ฝ๋์๋์ง๋ฅผ ํ์ธํด์ฃผ๋ ๋ถ์ธ ๊ฐ์ผ๋ก ์ฑ์์ง dataFrame์ ๋ฐํํฉ๋๋ค. ์ฌ๊ธฐ์ sum ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด ๋๋ฝ๋ ๊ฐ์ ๊ฐ์๋ฅผ ์ฝ๊ฒ ๋ณผ ์ ์์ต๋๋ค.
df.isnull().sum()
๊ทธ ๋ค์์ ๋๋ฝ๋ ๊ฐ์ด ์๋ ์ํ์ด๋ ํน์ฑ์ ์ ์ธํ๋ ๊ฒ์ธ๋ฐ์, ์ด ๋ฐฉ๋ฒ์ด ๋๋ฝ๋ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ธฐ ๊ฐ์ฅ ํธํ ๋ฐฉ๋ฒ์ ๋๋ค. ๋๋ฝ๋ ๊ฐ์ด ์๋ ํ์ ์ ๊ฑฐํ ๋๋ dropna ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด ์ฝ๊ฒ ์ญ์ ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
df.dropna(axis=0)
df.dropna(axis=1)
dropna์ axis๊ฐ 0์ด๋ฉด ๋๋ฝ๋ ๊ฐ์ด ์๋ ํ์ ์ญ์ ํ๊ณ , axis๊ฐ 1์ด๋ฉด NaN์ด ํ๋๋ผ๋ ์๋ ์ด์ ์ญ์ ํฉ๋๋ค. ์ด์ธ์๋ df.dropna(how='all') ์ ์ฌ์ฉํ๋ฉด ๋ชจ๋ ์ด์ด NaN์ธ ํ์ ์ญ์ ํ๊ณ , thresh=3์ด๋ผ๊ณ ์ ์ผ๋ฉด ์ค์ ๊ฐ์ด 3๋ณด๋ค ์์ ํ์ ์ญ์ ํฉ๋๋ค. ๋ง์ฝ subset = ['A']๋ผ๋ฉด A์ด์ NaN์ด ์๋ ํ๋ง ์ญ์ ํฉ๋๋ค.
๋๋ฝ๋ ๋ฐ์ดํฐ๋ฅผ ์ ๊ฑฐํ๋ ๊ฒ์ ๋จ์ ์ ๋๋ฌด ๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ฉด ๋ถ์ํ ๋ ๋ถ์์ ํ๋ค๋ ์ ๊ณผ ๋๋ฌด ๋ง์ ํน์ฑ ์ด์ ์ญ์ ํ๋ฉด ๋ถ๋ฅ๊ธฐ๊ฐ ํด๋์ค๋ฅผ ๊ตฌ๋ถํ๋๋ฐ ํ์ํ ์ ๋ณด๋ฅผ ์์ ์ํ์ด ์์ต๋๋ค.
๋ฐ๋ผ์, ์ํ์ ์ญ์ ํ๊ฑฐ๋ ํน์ฑ ์ด์ ํต์งธ๋ก ์ ๊ฑฐํ๊ธฐ ์ด๋ ค์ธ ๋ ๋ณด๊ฐ(interpolation)๊ธฐ๋ฒ์ ์ฌ์ฉํฉ๋๋ค. ๋ณด๊ฐ ๊ธฐ๋ฒ์ ์ด์ฉํ๋ฉด ๋ค๋ฅธ ํ๋ จ ๋ฐ์ดํฐ๋ก๋ถํฐ ๋๋ฝ๋ ๋ฐ์ดํฐ๋ฅผ ์ถ์ ํ ์ ์์ต๋๋ค. ๊ฐ์ฅ ํํ ๊ธฐ๋ฒ ์ค ํ๋๋ ํ๊ท ์ผ๋ก ๋์ฒดํ๋ ๊ฒ์ ๋๋ค. ๊ฐ ์ด์ ์ ์ฒด ํ๊ท ์ผ๋ก ์ ์ฉํ๋ ๊ฒ์ด์ฃ . ์ฌ์ดํท๋ฐ imputer ํด๋์ค๋ฅผ ์ฌ์ฉํฉ๋๋ค.
from sklearn.preprocessing import Imputer
imr = Imputer(missing_values='NaN', strategy='mean', axis=0)
imr = imr.fit(df.values)
imputed_data = imr.transform(df.values)
imputed_data
์ฌ๊ธฐ์๋ NaN๊ฐ์ ๊ฐ ํน์ฑ ์ด๋ง๋ค ๊ณ์ฐํ ํ๊ท ์ผ๋ก ์ ํด์ฃผ์์ต๋๋ค. strategy ๋งค๊ฐ๋ณ์์๋ mean๋ง๊ณ ๋ median, most_frequent๋ฅผ ๋ฃ์ด์ค ์ ์์ต๋๋ค. most_frequent๋ ๊ฐ์ฅ ๋ง์ด ๋ํ๋ ๊ฐ์ผ๋ก ๋๋ฝ๋ ๊ฐ์ ๋์ฒดํฉ๋๋ค. median์ ๋ง ๊ทธ๋๋ก ์ค๊ฐ๊ฐ์ด์ฃ .
์์์ ์ฌ์ดํท๋ฐ์ Imputer ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๊ธฐ์ตํ์์ฃ ? Imputer ํด๋์ค๋ ์ฌ์ดํท๋ฐ ๋ณํ๊ธฐ(transformer)ํด๋์ค์ ๋๋ค. ์ด๋ฌํ ๋ณํ๊ธฐ์ ์ฃผ์ํ ๋ฉ์๋๋ fit๊ณผ transform์ ๋๋ค. fit์ ์ด์ ์ธ์ ์์๋ ๋ง์ด ๋ณด์ จ๋ค์ํผ ๋ชจ๋ธ์ ํ์ต์ํค๊ณ , transform๋ฉ์๋๋ ํ์ตํ ๋ชจ๋ธ๋ก ๋ฐ์ดํฐ๋ฅผ ๋ณํํฉ๋๋ค. ๊ทธ๋ฆผ 6์ ๋ณํ๊ธฐ๊ฐ ๋ฐ์ดํฐ ์ ๋ค์ ๋ณํํ๋ ๊ณผ์ ์ ๋๋ค.
์ด์ ์ธ์ ๋ค์์ ์ฌ์ฉํ ๋ถ๋ฅ๊ธฐ๋ ๋ณํ๊ธฐ ํด๋์ค์ ์ ์ฌํ API๋ฅผ ๊ฐ์ง ์ถ์ ๊ธฐ(estimator)์ ๋๋ค. predict ๋ฉ์๋๊ฐ ์น์ํ์ค ๊ฒ ๊ฐ๋ค์. ์ถ์ ๊ธฐ๋ predict ๋ฉ์๋๊ฐ ์์ง๋ง transform ๋ฉ์๋๋ ๊ฐ์ง ์ ์์ต๋๋ค. ๋ถ๋ฅ๋ฅผ ์ํด ์ถ์ ๊ธฐ๋ฅผ ํ๋ จํ ๋๋ fit์ ์ด์ฉํด์ ๋ชจ๋ธ์ ํ๋ฆฌ๋ฏธํฐ๋ฅผ ํ์ตํ๊ณ , ์ง๋ํ์ต์์๋ ๋ชจ๋ธ์ ํ๋ จํ ๋ ์ถ๊ฐ ํด๋์ค ๋ ์ด๋ธ์ ์ ๊ณตํ๊ณ predict ๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. ๊ทธ๋ฆผ 7์์ ์ถ์ ๊ธฐ์ ๋ณํ๊ธฐ๋ฅผ ๋น๊ต ํ์ธํ์ค ์ ์์ต๋๋ค.
2. ๋ฒ์ฃผํ ๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ
์ง๊ธ๊น์ง ์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ์ ๋ค์ ๋์ด์ผ๋ณด๋ฉด, ์ ๋ถ ์์นํ ๋ฐ์ดํฐ์๋ค๋ ๊ฒ์ ์ฝ๊ฒ ์์ค ์ ์์ํ ๋ฐ์, ์ค์ ๋ฐ์ดํฐ๋ ํ๋ ์ด์์ ๋ฒ์ฃผํ ํน์ฑ์ด ํฌํจ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ์ด๋ฌํ ๋ฒ์ฃผํ ๋ฐ์ดํฐ๋ฅผ ์์น ๊ณ์ฐ์ฉ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
์ฒ์์ผ๋ก, ๋ฒ์ฃผํ ๋ฐ์ดํฐ์ ์์๊ฐ ์๋ ๊ฒ๊ณผ ์๋ ๊ฒ์ ๊ตฌ๋ถํด์ผํฉ๋๋ค. ์์๊ฐ ์๋ ํน์ฑ์ ์ฐจ๋ก๋๋ก ๋์ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ํฌ๊ธฐ๋ฅผ ์์๋ก S, M, L ์ผ๋ก ์ฐจ๋ก๋๋ก ๋์ ์ ์๊ฒ ์ฃ . ๋ฐ๋๋ก ์์๊ฐ ์๋ ํน์ฑ์ ์ฐจ๋ก๋ฅผ ๋ถ์ฌํ ์ ์์ต๋๋ค. ์๊น๊ณผ ๊ฐ์ ๊ฒ์ด์ฃ . ์ผ๋จ ์์ ๋์ดํฐ์ ์ ๋ณผ๊น์?
import pandas as pd
df = pd.DataFrame([['green', 'M', 10.1, 'class1'],
['red', 'L', 13.5, 'class2'],
['blue', 'XL', 15.3, 'class1']])
df.columns = ['color', 'size', 'price', 'classlabel']
df
์ถ๋ ฅ์์ ๋ณผ ์ ์๋ฏ์ด ๋ฒ์ฃผํ ์ค ์์๊ฐ ์๋ ๋ฐ์ดํฐ color์ ์์๊ฐ ์๋ ๋ฐ์ดํฐ size, ์์นํ ๋ฐ์ดํฐ price๊ฐ ์์ต๋๋ค. ํด๋์ค ๋ ์ด๋ธ์ ๋ง์ง๋ง ์ด์ ์๋ค์.
๋ค์์ ์์ ํน์ฑ์ ๋งคํํ๋ ๊ฒ์ธ๋ฐ์, ํ์ต ์๊ณ ๋ฆฌ์ฆ์ด ์์ ํน์ฑ์ ์ฌ๋ฐ๋ฅด๊ฒ ์ธ์ํ๊ธฐ ์ํด์๋ ๋ฌธ์์ด์ ์ ์๋ก ๋ฐ๊พธ์ด์ผ ํฉ๋๋ค. ์์ size ํน์ฑ์ ์์๋ฅผ ์๋์ผ๋ก ๋ฐ๊ฟ์ฃผ์ง ์๊ธฐ ๋๋ฌธ์, ๋งคํ ํจ์๋ฅผ ์ง์ ๋ง๋ค์ด์ผํฉ๋๋คใ ใ . ์ฌ๊ธฐ์ ํน์ฑ๊ฐ์ ์ฐ์ ์ ์ธ ์ฐจ์ด๋ฅผ ์๊ณ ์๋ค๊ณ ๊ฐ์ ํ๋ฉด, XL = L + 1 = M + 2๋ผ๊ณ ํฉ์๋ค.
size_mapping = {'XL': 3,
'L': 2,
'M': 1}
df['size'] = df['size'].map(size_mapping)
df
์ด๋ ๊ฒ ์ฌ์ด์ฆ๊ฐ ๋งคํ๋์๋ค์! ๋ง์ฝ์ ์ ์ ๊ฐ์ ๋ค์ ๋ฌธ์์ด๋ก ๋ฐ๊พธ๊ณ ์ถ๋ค๋ฉด ๊ฑฐ๊พธ๋ก ๋งคํํ๋ ๋์ ๋๋ฆฌ๊ฐ ์์ต๋๋ค! ๋ฐ๋ก inv_size_mapping={v:k for k, v in size_mapping.items()}๋ฅผ ์ ์ํด์ฃผ๋ฉด ๋ฉ๋๋ค. ํด๋ณผ๊น์?
inv_size_mapping = {v: k for k, v in size_mapping.items()}
df['size'].map(inv_size_mapping)
๋ค์์ ํด๋์ค ๋ ์ด๋ธ์ ์ธ์ฝ๋ฉํ๋ ๊ฒ์ ๋๋ค. ๋๋ถ๋ถ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ํด๋ ์ค ๋ ์ด๋ธ์ ์ ์๋ก ์ธ์ฝ๋ฉ ๋์๋ค๊ณ ์๊ฐํ๊ณ ์คํํฉ๋๋ค. ์ฌ์ดํท๋ฐ์์ ์ ๊ณตํ๋ ๋ถ๋ฅ ์ถ์ ๊ธฐ ๋๋ถ๋ถ์ ์๋์ผ๋ก ๋ ์ด๋ธ์ ์ ์๋ก ๋ฐ๊ฟ์ฃผ์ง๋ฉด ์ค์๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด์ ํด๋์ค ๋ ์ด๋ธ์ ์ ์ ๋ฐฐ์ด๋ก ์ ๋ฌํด์ฃผ๋ ๊ฒ์ ์ถ์ฒํฉ๋๋ค.
ํด๋์ค ๋ ์ด๋ธ ์ธ์ฝ๋ฉ์ ์์ ๋งคํ๊ณผ ๋น์ทํฉ๋๋ค. ํด๋์ค ๋ ์ด๋ธ์๋ ์์๊ฐ ์์ต๋๋ค. enumerate๋ฅผ ์ด์ฉํด์ ํด๋์ค ๋ ์ด๋ธ์ 0๋ถํฐ ํ ๋นํด์ฃผ๊ณ , ๋งคํ ๋์ ๋๋ฆฌ๋ก ํด๋์ค ๋ ์ด๋ธ์ ์ ์๋ก ๋ณํํด์ค๋๋ค.
import numpy as np
class_mapping = {label: idx for idx, label in enumerate(np.unique(df['classlabel']))}
class_mapping
df['classlabel'] = df['classlabel'].map(class_mapping)
df
์ด๋ฐ ์์ผ๋ก ํด๋์ค ๋ ์ด๋ธ์ ์ ์๋ก ๋ณํ์์ผ ์ฃผ์์ต๋๋ค. ๋งคํ ๋์ ๋๋ฆฌ์ ํค์ ๊ฐ์ ๋ค์ง์ด์ ํด๋์ค ๋ ์ด๋ธ์ ๋ค์ ์๋ณธ ๋ฌธ์์ด๋ก๋ ๋ฐ๊ฟ ์ ์์ต๋๋ค.
inv_class_mapping = {v: k for k, v in class_mapping.items()}
df['classlabel'] = df['classlabel'].map(inv_class_mapping)
df
๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก๋ ์ฌ์ดํท๋ฐ์ LavelEncoder ํด๋์ค๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. fit_transform ๋ฉ์๋๋ ์ด๋ฆ์์ ์ ์ ์๋ฏ์ด fit๊ณผ tranform์ ํฉ์ณ๋์ ๋ฉ์๋์ ๋๋ค. ์ด๊ฒ์ inverse_transform๋ฉ์๋๋ก ๋๋๋ฆด ์ ์์ต๋๋ค.
from sklearn.preprocessing import LabelEncoder
# class label encoder
class_le = LabelEncoder()
y = class_le.fit_transform(df['classlabel'].values)
y
# inverse
class_le.inverse_transform(y)
๋ค์์ผ๋ก๋ ์ค์ํ ๊ฐ๋ ์ธ ์-ํซ ์ธ์ฝ๋ฉ์ ๋ํด์ ์ด์ผ๊ธฐํ๋๋ก ํ๊ฒ ์ต๋๋ค. ์์๊ฐ ์๋ ํน์ฑ์๋ ๋งคํํ๋ ๊ฒ๊ณผ ๋น์ทํ ๋ฐฉ์์ ์ฌ์ฉํ ์๊ฐ ์์ต๋๋ค. ์ฝ๋๋ก ๋ณผ๊น์?
X = df[['color', 'size', 'price']].values
color_le = LabelEncoder()
X[:, 0] = color_le.fit_transform(X[:, 0])
X
์ด๋ ๊ฒ ํ๋ฉด blue๊ฐ 0, green์ 1, red๋ 2๊ฐ ๋ฉ๋๋ค. ์ ์ด์ ์ด ๋ฐฐ์ด์ ๋ถ๋ฅ๊ธฐ์ ๋ฃ์ผ๋ฉด ์ด๋ป๊ฒ ๋ ๊น์? ๋ฌธ์ ๊ฐ ์๊ธฐ๊ฒ ์ฃ . ๋ฌด์จ ๋ฌธ์ ๊ฐ ์๊ธธ๊น์? ์ปฌ๋ฌ ๊ฐ์๋ ์์๊ฐ ์์ง๋ง ๋ถ๋ฅ๊ธฐ๋ red, green, blue ์์๋ก ํฌ๋ค๊ณ ์๊ฐํ ๊ฒ์ ๋๋ค. ์ด๊ฑด ์ณ์ง ์์ ๊ฒฐ๊ณผ์ง๋ง ์๋ฏธ๊ฐ ์์ ์๋ ์๊ฒ ์ฃ . ํ์ง๋ง ๊ฒฐ๊ณผ๋ ์ต์ ์ด ์๋๋๋ค.
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๋ฐฉ๋ฒ์ด ๋ฐ๋ก ์-ํซ ์ธ์ฝ๋ฉ(one-hot encoding)์ ๋๋ค. ์ด ๋ฐฉ์์ ํน์ฑ์ ๋ค์ด์๋ ๊ณ ์ ํ ๊ฐ๋ง๋ค ์๋ก์ด dummy ํน์ฑ์ ๋ง๋๋ ๊ฒ์ด์ฃ . ์๋ฅผ ๋ค๋ฉด color ํน์ฑ์ ์ธ ๊ฐ์ ์๋ก์ด ํน์ฑ green, blue, red๋ก ๋ณํํ๋ ๊ฒ์ ๋๋ค. ์ด์ง ๊ฐ์ผ๋ก ํํํ ๋, blue๋ blue = 1, green = 0, red = 0์ผ๋ก ์ธ์ฝ๋ฉ ๋ฉ๋๋ค. ์ฌ์ดํท๋ฐ์์๋ preprocessing ๋ชจ๋์ OneHotEncoder์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(categorical_features=[0])
ohe.fit_transform(X).toarray()
OneHotEncoder์ ์ด๊ธฐํํ ๋ ๋ณํํ๋ ค๋ ํน์ฑ ์ด์ categorical_features์ ์ ๋ฌํฉ๋๋ค. ์ํซ์ธ์ฝ๋์ transform์ ํฌ์ ํ๋ ฌ(sparse matrix)๋ฅผ ๋ฐํํฉ๋๋ค. ์ด ๋ด์ฉ์ ๋ณด๋ ค๋ฉด ํฌ์ ํ๋ ฌ์ toarray๋ก ๋ํ์ด ๋ฐฐ์ด๋ก ๋ฐํ์ํฌ ์ ์์ต๋๋ค. ํฌ์ ํ๋ ฌ์ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๋ ํจ์จ์ ์
๋๋ค. ํนํ 0์ด ๋ง์ ๋์. ์ฌ์ดํท๋ฐ์ ๋ง์ ํฌ์ ํ๋ ฌ์ ์ง์๋ฐ๋๋ค. OneHotEncoder(... , sparse=False)์ฒ๋ผ ์ธ์ฝ๋๋ฅผ ์ด๊ธฐํํ๋ฉด ๋ฐ๋ก ๋ฐฐ์ด์ ์ป์ ์๋ ์์ต๋๋ค.
์ํซ ์ธ์ฝ๋ฉ์ผ๋ก ๋๋ฏธ ๋ณ์๋ฅผ ๋ง๋๋ ํธ๋ฆฌํ ๋ฐฉ๋ฒ์ ํ๋ค์ค์ get_dummies ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋๋ค. DataFrame์ ์ ์ฉํ๋ฉด get_dummies ๋ฉ์๋๋ ๋ฌธ์์ด ์ด๋ง ๋ณํํ๊ณ ๋๋จธ์ง๋ ๊ทธ๋๋ก ๋ก๋๋ค.
pd.get_dummies(df[['price', 'color', 'size']])
์ํซ ์ธ์ฝ๋ฉ๋ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ ๋๋ ๋ค์ค ๊ณต์ ์ฑ(mulicollinearity)๋ฅผ ์๊ฐํด์ผํฉ๋๋ค. ์ญํ๋ ฌ์ ๊ตฌํด์ผํ๋ ๊ฒฝ์ฐ์๋ ๋ฌธ์ ๊ฐ ๋ ์ ์๊ธฐ ๋๋ฌธ์ด์ฃ . ํน์ฑ๊ฐ ์๊ด๊ด๊ณ๊ฐ ๋์ผ๋ฉด ์ญํ๋ ฌ์ ๊ณ์ฐํ๊ธฐ ํ๋ค์ด ์์น์ ๋ถ์์ ์ฑ์ด ๋์์ง๋๋ค. ์ด ์๊ด๊ด๊ณ๋ฅผ ๊ฐ์์ํค๊ธฐ ์ํด ์ธ์ฝ๋ฉ๋ ๋ฐฐ์ด์ ์ด ํ๋๋ฅผ ์ญ์ ํฉ๋๋ค. ๋ง์ฝ color_blue๋ฅผ ์ญ์ ํด๋ color_green์ 0์ด๊ณ color_red๊ฐ 0์ด๋ฉด blue๊ฐ 1์์ ์ ์ ์์ผ๋ฏ๋ก ๋ฐ์ดํฐ์๋ ์์ค์ด ์์ต๋๋ค.
get_dummies๋ฅผ ์ฌ์ฉํ ๋ drop_first๋ฅผ true๋ก ์ค์ ํด ์ฒซ ๋ฒ์งธ ์ด์ ์ญ์ ํ ์ ์์ต๋๋ค.
pd.get_dummies(df[['price', 'color', 'size']], drop_first=True)
OneHotEncoder์ ์ด์ ์ญ์ ํ ์ ์์ต๋๋ค. ํ์ง๋ง ์๋ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ํ์ด ๋ฐฐ์ด์ ์ฌ๋ผ์ด์ฑํ ์ ์์ต๋๋ค.
ohe = OneHotEncoder(categorical_features=[0])
ohe.fit_transform(X).toarray()[:, 1:]
์ด๋ ๊ฒ ๋๋ฝ๋ ๋ฐ์ดํฐ์ ๋ฒ์ฃผํ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด์์ต๋๋ค. ์ค์ ์์ ๋ง์ด ์ฐ์ด๋ ๊ฐ๋
์ด๊ณ ,
OneHotEndoding ์ญ์ ์ค์ํ๊ฒ ๋ค๋ค์ง๋ ๊ฐ๋
์ด๋ ์ ์์๋์๊ธธ ๋ฐ๋๋๋ค! ๋ค์ ์ธ์
๋ถํฐ๋ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ์ ๊ดํ ๊ธ์ ๋ค๊ณ ์ค๋๋ก ํ๊ฒ ์ต๋๋ค. ์ข์ ํ๋ฃจ ๋์ธ์!