Machine Learning (3) - 데이터 전처리

2022년 11월 25일 3 분 소요

사이킷런으로 시작하는 머신러닝

데이터 전처리(Data Preprocessing)

제대로 된 데이터를 입력해야 결과도 제대로 나온다.(Garbage In, Garbage Out)

NaN, Null 값 허용하지 않음
문자열 값을 입력값으로 허용하지 않음

데이터 인코딩

레이블 인코딩(Label encoding)

유일값을 뽑아 목록을 만든 뒤 일련번호를 붙인다.(리스트로 만들고 idx를 사용)
숫자값이 의미가 없고 구분용도로 쓰인다.
변환된 숫자값이 중요도로 인식되어 예측성능이 떨어질 수도 있다.
따라서 선형회귀와 같은 ML 알고리즘에는 적용하지 않아야 한다.
트리 계열의 ML 알고리즘은 숫자의 이러한 특성을 반영하지 않으므로 별문제가 없다.

In [1]:

from sklearn.preprocessing import LabelEncoder

In [2]:

items = ['TV', '냉장고', '전자레인지', '컴퓨터', '컴퓨터', '선풍기', '선풍기', '믹서', '믹서']
encoder = LabelEncoder()
# 데이터를 정리, 사전 작성
encoder.fit(items)
# 레이블 인코딩 수행
encoder.transform(items)
labels = encoder.transform(items)

In [3]:

labels

Out [3]:

array([0, 1, 4, 5, 5, 3, 3, 2, 2])

In [4]:

encoder.transform(['냉장고'])

Out [4]:

array([1])

In [5]:

# 사전 정보 확인
encoder.classes_

Out [5]:

array(['TV', '냉장고', '믹서', '선풍기', '전자레인지', '컴퓨터'], dtype='<U5')

In [6]:

# 원상복구(인코딩된 값을 다시 디코딩)
encoder.inverse_transform([1])

Out [6]:

array(['냉장고'], dtype='<U5')

In [7]:

encoder.inverse_transform(labels)

Out [7]:

array(['TV', '냉장고', '전자레인지', '컴퓨터', '컴퓨터', '선풍기', '선풍기', '믹서', '믹서'],
      dtype='<U5')

One-Hot Encoding

크기에 따른 영향을 없애기 위해 사용한다.
2차원 ndarray로 reshape해야 한다.
변환한 값이 희소 행렬(Sparse Matrix) 형태이므로 밀집 행렬(Dense Matrix) 형태로 변환해야 한다.

In [8]:

from sklearn.preprocessing import OneHotEncoder
import numpy as np

In [9]:

items

Out [9]:

['TV', '냉장고', '전자레인지', '컴퓨터', '컴퓨터', '선풍기', '선풍기', '믹서', '믹서']

In [10]:

# 2차원 ndarray로 변환(List로 만들어도 가능) - 한 행에 한건의 데이터
items_t = np.array(items).reshape(-1, 1)
items_t
items_l = [['TV'],
       ['냉장고'],
       ['전자레인지'],
       ['컴퓨터'],
       ['컴퓨터'],
       ['선풍기'],
       ['선풍기'],
       ['믹서'],
       ['믹서']]

In [11]:

# 리스트 형태로 넣어도 가능하다
oh_encoder = OneHotEncoder()
oh_encoder.fit(items_l)
result = oh_encoder.transform(items_l)
result.toarray()

Out [11]:

array([[1., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 0., 1.],
       [0., 0., 0., 0., 0., 1.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0.]])

In [12]:

# ndarray형태
oh_encoder.fit(items_t)
oh_labels = oh_encoder.transform(items_t)
oh_labels.toarray()

Out [12]:

array([[1., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 0., 1.],
       [0., 0., 0., 0., 0., 1.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0.]])

In [13]:

oh_encoder.categories_

Out [13]:

[array(['TV', '냉장고', '믹서', '선풍기', '전자레인지', '컴퓨터'], dtype='<U5')]

In [14]:

oh_encoder.inverse_transform([[1., 0., 0., 0., 0., 0.]]) # 2차원으로 넣어줘야 함 # 기본 데이터 타입이 실수형이라 '.' 없이 넣어도 자동으로 변환

Out [14]:

array([['TV']], dtype='<U5')

In [15]:

