PP-Encoding and Discritization

개요

1. 인코딩(Encoding)이란?

1) 인코딩의 개념

• 많은 실제 데이터셋에는 수치형, 범주형변수가 혼재하고 있다
• 즉, 컴퓨터 입장에서 데이터를 처리하기 용이하도록 데이터를 변경하는
  작업이필요함
• 이 작업을 인코딩이라고 명명함

2) 인코딩의 종류

• 레이블 인코딩(Label encoding)
  - 범주형 데이터(string)를 수치형 데이터로 변환

• 이진화(Binarizsaztion) / 이산화(Discretization)
  - 수치형 데이터(numerical)를 범주형 데이터로 변환
  - 분류문제에서 사용(종속변수가 범주형이여야 하기때문)

• 원핫인코딩(One-hot encoding) / 더미변수화(Dummy encoding)
  - 범주형 데이터를 수치형 데이터으로 변환
  - 회귀모형 또는 신경망에서 사용(독립변수가 수치형이여야 하기 때문)

• 정수인코딩(Integer encoding)
  - 텍스트 데이터의 각 단어를 토큰화 한 후 정수값으로 할당(매핑)
  - 자연어처리(NLP)과정에서 사용

  3) 인코딩의 장단점 정리
  

2. 범주화(Discritization) 란?

1) 범주화 개념

• 연속형 변수를 구간별로 나누어 범주형 변수로 변환하는 것
• quantization 또는 binning이라고도 부름

인코딩 코드 정리

1. 범주형 -> 수치형(이산)

1) 함수 정리

• OrdinalEncoder()

• 범주형 데이터를 정수로 인코딩 / 여러 column에 사용 가능

• LabelEncoder()

• 범주형 데이터를 정수로 인코딩 / 하나의 column에만 사용 가능

• TargetEncoder()

• 범주형 데이터를 특정한 column의 값의 크기와 비례한 숫자로 인코딩

2) 코드

• 테스트를 위한 데이터세트 생성

import pandas as pd

# 독립변수 : weight, height, sex, blood_type, health
# 각 독립변수들이 수치형(연속형)과 범주형데이터들을 모두 갖고 있음

df = pd.DataFrame({'weight':[40, 80, 60, 50, 90], 
                   'height':[162, 155, 182, 173, 177], 
                   'sex':['f', 'm', 'm', 'f', 'm'], 
                   'blood_type':['O', 'A', 'B', 'O', 'A'], 
                   'health':['good', 'excellent', 'bad', 'bad', 'good'],
                   })

df

• OrdinalEncoder 사용

# 필요 패키지(클래스 / 함수) 가져오기
from sklearn.preprocessing import OrdinalEncoder

# OrdinalEncoder 수정된 사용

# 데이터프레임 복사(df를 여러번 사용하기 위함)
df_oe = df.copy()

# OrdinalEncoder에 대한 객체 생성
oe = OrdinalEncoder()

# 데이터로 oe 학습
oe.fit(df[['sex', 'blood_type']])

# 학습된 결과 
print(f'{oe.categories_=}')

# 학습된 결과를 적용하여 삽입
df_oe.iloc[:,2:4] = oe.transform(df[['sex', 'blood_type']])
df_oe

• LabelEncoder 사용

# 필요 패키지(클래스 / 함수)가져오기
from sklearn.preprocessing import LabelEncoder

# 데이터프레임 복사(df를 반복적으로 사용하기 위함)
df_le = df.copy()

# LabelEncoder는 하나의 변수에 대해서만 변환 가능함

# LabelEncoder 객체 생성과 fit을 동시에 적용할 수 있음
health_le = LabelEncoder().fit(df.health)
df_le['health'] = health_le.transform(df.health)
df_le

# +) fit_transform() 메서드를 사용하여 한번에 인코딩 수행가능
df_le['health'] = LabelEncoder().fit_transform(df.health)
df_le

• TargetEncoder 사용

# 필요한 패키지(클래스 / 함수) 가져오기
from sklearn.preprocessing import TargetEncoder

# 데이터프레임 복사(df를 반복적으로 사용하기 위함)
df_te = df.copy()

# TargetEncoder에 대한 객체 생성
# smooth -> 정밀도 조정 / target_type -> 인코딩 타입 지정
te = TargetEncoder(smooth=0, target_type='continuous')

# te 학습 / 타겟 -> weight, 인코딩대상 -> blood_type
# 즉, blood_type_target은 weight와 비례하여 인코딩된 값
te.fit(df['blood_type'].values.reshape(-1, 1), df.weight)
# 인코딩이 되는 값(blood_type)은 2차원데이터로 변환시켜야 함

# 학습된 결과 
print(f'{te.categories_=}')

# 학습된 결과를 적용하여(새로운 컬럼 생성 후 삽입)
df_te['blood_type_target'] = te.transform(df['blood_type'].values.reshape(-1, 1))
df_te

2. 범주형 데이터 -> 이진 데이터

1) 함수 정리

• OneHotEncoder()