oh_encoder.transform([['냉장고']]).toarray()

Out [15]:

array([[0., 1., 0., 0., 0., 0.]])

In [16]:

import pandas as pd

In [17]:

df = pd.DataFrame({'item':['TV', '냉장고', '전자레인지', '컴퓨터', '컴퓨터', '선풍기', '선풍기', '믹서', '믹서']})

In [18]:

# 숫자형 변환 없이도 바로 변환 가능
pd.get_dummies(df['item']) # 특정컬럼 지정하지 않으면 item_TV, item_냉장고 처럼 컬럼이 나옴

Out [18]:

	TV	냉장고	믹서	선풍기	전자레인지	컴퓨터
0	1	0	0	0	0	0
1	0	1	0	0	0	0
2	0	0	0	0	1	0
3	0	0	0	0	0	1
4	0	0	0	0	0	1
5	0	0	0	1	0	0
6	0	0	0	1	0	0
7	0	0	1	0	0	0
8	0	0	1	0	0	0

피처 스케일링과 정규화

서로 다른 변수의 값 범위를 일정한 수준으로 맞추는 작업이다.

표준화(Standardization)
평균이 0이고 분산이 1인 가우시안 정규 분포를 가진 값으로 변환한다.

\[x_i\_new=\frac{x_i-mean(x)}{stdev(x)}\]

정규화(Normalization)
서로다른 피처의 크기를 통일하기 위해 크기를 변환해주는 개념이다.
값들의 범위를 0에서 1사이로 변환한다.

\[x_i\_new=\frac{x_i-min(x)}{max(x)-min(x)}\]

사이킷런에서의 정규화(벡터 정규화)
선형대수에서의 정규화 개념이 적용된다.
개별 벡터의 크기를 맞추기 위해 변환하는 것을 의미한다.
개별 벡터를 모든 피처 벡터의 크기로 나눠준다.

\[x_i\_new=\frac{x_i}{\sqrt{x_i^2+y_i^2+z_i^2}}\]

StandardScaler

표준화를 쉽게 지원하기 위한 클래스
가우시안 정규분포를 따르는 데이터에 적용

In [19]:

from sklearn.datasets import load_iris

In [20]:

iris = load_iris(as_frame=True)

In [21]:

# 평균확인
iris.data.mean()

Out [21]:

sepal length (cm)    5.843333
sepal width (cm)     3.057333
petal length (cm)    3.758000
petal width (cm)     1.199333
dtype: float64

In [22]:

# 분산확인
iris.data.var()

Out [22]:

sepal length (cm)    0.685694
sepal width (cm)     0.189979
petal length (cm)    3.116278
petal width (cm)     0.581006
dtype: float64

In [23]:

from sklearn.preprocessing import StandardScaler

In [24]:

scaler = StandardScaler()
scaler.fit(iris.data)
iris_scaled = scaler.transform(iris.data)

In [25]:

# transform시 numpy ndarray로 반환되므로 DataFrame으로 변환
iris_df = pd.DataFrame(iris_scaled)

In [26]:

# 스케일된 데이터의 평균확인
iris_df.mean().round(5)

Out [26]:

 -0.0
 -0.0
 -0.0
 -0.0
dtype: float64

In [27]:

# 스케일된 데이터의 분산확인
iris_df.var()

Out [27]:

  1.006711
  1.006711
  1.006711
  1.006711
dtype: float64

MinMaxScaler

데이터의 분포가 가우시안 분포가 아닐 경우에 적용해 볼 수 있다.

In [28]:

from sklearn.preprocessing import MinMaxScaler

In [29]:

# 최소값 확인
iris.data.min()

Out [29]:

sepal length (cm)    4.3
sepal width (cm)     2.0
petal length (cm)    1.0
petal width (cm)     0.1
dtype: float64

In [30]:

# 최대값 확인
iris.data.max()

Out [30]:

sepal length (cm)    7.9
sepal width (cm)     4.4
petal length (cm)    6.9
petal width (cm)     2.5
dtype: float64

In [31]:

scaler = MinMaxScaler()
scaler.fit(iris.data)
iris_scaled = scaler.transform(iris.data)
iris_df = pd.DataFrame(iris_scaled)

In [32]:

# 스케일된 데이터의 최솟값 확인
iris_df.min()