• 한 column에 있는 범주형 데이터를 여러개의 이진수 데이터로 인코딩
• one-of-K 인코딩이라고도 부름

• get_dummies()

• Pandas에서 제공함 / One-hot encoding과 동일한 기능
• 여러 컬럼을 한 번에 변환 가능함
• 회귀분석에서 범주형 변수를 고려할 때 사용

2) 코드

• 원핫인코딩(One-Hot-Encoding)

# 필요한 패키지(클래스 / 함수) 가져오기
from sklearn.preprocessing import OneHotEncoder

# 데이터프레임 복사(df를 반복적으로 사용하기 위함)
df_ohe = df.copy()

# OneHotEncoder에 대한 객체 생성 후 바로 fit하기
ohe = OneHotEncoder().fit(df_ohe[['blood_type']])

# 학습된 결과 
print(f'{ohe.categories_=}')

# 학습된 결과를 적용하여 새로운 컬럼 삽입
# 주의 : OneHotEncoder는 결과를 sparse matrix로 반환하기 때문에 toarray()를 통해 ndarray로 변환

df_ohe[ohe.categories_[0]] = ohe.transform(df_ohe[['blood_type']]).toarray()
df_ohe

• Dummy encoding

# 원 핫 인코딩과 동일기능이므로, 자세한 설명은 생략함
pd.get_dummies(df, columns=['sex', 'blood_type'], drop_first=False)

3. 연속 수치형 데이터 -> 이진 데이터

1) 함수 정리

• Binerizer()

• 연속 수치형 데이터를 임계값을 기준으로 하여 이진수로 인코딩

• LabelBinerizer()

• 연속형 데이터를 이진수 column으로 인코딩
• 하나의 column에만 사용 가능

• MultiLabelBinerizer()

• 여러개의 범주가 있는 데이터를 이진수 컬럼으로 인코딩
• 하나의 column에만 사용 가능

2) 코드

• Binerizer

# 필요한 패키지(클래스 / 함수) 가져오기
from sklearn.preprocessing import Binarizer

# 데이터 불러오기(df를 지속적으로 사용하기 위함)
df_bin = df.copy()

# Binarizer 객체 생성과 fit, transform을 동시에 적용
# 주의 : Binarizer는 수치형 변수에 대해서만 변환 가능
df_bin['weight_bin'] = Binarizer(threshold=50).fit_transform(df.weight.values.reshape(-1,1))
df_bin['height_bin'] = Binarizer(threshold=170).fit_transform(df.height.values.reshape(-1,1))

# 결과
df_bin

• LabelBinerizer

# 필요한 패키지(클래스 / 함수)를 가져오기
from sklearn.preprocessing import LabelBinarizer

# 데이터프레임 복사(df를 반복적으로 사용하기 위함)
df_lb = df.copy()

# LabelBinarizer 객체 생성과 fit을 한번에 적용
lb = LabelBinarizer().fit(df.health)

# lb.classes_ : LabelBinarizer가 인코딩한 클래스 확인
print(f'{lb.classes_ = }')

# 인코딩 변환 후 health_lb에 저장 / 결과확인
health_lb = lb.transform(df.health)
print('health_lb = \n', health_lb)

# 인코딩된 데이터를 데이터프레임으로 변환
df_lb[lb.classes_] = health_lb
df_lb

• MultiLabelBinerizer

# 필요 패키지 가져오기
from sklearn.preprocessing import MultiLabelBinarizer

# 데이터프레임 복사(df를 지속적으로 사용하기 위함)
df_mlb = df.copy()

# 여러개의 범주를 위한 컬럼 추가(데이터 준비정)
df_mlb['test'] = [['math', 'english'], ['math', 'science'], ['science'], ['math', 'english'], 
                           ['science']] # target: test, categorical, multi-class

# 준비된 데이터 확인
df_mlb

# MultiLabelBinarizer 객체를 생성하고 fit() 메소드를 호출하여 클래스를 인코딩
mlb = MultiLabelBinarizer().fit(df_mlb.test)

# classes_ 속성을 사용하면 어떤 클래스가 인코딩되었는지 확인 가능
print(f'{mlb.classes_ = }')

# 인코딩된 데이터를 데이터프레임으로 변환
df_mlb[mlb.classes_] = mlb.transform(df_mlb.test)

# 결과 확인
df_mlb

범주화 코드 정리

1) 코드

• K-bins discretization

# 필요 패키지(클래스 / 함수) 가져오기
from sklearn.preprocessing import KBinsDiscretizer

# 데이터프레임 복사(df를 반복적으로 사용하기 위함)
df_kbd = df.copy()

# KBinsDiscretizer 객체 생성과 fit을 적용
kbd = KBinsDiscretizer(n_bins=3, encode='ordinal').fit(df[['weight', 'height']])

# kbd.transform() : 인코딩 변환 / 인코딩결과 데이터프레임으로 변환
df_kbd[['weight_bin', 'height_bin']] = kbd.transform(df[['weight', 'height']])

# 결과확인
df_kbd