Out [32]:

  0.0
  0.0
  0.0
  0.0
dtype: float64

In [33]:

# 스케일된 데이터의 최댓값 확인
iris_df.max()

Out [33]:

  1.0
  1.0
  1.0
  1.0
dtype: float64

학습 데이터와 테스트 데이터의 스케일링 변환 시 유의점

학습 데이터 세트로 fit()과 transform()을 적용하면 테스트 데이터 세트로는 다시 fit()을 수행하지 않고 학습 데이터 세트로 fit()을 수행한 결과를 이용해 transform() 변환을 적용해야 한다

In [34]:

train_array = np.arange(0, 11).reshape(-1, 1)
train_array

Out [34]:

array([[ 0],
       [ 1],
       [ 2],
       [ 3],
       [ 4],
       [ 5],
       [ 6],
       [ 7],
       [ 8],
       [ 9],
       [10]])

In [35]:

test_array = np.arange(0, 6).reshape(-1, 1)
test_array

Out [35]:

array([[0],
       [1],
       [2],
       [3],
       [4],
       [5]])

In [36]:

scaler = MinMaxScaler()
scaler.fit(train_array)
train_array = scaler.transform(train_array)

In [37]:

train_array

Out [37]:

array([[0. ],
       [0.1],
       [0.2],
       [0.3],
       [0.4],
       [0.5],
       [0.6],
       [0.7],
       [0.8],
       [0.9],
       [1. ]])

In [38]:

# train으로 fit된 scaler에 test는 transform만 수행
test_array = scaler.transform(test_array)

In [39]:

test_array

Out [39]:

array([[0. ],
       [0.1],
       [0.2],
       [0.3],
       [0.4],
       [0.5]])

In [40]:

# 잘못된 사용
scaler.fit(test_array)
test_array = scaler.transform(test_array)

In [41]:

test_array

Out [41]:

array([[0. ],
       [0.2],
       [0.4],
       [0.6],
       [0.8],
       [1. ]])

가능하다면 전체 데이터의 스케일링 변환을 적용한 뒤 학습과 테스트 데이터로 분리
위가 여의치 않다면 테스트 데이터 변환시에는 fit()이나 fit_transform()을 적용하지 않고 학습 데이터로 이미 fit()된 scaler 객체를 이용해 transform()으로 변환

Reference

이 포스트는 SeSAC 인공지능 자연어처리, 컴퓨터비전 기술을 활용한 응용 SW 개발자 양성 과정 - 심선조 강사님의 강의를 정리한 내용입니다.

Twitter Facebook LinkedIn

Kwak Jisub

Machine Learning (3) - 데이터 전처리

사이킷런으로 시작하는 머신러닝

데이터 전처리(Data Preprocessing)

데이터 인코딩

레이블 인코딩(Label encoding)

One-Hot Encoding

피처 스케일링과 정규화

StandardScaler

MinMaxScaler

학습 데이터와 테스트 데이터의 스케일링 변환 시 유의점

Reference

공유하기

댓글남기기

참고

python max 함수의 매개변수

python round 함수의 문제

python set 자료형과 메소드

MySQL GROUP BY와 MAX

	TV	냉장고	믹서	선풍기	전자레인지	컴퓨터
0	1	0	0	0	0	0
1	0	1	0	0	0	0
2	0	0	0	0	1	0
3	0	0	0	0	0	1
4	0	0	0	0	0	1
5	0	0	0	1	0	0
6	0	0	0	1	0	0
7	0	0	1	0	0	0
8	0	0	1	0	0	0

	TV	냉장고	믹서	선풍기	전자레인지	컴퓨터
0	1	0	0	0	0	0
1	0	1	0	0	0	0
2	0	0	0	0	1	0
3	0	0	0	0	0	1
4	0	0	0	0	0	1
5	0	0	0	1	0	0
6	0	0	0	1	0	0
7	0	0	1	0	0	0
8	0	0	1	0	0	0

	TV	냉장고	믹서	선풍기	전자레인지	컴퓨터
0	1	0	0	0	0	0
1	0	1	0	0	0	0
2	0	0	0	0	1	0
3	0	0	0	0	0	1
4	0	0	0	0	0	1
5	0	0	0	1	0	0
6	0	0	0	1	0	0
7	0	0	1	0	0	0
8	0	0	1	0	0	0