데이터 전처리는 데이터를 분석하기 전에 적합한 형태로 가공하는 과정이다. 데이터 전처리는 매우 중요한 과정으로 전체 프로세스의 80% 정도를 차지한다. 특히, 머신러닝의 학습을 위해서 학습이 용이한 형태로 가공이 필요하다. 데이터 전처리는 보통 데이터 수집 -> 데이터 프로파일링 -> 데이터 정제 -> 데이터 축소 -> 데이터 변환 -> 데이터 준비의 과정을 거친다.

최초에 수집된 데이터는 다양한 요인에 의해 분석을 방해하는 요소가 존재하기 마련이다. 그렇기 때문에 데이터의 잘못된 분석 결과를 막기 위해서 데이터 전처리는 필수적이다. 하지만 데이터 전처리 과정을 이해하는 것은 아직 나에게는 매우 어려운 일이다. 통계적인 지식은 물론이고, 파이썬을 비롯한 다양한 프로그래밍 언어 또한 숙련되어야 한다. 거기다 많이 수행해봐야 한다는 점에서 포털에 존재하는 다양한 데이터들로 연습을 해봐야 한다. 따라서, 아직 나의 상태로는 데이터 전처리를 아무 도움 없이 하기에 매우 서툴고 어렵기 때문에 데이터 전처리 강의를 통해 배운 내용과 타인이 수행한 데이터 전처리 코드와 내용을 참고하여 해당 내용을 직접 연습해보고 진행 과정을 스스로 분석해봄으로써 데이터 전처리 과정과 목적을 다시 한번 깨닫고 부족한 코딩 실력에도 도움이 될 수 있게 연습하는 게 이번 프로젝트의 목적이다.

이번 데이터 전처리의 내용은 질병관리청의 지역사회 건강조사 사이트에서 진행된 설문조사 자료를 통해 진행된다. 공원과 건강 간의 상관관계를 분석해보고자 해당 데이터를 수집하여 데이터 전처리를 해보는 것이다. 해당 자료를 수집한 후 데이터 전처리 과정을 통해 정제 및 변환을 수행하고, 데이터를 시각화 해보는 순서로 프로젝트가 진행된다.

2. 본론

데이터 수집

1. 2019년에 각 설문조사가 진행된 보건소정보와 세대유형
2. 2019년에 진행된 설문조사에서 서울특별시에 해당하는 설문조사 (지역 사회 건강 조사 원시 자료)
3. 2019년 서울시 주민등록인구(연령별구별) 통계 (이미 정제된 데이터)
4. 2019년 서울시 자치구 재정자립도 (이미 정제된 데이터)
5. 2019년 서울시 신고 등록 체육시설 통계 (이미 정제된 데이터)
6. 2019년 서울시 공원 데이터 (이미 정제된 데이터)

데이터 정리

1. 서울시의 각 자치구별 구분을 하기 위해서 1번 자료에서 보건소 정보를 추출하였다.

   import pandas as pd
   

df = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등'+
'/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx', header=3) # # 엑셀 파일이기 때문에 시작위치가 고정되지 않음. header를 사용하여 불러올 시작 위치 지정 df

![](https://velog.velcdn.com/images/hate_all/post/368b9abf-9c0a-4e96-b200-253850575e6a/image.png)

시도명이 서울특별시인 보건소코드와 보건소명을 데이터프레임으로 뽑는다. 다음에 다른 데이터프레임에 사용할 것이다.

```python
data_pbhlth_code = df[df['시도코드'] == 11][['보건소코드','보건소명']]
# 시도코드 11 (서울특별시)인 보건소코드와 보건소명만 데이터프레임으로 입력

data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True)
# 보건소명을 제외하고 자치구만 남기기 위해서 replace로 공백 대체

data_pbhlth_code.columns=['보건소코드','자치구'] # 보건소코드와 자치구를 column으로 지정

data_pbhlth_code.set_index('보건소코드',inplace=True)
# inplace = True는 원본 데이터프레임을 변경하는 것이다. (기본값은 False여서 해당 데이터프레임을 copy한 결과를 보여준다)
# 보건소코드를 인덱스로 지정하여 추후에 데이터프레임에서 인덱스로 연산
data_pbhlth_code.head(6)

2. 위는 2번 자료에 대한 사진이다. 해당 자료에는 다양한 항목들이 존재한다. 서론에서의 목적에 맞게 공원이나 신체활동, 건강상태와 관련된 항목들을 추출한다. 추가로 소득도 관련이 있나 뽑아보았다. 그리하여 가져오기로 한 자료의 변수 명에 대하여 알아보자면 age는 만 나이, sex는 성별, pbhlth_code는 보건소번호, qoa_01z1는 주관적 건강수준, pha_04z1는 격렬한 신체활동 일수, pha_05z1는 격렬한 신체활동 시간(시), pha_06z1는 격렬한 신체활동 시간(분), pha_07z1는 중등도 신체활동 일수, pha_08z1는 중등도 신체활동 시간(시), pha_09z1는 중등도 신체활동 시간(분), phb_01z1는 걷기 실천 일수, phb_02z1는 걷기 실천 시간(시), phb_03z1는 걷기 실천 시간(분), obb_01z1는 체중조절 경험 여부, mta_01z1는 주관적 스트레스 수준, mtb_01z1는 우울감 경험 여부, qoc_07z1는 행복감 지수, ena_01d1는 사회환경_동네 자연환경, ena_01e1는 사회환경_동네 생활환경, fma_01z1는 가구원수, fma_12z1는 가구소득_년월, fma_13z1는 가구소득_년금액, fma_14z1는 가구소득_월금액, fma_24z2는 조건부가구소득이다.

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 원시자료/chs19_a.txt',sep ='\t', encoding = 'cp949')
data_raw.head()

df_raw1 = data_raw[['age','sex','pbhlth_code','qoa_01z1',
                    'pha_04z1','pha_05z1','pha_06z1','pha_07z1','pha_08z1','pha_09z1',
                    'phb_01z1','phb_02z1','phb_03z1','obb_01z1','mta_01z1','mtb_01z1',
                    'qoc_07z1','ena_01d1','ena_01e1',
                    'fma_01z1','fma_12z1','fma_13z1','fma_14z1','fma_24z2']]

index = ['만나이','성별','보건소번호','주관적 건강수준',
         '격렬한 신체활동 일수','격렬한 신체활동 시간(시)','격렬한 신체활동 시간(분)',
         '중등도 신체활동 일수','중등도 신체활동 시간(시)','중등도 신체활동 시간(분)',
         '걷기 실천 일수','걷기 실천 시간(시)','걷기 실천 시간(분)',
         '체중조절 경험 여부','주관적 스트레스 수준','우울감 경험 여부','행복감 지수',
         '사회환경_동네 자연환경','사회환경_동네 생활환경',
         '가구원수','가구소득_년월','가구소득_년금액','가구소득_월금액','조건부가구소득']

df_raw1.columns = index # 각 항목에 들어있는 코드들을 이해할 수 있는 변수 라벨로 변경하여 column으로 설정
df_raw2 = df_raw1.copy() # SettingWithCopyWarning 방지

df_raw2['자치구'] = df_raw2['보건소번호'].map(data_pbhlth_code.to_dict()['자치구'])
# map을 이용하여 위에서 구한 보건소번호에 해당하는 자치구를 df_raq2에 추가
df_raw3 = df_raw2.drop(['보건소번호'],axis=1) # 더 이상 필요없는 보건소번호를 drop을 시킴
df_raw3.to_csv("C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 1차 전처리_2019.csv", mode='w',encoding = 'utf-8-sig')
df_raw3

이 다음부터 사용할 데이터는 지역사회건강조사 1차 전처리_2019.csv 파일이다.

범주형 데이터 전처리

• 주관적 건강수준이나 행복감지수 같은 범주형 데이터는 결측치를 제거하고, 전체와 각 자치구 별로 나누었다. 그리고 그 안에서도 나이대별과 성별로 나눠서 인덱스를 지정하였다. (코드 진행이 비슷)

• 결측치에 해당하는 모름이나 응답거부에 해당하는 데이터들을 삭제하였다.(예-행복감지수에서 77은 응답거부, 99는 모름이다.)

1. 행복감지수 전처리 수행

   data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')
   

df = data_raw[['만나이','성별','행복감 지수','자치구']]

df_hi1=df[df['행복감 지수'] != 99] # 99는 모름 df_hi2=df_hi1[df_hi1['행복감 지수'] != 77] # 77은 응답거부

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3) data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']] data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True) data_pbhlth_code.columns=['보건소코드','자치구']

list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시'] # 전체 합에 해당하는 서울시 추가 list_region.reverse() # 서울시가 맨 위에 올라오도록 reverse 사용

list_region에는 서울시를 비롯한 각 자치구가 들어오게 된다. 그 다음 데이터들을 자치구끼리 묶고, 전체 데이터를 서울시로 묶는다.

```python
list_df = []
for value in list_region:
    temp = df_hi2['자치구'] == value
    # list_region에 들어있는 자치구와 df_hi2에 있는 자치구와 동일하면 temp에는 True과 들어가고, 같지 않으면 False

    list_df.append(df_hi2[temp]) # 그래서 temp가 true이면 value와 동일한 자치구를 가진 데이터프레임을 리스트에 넣는다

list_df[0] = df_hi2
# df_hi2에서 자치구 column에는 서울시가 없기 때문에 list_df[0]은 빈 데이터프레임이 들어있는데 여기에 전체 데이터를 넣어준다.

각 자치구별 데이터들을 연령별, 성별로 나눠서 하나의 데이터프레임으로 만든다.

list_age = ['19~200','19~44','45~64','65~74','75~200'] # 전체 / 19~44  45~64 / 65~74 / 75이상 으로 나누기 위해서 범위 설정
list_sex = ['계','남','여']
idx_sex = []
idx_age = []
idx_region = []
value_hi = []
# 크게 자치구 -> 연령대 -> 성별로 하위 인덱스를 만드식으로 작업하면서 계(전체)에 해당하는 값을 살리려고 함
for i, value1 in enumerate(list_region): # enumerate를 이용해 list_df의 인덱스와 자치구로 이용
    for j in list_age:
        for k in list_sex:            
            temp = list_df[i][list_df[i]['만나이']>=int(j.split('~')[0])] 
            temp1 = temp[temp['만나이'] <= int(j.split('~')[1])] # 연령대를 ~를 기준으로 이상, 이하로 데이터 처리

            # 이 부분은 위에 list_age에서 넘어오는 계 / 남 / 여를 구분해서 만들기 위해 아래와 같이 조건문 사용
            if k == '남':
                temp2 = temp1[temp1['성별'] == 1]
            elif k == '여':
                temp2 = temp1[temp1['성별'] == 2]
            else:
                temp2 = temp1

            # 행복감 지수는 범주형 데이터여서 value_counts()롤 각각의 값에 해당하는 데이터들의 갯수를 세어서 딕셔너리로 만듬
            temp3 = temp2['행복감 지수'].value_counts().to_dict()
            # 행복감 지수는 1부터 10까지 이루어져있지만, 설문조사상 해당하는 값이 없는 경우는 딕셔너리가 만들어지지 않음
            # 그래서 없는 값도 생성 후 0으로 넣어서 추후 전처리 작업 진행간에 오류 발생 방지
            for m in range(1,11): 
                if m not in temp3: 
                    temp3[m] = 0

            temp_sum = 0
            # 이 구간에서 없는 값은 오류가 발생할 수도 있어서 위에서 방지
            # 그리고 각 구간별 수와 값을 곱해서 계속해서 더한 후 나눠서, 전체 평균을 구함
            for n in range(1,11):
                temp_sum += temp3[n]*n  
            value_hi.append(round(temp_sum / len(temp2['행복감 지수']),2))

            # 아래 작업은 멀티 인덱스를 생성하기 위해서 순서대로 idx 리스트에 해당하는 값을 삽입
            if j == '19~200':
                idx_age.append('계')
            elif j == '75~200':
                idx_age.append('75 이상')
            else:
                idx_age.append(j)
            idx_sex.append(k)
            idx_region.append(value1)

df_final = pd.DataFrame({'행복감 지수':value_hi, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 (전처리된 데이터)_2019/지역사회건강조사 (행복감 지수)_2019.csv", mode='w',encoding = 'utf-8-sig')

df_final

2. 체중조절 경험 여부 전처리 수행 (9 -> 모름, 7 -> 응답거부)

import pandas as pd
import numpy as np

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','체중조절 경험 여부','자치구']]

df_cw1=df[df['체중조절 경험 여부'] != 9]
df_cw2=df_cw1[df_cw1['체중조절 경험 여부'] != 7]
df_cw2['체중조절 경험 여부'].value_counts(normalize = True)
# 고유 값별 데이터 수를 나타낸다.
# normalize 옵션도 가능.

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3)
data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']]
data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True)
data_pbhlth_code.columns=['보건소코드','자치구']
list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시']
list_region.reverse()

list_df = []
for value in list_region:
    temp = df_cw2['자치구'] == value
    list_df.append(df_cw2[temp])
list_df[0] = df_cw2

list_age = ['19~200','19~44','45~64','65~74','75~200']
list_sex = ['계','남','여']
idx_sex = []
idx_age = []
idx_region = []
value_cw = []
for i, value1 in enumerate(list_region):
    for j in list_age:
        for k in list_sex:            
            temp = list_df[i][list_df[i]['만나이']>=int(j.split('~')[0])]
            temp1 = temp[temp['만나이'] <= int(j.split('~')[1])]
            if k == '남':
                temp2 = temp1[temp1['성별'] == 1]
            elif k == '여':
                temp2 = temp1[temp1['성별'] == 2]
            else:
                temp2 = temp1
            temp3 = temp2['체중조절 경험 여부'].value_counts(normalize = True).to_dict()
            if 4 not in temp3:
                temp3[4] = 0
            if 3 not in temp3:
                temp3[3] = 0
            value_cw.append(round(100 - (temp3[3]+temp3[4])*100,1)) # 위 조건으로 경험 여부(1,2,3,4)가 최종 형태처럼(한지 안 한지에 대한 비율 형태) 변함.

            if j == '19~200':
                idx_age.append('계')
            elif j == '75~200':
                idx_age.append('75 이상')
            else:
                idx_age.append(j)
            idx_sex.append(k)
            idx_region.append(value1)

df_final = pd.DataFrame({'체중조절 경험 여부':value_cw, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (체중조절)_2019.csv", mode='w',encoding = 'utf-8-sig')

3. 우울감 전처리 수행 (9 -> 모름, 7 -> 응답거부, 응답 -> 1 or 2)

import pandas as pd
import numpy as np

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','우울감 경험 여부','자치구']]

df_dep1=df[df['우울감 경험 여부'] != 9]
df_dep2=df_dep1[df_dep1['우울감 경험 여부'] != 7]

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3)
data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']]
data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True)
data_pbhlth_code.columns=['보건소코드','자치구']
list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시']
list_region.reverse()

list_df = []
for value in list_region:
    temp = df_dep2['자치구'] == value
    list_df.append(df_dep2[temp])
list_df[0] = df_dep2

list_age = ['19~200','19~44','45~64','65~74','75~200']
list_sex = ['계','남','여']
idx_sex = []
idx_age = []
idx_region = []
value_dep = []
for i, value1 in enumerate(list_region):
    for j in list_age:
        for k in list_sex:            
            temp = list_df[i][list_df[i]['만나이']>=int(j.split('~')[0])]
            temp1 = temp[temp['만나이'] <= int(j.split('~')[1])]
            if k == '남':
                temp2 = temp1[temp1['성별'] == 1]
            elif k == '여':
                temp2 = temp1[temp1['성별'] == 2]
            else:
                temp2 = temp1
            value_dep.append(round(100 - temp2['우울감 경험 여부'].value_counts(normalize = True)[2]*100,1))
            if j == '19~200':
                idx_age.append('계')
            elif j == '75~200':
                idx_age.append('75 이상')
            else:
                idx_age.append(j)
            idx_sex.append(k)
            idx_region.append(value1)

df_final = pd.DataFrame({'우울감 경험률':value_dep, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (우울감)_2019.csv", mode='w',encoding = 'utf-8-sig')

4. 스트레스 전처리 수행 (9 -> 모름, 7 -> 응답거부)

   import pandas as pd
   import numpy as np
   

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','주관적 스트레스 수준','자치구']]

df_sl1=df[df['주관적 스트레스 수준'] != 9] df_sl2=df_sl1[df_sl1['주관적 스트레스 수준'] != 7] df_sl2['주관적 스트레스 수준'].value_counts(normalize = True)

![](https://velog.velcdn.com/images/hate_all/post/e300ab1d-3520-4e3b-adf5-d877f7f18387/image.png)

```python
data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3)
data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']]
data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True)
data_pbhlth_code.columns=['보건소코드','자치구']
list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시']
list_region.reverse()

list_df = []
for value in list_region:
    temp = df_sl2['자치구'] == value
    list_df.append(df_sl2[temp])
list_df[0] = df_sl2

list_age = ['19~200','19~44','45~64','65~74','75~200']
list_sex = ['계','남','여']
idx_sex = []
idx_age = []
idx_region = []
value_hl = []
for i, value1 in enumerate(list_region):
    for j in list_age:
        for k in list_sex:            
            temp = list_df[i][list_df[i]['만나이']>=int(j.split('~')[0])]
            temp1 = temp[temp['만나이'] <= int(j.split('~')[1])]
            if k == '남':
                temp2 = temp1[temp1['성별'] == 1]
            elif k == '여':
                temp2 = temp1[temp1['성별'] == 2]
            else:
                temp2 = temp1
            temp3 = temp2['주관적 스트레스 수준'].value_counts(normalize = True).to_dict()
            if 4 not in temp3:
                temp3[4] = 0
            if 1 not in temp3:
                temp3[1] = 0
            value_hl.append(round((temp3[1]+temp3[2])*100,1))

            if j == '19~200':
                idx_age.append('계')
            elif j == '75~200':
                idx_age.append('75 이상')
            else:
                idx_age.append(j)
            idx_sex.append(k)
            idx_region.append(value1)

df_final = pd.DataFrame({'주관적 스트레스 수준':value_hl, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (스트레스)_2019.csv", mode='w',encoding = 'utf-8-sig')

5. 자연환경 전처리 수행 (9 -> 모름, 7 -> 응답거부)

   import pandas as pd
   import numpy as np
   

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','사회환경_동네 자연환경','자치구']]

df_ne1=df[df['사회환경_동네 자연환경'] != 9] df_ne2=df_ne1[df_ne1['사회환경_동네 자연환경'] != 7]

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3) data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']] data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True) data_pbhlth_code.columns=['보건소코드','자치구'] list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시'] list_region.reverse()

list_df = [] for value in list_region: temp = df_ne2['자치구'] == value list_df.append(df_ne2[temp]) list_df[0] = df_ne2

list_age = ['19200','1944','4564','6574','75200'] list_sex = ['계','남','여'] idx_sex = [] idx_age = [] idx_region = [] value_ne = [] for i, value1 in enumerate(list_region): for j in list_age: for k in list_sex:
temp = list_df[i][list_df[i]['만나이']>=int(j.split('')[0])] temp1 = temp[temp['만나이'] <= int(j.split('')[1])] if k == '남': temp2 = temp1[temp1['성별'] == 1] elif k == '여': temp2 = temp1[temp1['성별'] == 2] else: temp2 = temp1 value_ne.append(round(temp2['사회환경_동네 자연환경'].value_counts(normalize = True)[1]*100,1)) if j == '19200': idx_age.append('계') elif j == '75~200': idx_age.append('75 이상') else: idx_age.append(j) idx_sex.append(k) idx_region.append(value1)

df_final = pd.DataFrame({'긍정적 태도율(자연환경)':value_ne, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (긍정적 태도율(자연환경))_2019.csv", mode='w',encoding = 'utf-8-sig')

![](https://velog.velcdn.com/images/hate_all/post/2ca57813-2283-41ed-839f-6062d4ca7e49/image.png)

6. 건강수준 전처리 수행 (9 -> 모름, 7 -> 응답거부)
```python
import pandas as pd
import numpy as np

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','주관적 건강수준','자치구']]

df_hl1=df[df['주관적 건강수준'] != 9]
df_hl2=df_hl1[df_hl1['주관적 건강수준'] != 7]
df_hl2['주관적 건강수준'].value_counts(normalize = True)

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3)
data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']]
data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True)
data_pbhlth_code.columns=['보건소코드','자치구']
list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시']
list_region.reverse()

list_df = []
for value in list_region:
    temp = df_hl2['자치구'] == value
    list_df.append(df_hl2[temp])
list_df[0] = df_hl2

list_age = ['19~200','19~44','45~64','65~74','75~200']
list_sex = ['계','남','여']
idx_sex = []
idx_age = []
idx_region = []
value_hl = []
for i, value1 in enumerate(list_region):
    for j in list_age:
        for k in list_sex:            
            temp = list_df[i][list_df[i]['만나이']>=int(j.split('~')[0])]
            temp1 = temp[temp['만나이'] <= int(j.split('~')[1])]
            if k == '남':
                temp2 = temp1[temp1['성별'] == 1]
            elif k == '여':
                temp2 = temp1[temp1['성별'] == 2]
            else:
                temp2 = temp1
            temp3 = temp2['주관적 건강수준'].value_counts(normalize = True).to_dict()
            if 5 not in temp3:
                temp3[5] = 0
            if 1 not in temp3:
                temp3[1] = 0
            value_hl.append(round(100 - (temp3[3]+temp3[4]+temp3[5])*100,1))
            if j == '19~200':
                idx_age.append('계')
            elif j == '75~200':
                idx_age.append('75 이상')
            else:
                idx_age.append(j)
            idx_sex.append(k)
            idx_region.append(value1)

df_final = pd.DataFrame({'주관적 건강수준':value_hl, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (건강수준)_2019.csv", mode='w',encoding = 'utf-8-sig')

연속형 데이터 전처리

• 해당 자료에서 남은 데이터들은 시간이나 날짜로 나누어져 있기 때문에 이를 합치는 전처리를 진행할 것이다.
• 함수를 만들어 합치고 apply를 적용한 후, 멀티 인덱스를 적용하여 전처리한다.

1. 중등도 신체활동 전처리 (99 -> 모름, 77 -> 응답거부)

   import pandas as pd
   import numpy as np
   

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','자치구', '중등도 신체활동 일수', '중등도 신체활동 시간(시)','중등도 신체활동 시간(분)']]

df1=df[df['중등도 신체활동 일수'] != 99] df2=df1[df1['중등도 신체활동 일수'] != 77]

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3) data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']] data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True) data_pbhlth_code.columns=['보건소코드','자치구']

list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시'] # 전체 합에 해당하는 서울시 추가 list_region.reverse() # 서울시가 맨 위에 올라오도록 reverse 사용

```python
def transtime(df_activity) : # 시와 분을 합쳐서 총 분으로 환산하는 과정
    if 0 <= df_activity['중등도 신체활동 시간(시)'] <= 24 and df_activity['중등도 신체활동 시간(분)'] <= 59 :
        return df_activity['중등도 신체활동 시간(시)']*60 + df_activity['중등도 신체활동 시간(분)']
    else :
        return 0

def health_index(df_activity) :
    if df_activity['중등도 신체활동 일수'] < 5 :
        return 0
    # 중등도 신체활동 실천율은 다음과 같다
    # 최근 1주일 동안 평소보다 몸이 조금 힘들거나 숨이 약간 가쁜 중등도 신체활동을 1일 30분 이상, 주 5일 이상 실천한 사람의 분율
    # 따라서 아래 조건으로 해당하는 사람들은 1을 리턴하고 아니면 0을 리턴하도록 한다.
    elif 5 <= df_activity['중등도 신체활동 일수'] and df_activity['중등도 시분 환산'] >= 30 :
        return 1
    else :
        return 0

df_activity = df2.copy()

# 먼저 시분 환산이라는 새로운 column을 만들고 우리가 사용할 데이터프레임에 함수를 적용하자
df_activity["중등도 시분 환산"] = df_activity.apply(transtime, axis =1)

# 그리고 추가로 만들어진 시분 환산 column과 신체활동 일수를 이용하여
# 이 사람이 중등도 신체활동을 실천했으면 1, 그렇지 않으면 0을 주도록 하자.
df_activity['중등도 신체활동 실천'] = df_activity.apply(health_index, axis =1)

# 그리고 필요없는 column은 drop 함수를 이용하여 제거하자
df_activity = df_activity.drop(['중등도 신체활동 시간(시)','중등도 신체활동 시간(분)','중등도 신체활동 일수','중등도 시분 환산'],axis=1)        

list_df = []
for value in list_region:
    temp = df_activity['자치구'] == value
    list_df.append(df_activity[temp])
list_df[0] = df_activity

list_age = ['19~200','19~44','45~64','65~74','75~200']
list_sex = ['계','남','여']
idx_sex = []
idx_age = []
idx_region = []
value_act = []
for i, value1 in enumerate(list_region):
    for j in list_age:
        for k in list_sex:            
            temp = list_df[i][list_df[i]['만나이']>=int(j.split('~')[0])]
            temp1 = temp[temp['만나이'] <= int(j.split('~')[1])]
            if k == '남':
                temp2 = temp1[temp1['성별'] == 1]
            elif k == '여':
                temp2 = temp1[temp1['성별'] == 2]
            else:
                temp2 = temp1
            temp3 = temp2['중등도 신체활동 실천'].value_counts(normalize = True).to_dict()
            if 1 not in temp3:
                temp3[1] = 0
            if 0 not in temp3:
                temp3[0] = 0
            value_act.append(round(temp3[1]*100,1))

            if j == '19~200':
                idx_age.append('계')
            elif j == '75~200':
                idx_age.append('75 이상')
            else:
                idx_age.append(j)
            idx_sex.append(k)
            idx_region.append(value1)

df_final = pd.DataFrame({'중등도 신체활동 실천':value_act, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (중등도 신체활동)_2019.csv", mode='w',encoding = 'utf-8-sig')

2. 격렬한 신체활동 전처리 (99 -> 모름, 77 -> 응답거부)

   import pandas as pd
   import numpy as np
   

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','자치구', '격렬한 신체활동 일수', '격렬한 신체활동 시간(시)','격렬한 신체활동 시간(분)']]

df1=df[df['격렬한 신체활동 일수'] != 99] df2=df1[df1['격렬한 신체활동 일수'] != 77] df3=df2[df2['격렬한 신체활동 시간(시)'] != 99] df4=df3[df3['격렬한 신체활동 시간(시)'] != 77]

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3) data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']] data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True) data_pbhlth_code.columns=['보건소코드','자치구'] list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시'] list_region.reverse()

def transtime(df_activity) : if 0 <= df_activity['격렬한 신체활동 시간(시)'] <= 24 and df_activity['격렬한 신체활동 시간(분)'] <= 59 : return df_activity['격렬한 신체활동 시간(시)']*60 + df_activity['격렬한 신체활동 시간(분)'] else : return 0

def health_index(df_activity) : if df_activity['격렬한 신체활동 일수'] < 3 : return 0 elif 3 <= df_activity['격렬한 신체활동 일수'] and df_activity['격렬 시분 환산'] >= 20 : return 1 else : return 0

df_activity = df4.copy() # 오류제거 df_activity["격렬 시분 환산"] = df_activity.apply(transtime, axis =1) df_activity['격렬한 신체활동 실천'] = df_activity.apply(health_index, axis =1) df_activity = df_activity.drop(['격렬한 신체활동 시간(시)','격렬한 신체활동 시간(분)','격렬한 신체활동 일수','격렬 시분 환산'],axis=1)

list_df = [] for value in list_region: temp = df_activity['자치구'] == value list_df.append(df_activity[temp]) list_df[0] = df_activity

list_age = ['19200','1944','4564','6574','75200'] list_sex = ['계','남','여'] idx_sex = [] idx_age = [] idx_region = [] value_act = [] for i, value1 in enumerate(list_region): for j in list_age: for k in list_sex:
temp = list_df[i][list_df[i]['만나이']>=int(j.split('')[0])] temp1 = temp[temp['만나이'] <= int(j.split('~')[1])] if k == '남': temp2 = temp1[temp1['성별'] == 1] elif k == '여': temp2 = temp1[temp1['성별'] == 2] else: temp2 = temp1 temp3 = temp2['격렬한 신체활동 실천'].value_counts(normalize = True).to_dict() if 1 not in temp3: temp3[1] = 0 if 0 not in temp3: temp3[0] = 0 value_act.append(round(temp3[1]*100,1))

        if j == '19~200':
            idx_age.append('계')
        elif j == '75~200':
            idx_age.append('75 이상')
        else:
            idx_age.append(j)
        idx_sex.append(k)
        idx_region.append(value1)

df_final = pd.DataFrame({'격렬한 신체활동 실천':value_act, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (격렬한 신체활동)_2019.csv", mode='w',encoding = 'utf-8-sig')

![](https://velog.velcdn.com/images/hate_all/post/9b54a7c0-1db8-47eb-9485-4d5f27a8860a/image.png)

3. 걷기 전처리 (99 -> 모름, 77 -> 응답거부)
```python
import pandas as pd
import numpy as np

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','자치구', '걷기 실천 일수', '걷기 실천 시간(시)','걷기 실천 시간(분)']]

df1=df[df['걷기 실천 일수'] != 99]
df2=df1[df1['걷기 실천 일수'] != 77]

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3)
data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']]
data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True)
data_pbhlth_code.columns=['보건소코드','자치구']
list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시']
list_region.reverse()

def transtime(df_walk) :
    if 0 <= df_walk['걷기 실천 시간(시)'] <= 24 and df_walk['걷기 실천 시간(분)'] <= 59 :
        return df_walk['걷기 실천 시간(시)']*60 + df_walk['걷기 실천 시간(분)']
    else :
        return 0

def health_index(df_walk) :
    if df_walk['걷기 실천 일수'] < 5 :
        return 0
    elif 5 <= df_walk['걷기 실천 일수'] and df_walk['걷기 시분 환산'] >= 30 :
        return 1
    else :
        return 0

df_walk = df2.copy() # 오류제거
df_walk["걷기 시분 환산"] = df_walk.apply(transtime, axis =1)
df_walk['걷기 실천'] = df_walk.apply(health_index, axis =1)
df_walk = df_walk.drop(['걷기 실천 시간(시)','걷기 실천 시간(분)','걷기 실천 일수','걷기 시분 환산'],axis=1)

list_df = []
for value in list_region:
    temp = df_walk['자치구'] == value
    list_df.append(df_walk[temp])
list_df[0] = df_walk

list_age = ['19~200','19~44','45~64','65~74','75~200']
list_sex = ['계','남','여']
idx_sex = []
idx_age = []
idx_region = []
value_walk = []
for i, value1 in enumerate(list_region):
    for j in list_age:
        for k in list_sex:            
            temp = list_df[i][list_df[i]['만나이']>=int(j.split('~')[0])]
            temp1 = temp[temp['만나이'] <= int(j.split('~')[1])]
            if k == '남':
                temp2 = temp1[temp1['성별'] == 1]
            elif k == '여':
                temp2 = temp1[temp1['성별'] == 2]
            else:
                temp2 = temp1
            temp3 = temp2['걷기 실천'].value_counts(normalize = True).to_dict()
            if 1 not in temp3:
                temp3[1] = 0
            if 0 not in temp3:
                temp3[0] = 0
            value_walk.append(round(temp3[1]*100,1))

            if j == '19~200':
                idx_age.append('계')
            elif j == '75~200':
                idx_age.append('75 이상')
            else:
                idx_age.append(j)
            idx_sex.append(k)
            idx_region.append(value1)

df_final = pd.DataFrame({'걷기 실천':value_walk, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (걷기)_2019.csv", mode='w',encoding = 'utf-8-sig')

4. 소득 전처리 (9, 99999 -> 모름, 7, 77777 -> 응답거부)

   import pandas as pd
   import numpy as np
   

data_raw = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 1차 전처리_2019.csv')

df = data_raw[['만나이','성별','가구원수','가구소득_년월','가구소득_년금액','가구소득_월금액','자치구']]

df_hi1=df[df['가구소득_년금액'] != 99999] df_hi2=df_hi1[df_hi1['가구소득_년금액'] != 77777] df_hi3=df_hi2[df_hi2['가구소득_월금액'] != 99999] df_hi4=df_hi3[df_hi3['가구소득_월금액'] != 77777] df_hi5=df_hi4[df_hi4['가구소득_년월'] != 9] df_hi6=df_hi5[df_hi5['가구소득_년월'] != 7]

data_pbhlth_code = pd.read_excel('C:/Users/Public/zrzr/walk_with_me-main/raw/지역사회건강조사 2019년 원시자료 이용지침서 등/지역사회건강조사 2019 원시자료 참고사항_보건소정보, 세대유형.xlsx',header=3) data_pbhlth_code = data_pbhlth_code[data_pbhlth_code['시도코드'] == 11][['보건소코드','보건소명']] data_pbhlth_code["보건소명"] = data_pbhlth_code["보건소명"].str.replace('보건소', '', regex=True) data_pbhlth_code.columns=['보건소코드','자치구'] list_region = list(data_pbhlth_code.to_dict()['자치구'].values()) + ['서울시'] list_region.reverse()

def transincome(df_income) : if df_income['가구소득_년월'] == 1: # 1은 년 return df_income['가구소득_년금액'] / df_income['가구원수'] elif df_income['가구소득_년월'] == 2: # 2는 월 return df_income['가구소득_월금액']*12 / df_income['가구원수'] else : return 0

df_income = df_hi6.copy() # 오류제거 df_income["소득 연봉 환산"] = df_income.apply(transincome, axis =1) df_income = df_income.drop(['가구소득_년월','가구소득_년금액','가구소득_월금액','가구원수'],axis=1)

list_df = [] for value in list_region: temp = df_income['자치구'] == value list_df.append(df_income[temp]) list_df[0] = df_income

list_age = ['19200','1944','4564','6574','75200'] list_sex = ['계','남','여'] idx_sex = [] idx_age = [] idx_region = [] value_hi = [] for i, value1 in enumerate(list_region): for j in list_age: for k in list_sex:
temp = list_df[i][list_df[i]['만나이']>=int(j.split('')[0])] temp1 = temp[temp['만나이'] <= int(j.split('')[1])] if k == '남': temp2 = temp1[temp1['성별'] == 1] elif k == '여': temp2 = temp1[temp1['성별'] == 2] else: temp2 = temp1 temp3 = temp2["소득 연봉 환산"].value_counts().to_dict() total_sum = 0 for m,n in temp3.items(): total_sum += m*n value_hi.append(round(total_sum/len(temp2['소득 연봉 환산']),1)) if j == '19200': idx_age.append('계') elif j == '75~200': idx_age.append('75 이상') else: idx_age.append(j) idx_sex.append(k) idx_region.append(value1)

df_final = pd.DataFrame({'1인당 연소득':value_hi, '지역':idx_region,'연령별':idx_age,'성별':idx_sex})

df_final = df_final.set_index(['지역','연령별','성별'])

df_final

df_final.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/지역사회건강조사 (1인당 연소득)_2019.csv", mode='w',encoding = 'utf-8-sig')

![](https://velog.velcdn.com/images/hate_all/post/4e780c20-3929-4972-9aba-e2c26fde1381/image.png)

## 전처리된 데이터 통합
- OS 모듈 사용
- 편한 시각화를 위해 통합된 테이블이 필요함.

1. 건강 관련 데이터 통합
```python
import pandas as pd
import os

path_dir = 'C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/'

file_list = os.listdir(path_dir)
data_list = []
for i in file_list:
    if i =='지역사회건강조사 1차 전처리_2019.csv':
        continue
    if i.split(' ')[0] == '지역사회건강조사':
        data_list.append(pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/%s' % i))

for i in data_list:
    i.set_index(['지역','연령별','성별'],inplace=True)

df_health = pd.concat(data_list, axis=1, join='inner')

df_health

df_health.to_csv("C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/통합 테이블(건강)_2019.csv", mode='w',encoding = 'utf-8-sig')

2. 전처리된 데이터 모두 통합

   import pandas as pd
   

data_park = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/통합 테이블(공원)_2019.csv') data_health = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/통합 테이블(건강)_2019.csv') data_finance = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/서울시 자치구 재정자립도_2019.csv') data_athletic = pd.read_csv('C:/Users/Public/zrzr/walk_with_me-main/전처리된 데이터/서울시 신고_등록 체육시설 통계_2019.csv') data_health.rename(columns={'지역':'자치구'},inplace = True) # 지역을 자치구로 변경하여 하나로 통일 data_health1 = data_health[(data_health['연령별'] == '계') & (data_health['성별'] == '계')] data_health1.set_index('자치구',inplace = True) data_park.set_index('자치구',inplace = True) data_finance.set_index('자치구',inplace = True) data_athletic.set_index('자치구',inplace = True) df = pd.concat([data_health1, data_finance, data_athletic,data_park],axis=1) df = df.drop(df.index[0]) # 서울시를 일단 없앤다 df = df.drop(['연령별','성별'],axis=1) # 멀티인덱스때 사용했던 column들 삭제

df.reset_index(inplace = True) df

![](https://velog.velcdn.com/images/hate_all/post/9363b042-b329-4516-bd35-cd331972ebb0/image.png)

## 시각화
- 다양한 변수들의 상관관계에 대하여 알아보기 위해 seaborn의 heatmap을 사용하였음
- 통합된 데이터에 공원과 관련된 변수가 너무 많아서 각 자치구별 인구 비율을 반영할 수 있는 1인당 생활권 도시림 면적을 사용하였음

```python
import numpy as np
import seaborn as sns
import matplotlib as mp
import matplotlib.pyplot as plt

df1 = df.drop(['공원율','1인당 공원 면적','총 도시림 면적','생활권 도시림 면적','1인당 총 도시림 면적',
               '1인당 생활권 도시림 면적(산림수목)','1인당 생활권 도시림 면적(공원녹지)'],axis=1)

corr=df1.corr()

# 그림 사이즈 지정
fig, ax = plt.subplots( figsize=(15,15) )


# 삼각형 마스크를 만든다(위 쪽 삼각형에 True, 아래 삼각형에 False)
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True

# 히트맵 생성
sns.heatmap(corr, 
            cmap = 'RdYlBu_r', 
            annot = True,   # 실제 값을 표시
            mask=mask,      # 표시하지 않을 마스크 부분을 지정
            linewidths=1,  # 실선 조절
            cbar_kws={"shrink": 1},# 컬러바 크기 조절
            vmin = -1,vmax = 1   # 컬러바 범위 조절
           )  
plt.show()               

-> 1인당 생활권 도시림 면적과 다른 변수들과의 상관관계를 비교하면 신체활동과 관련된 지표에서는 큰 상관관계를 발견하기 어려웠지만 주관적 건강수준이나 행복감 지수 등에서 유의미한 양의 상관관계를 발견할 수 있음 -> 1인당 생활권 도시림 면적과 가장 큰 상관관계를 갖는 변수는 재정자립도와 1인당 연소득임

• 행복감 지수와 1인당 생활권 도시림 면적 간의 관계를 막대그래프와 선 그래프로 나타냄

  import scipy.stats as stats
  import seaborn as sns
  

df2= df1[['행복감 지수','주관적 건강수준','우울감 경험률']]

plt.rcParams['figure.figsize'] = (20, 10) # 크기 지정 plt.rcParams['font.size'] = 10 # 폰트 크기 지정

subplots를 이용하여 figure 객체(전체 영역)와 axex 객체(들어갈 그래프들)을 가져온다

fig, ax = plt.subplots()

ax에 그리고 싶은 막대그래프에 대한 정보를 넣는다

ax.bar(df["자치구"], df["1인당 생활권 도시림 면적"], color='deeppink', label='1인당 생활권 도시림 면적', alpha=0.3, width=0.7)

y축에 대해서 라벨과 스케일을 조절

ax.set_ylabel('1인당 생활권 도시림 면적') ax.set_yscale('log') # 자치구별 차이가 커서 로그 스케일로 보여주는 차이를 줄여주었다

plt.legend(loc=2, fontsize=13) # loc=2 는 upper left다

twinx()를 이용하여 y축을 하나 더 추가하자

ax1 = ax.twinx()

plot을 이용하여 선 그래프를 그려주자

ax1.plot(df["자치구"], df["행복감 지수"], '-s', color='purple', linewidth=2, alpha=0.5, label='행복감 지수') ax1.set_xlabel('자치구')

ax1.set_ylabel('행복감 지수') ax1.tick_params(axis='both', direction='in') plt.legend(loc=1, fontsize=13) # loc=1 는 upper right plt.ylim([6,8]) # 행복감 지수의 값이 6에서 8사이에 형성되어서 6과 8사이 오도록 설정

plt.show()

![](https://velog.velcdn.com/images/hate_all/post/c636783f-a85a-4bf2-9896-7d135f2e92df/image.png)

-> 행복감 지수와 주관적 건강수준이 1인당 생활권 도시림 면적과 유의미한 양의 상관관계가 있어 보이지만, 위에서도 확인했듯이 그 자치구의 재정자립도나 1인당 연소득이 더 높은 상관관계를 가지고 있음

- 위의 결과에 대한 내용인 (행복감 지수, 주관적 건강수준)과 (1인당 생활권 도시림 면적, 재정자립도, 1인당 연소득) 간의 관계를 막대그래프로 나타냄
```python
A =corr[['1인당 생활권 도시림 면적','1인당 연소득','재정자립도']]
B= A.T.reset_index()


plt.rcParams['figure.figsize'] = (10, 8)
plt.rcParams['font.size'] = 10


index = np.arange(3)/2
label=['1인당 생활권 도시림 면적','1인당 연소득','재정자립도']

ax = plt.subplot()
p1 =ax.barh(index-0.1,B["행복감 지수"],height=0.2,color='deeppink', label='행복감 지수', alpha=0.3)
p2 =ax.barh(index+0.1,B["주관적 건강수준"], height=0.2,  color='pink', label='주관적 건강수준', alpha=0.3)

plt.xlabel('상관 계수', fontsize=18)


plt.legend((p1[0], p2[0]), ('행복감 지수', '주관적 건강수준'),loc='upper center', ncol=1, bbox_to_anchor=(0.83, 0.8), fontsize=15)


plt.yticks(index, label,fontsize=12)

plt.show()

3. 결론

데이터 전처리 과정 중 데이터 수집, 데이터 정제, 가공의 과정을 직접 수행하였다. 특히, 결측치를 제거와 단순 대체법을 수행하였다. 수집한 모든 데이터들을 전처리한 후, 통합하여 분석 목적인 공원과 건강, 소득 간의 상관관계를 알아보고자 시각화를 수행하였다. 시각화 결과 신체적 건강(걷기, 중등도, 격렬)과 공원(도시림 면적) 간에는 큰 상관관계가 나타나지 않았고, 신체적 건강과 소득(재정자립도, 연소득) 역시 큰 상관관계가 나타나지 않았다. 반면에 심리적 건강(행복감지수, 주관적 건강수준 등)은 공원과 유의미한 상관관계가 나타났고, 소득과도 유의미한 상관관계가 나타났다.

이번 프로젝트를 진행하면서 데이터 전처리는 아직도 매우 어렵고, 복잡한 과정이지만 이 과정이 데이터 분석에 있어서 얼마나 중요한지 다시금 깨닫게 되었다. 그리고 스스로한테도 앞으로의 전공과 진로에 대하여 많은 도움을 받게 되었다. 데이터 전처리 과정이 단순하게 값과 데이터를 조작하는 것이 아닌 논리적이고 통계적인 지식을 갖고 수행해야 함을 또 느꼈다. 더 많은 데이터를 접해보고 기초적인 지식을 쌓아야 할 필요성을 느끼게 되었다. 아직 데이터를 변환하는 것이 약한 것 같아서 그 부분에 있어서 이번 프로젝트와 같은 추가적인 예제 학습과 분석을 방학동안 수행해야 겠다고 생각했다.

4. 참고 문헌

인용, 출처, 참고 모두 포함

1) https://chs.kdca.go.kr/chs/index.do 2) https://blog.naver.com/udo_peanut/222527849666 3) https://github.com/jj150618/walk_with_me/tree/main 4) https://data.seoul.go.kr/

1.1 인코딩이란

• 인코딩은 컴퓨터가 처리하기 용이하도록 기존의 데이터를 변경하거나 데이터양을 줄이기 위하여 코드화하고 압축하는 것을 의미한다.

• 실제 데이터셋에는 수치형 변수와 범주형 변수가 많이 혼재하고 있기 때문에 인코딩을 하게 된다.

• 인코딩된 코드를 원래의 데이터로 변환하는 것은 디코딩이라고 한다.

1.2 인코딩의 장단점

• 장점
  • 적은 정보 기록 -> 적은 메모리 사용
  • 코드화로 원데이터의 의미 알 수 없음 -> 보안에 유리
  • 빠른 시간에 데이터 입력이 가능
  • 코드의 규격화 -> 데이터 검증 유리
  • 데이터의 규격화 -> 비교 용이
• 단점
  • 데이터의 정확도 손실 발생 가능
  • 가치 판단에 대한 코드화 시 의미와 정확도 감소
  • 사용자가 변환된 코드를 알고 있어야 사용 가능
  • 코드의 수가 제한될 수 있음
  • 코드가 정확히 기록된 것인지 오류의 검증이 어려움

1.3 대표적인 인코딩

• 레이블 인코딩 : 범주형 데이터는 일반적으로 텍스트로 되어 있으므로 이를 숫자(일반적으로 양의 정수)로 변환

• 이진화, 이산화 : 분류 문제에서는 종속변수가 범주형이어야 하므로 수치형 데이터는 범주형으로 변환

• 원핫인코딩, 더미변수화 : 회귀 모형이나 신경망에서는 독립변수는 수치형 변수이어야 하므로 범주형 변수를 수치형으로 변환

• 정수인코딩 : 텍스트 데이터는 자연어 처리를 위해 토큰화 과정을 거쳐야 함

2. 인코딩 방법

2.1 데이터 생성

import pandas as pd
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

weight, height -> 연속 수치형 sex, blood_type, health -> 범주형

2.2 범주형 데이터 → 이산 수치형 데이터

2.2.1 OrdinalEncoder

기본

from sklearn.preprocessing import OrdinalEncoder

df_oe = df.copy()
oe = OrdinalEncoder()
oe.fit(df)

print(f'{oe.categories_=}')

df_oe = pd.DataFrame(oe.transform(df), columns=df.columns)
df_oe

df_oe = df.copy()
oe = OrdinalEncoder()
oe.fit(df[['sex', 'blood_type']])

print(f'{oe.categories_=}')

df_oe.iloc[:,2:4] = oe.transform(df[['sex', 'blood_type']])
df_oe

oe.inverse_transform(df_oe.iloc[:,2:4]) 

학습

• Ordinal Encoder(1:1 변환)

  • 범주형 데이터를 정수로 인코딩하는 방법
  • 여러 독립 변수(열)에 사용 가능
  • 상태공간의 값을 컬럼으로 늘어놓는 것이 아니라 그 자체 변수에서 unique한 값을 숫자로 구분
  • 2차원 데이터에 적합
  • 순서를 유지할 필요가 있는 서열이 존재하는 데이터 처리에 적합

• 첫번째 코드 실행

  • 데이터를 복사(df_oe) 후, oe에 Ordinal Encoder 객체 생성
  • fit 함수로 oe를 학습
  • 수치형 데이터인 weight와 height도 범주형으로 인식되어 변경됨

• 두번째 코드 실행

  • 데이터 복사(df_oe) 후, oe에 Ordinal Encoder 객체 생성
  • fit 함수로 oe를 학습('sex'와 'blood_type' 특정)
  • 'sex'와 'blood_type'만 인코딩된 결과 도출

• 세번째 코드 실행

  • 인코딩된 'sex'와 'blood_type'을 디코딩

2.2.2 LabelEncoder

기본

from sklearn.preprocessing import LabelEncoder

df_le = df.copy()
health_le = LabelEncoder().fit(df.health)
df_le['health'] = health_le.transform(df.health)
df_le

df_le = df.copy()
df_le['health'] = LabelEncoder().fit_transform(df.health)
df_le

학습

• Label Encoder(1:1 변환)

  • 범주형 데이터를 정수로 인코딩
  • 하나의 종속변수(열)에만 사용 가능
  • ordinal encoder와 유사하게 label을 붙임
  • label은 array형태
  • 단순 매칭이라 볼 수 있음

• 첫번째 코드 실행

  • 데이터 복사(df_le) 후, Label Encoder 객체 생성 및 fit 함수 적용
  • 하나의 변수(health)에 대해서 변환(알파벳 순서)

• 두번째 코드 실행

- 데이터 복사(df_le) 후, Label Encoder 객체 생성 및 fit 함수 적용
- fit_transform을 통해 한번에 인코딩 수행(health 변수)

2.2.3 TargetEncoder

기본

from sklearn.preprocessing import TargetEncoder

df_te = df.copy()

te = TargetEncoder(smooth=0, target_type='continuous')

te.fit(df['blood_type'].values.reshape(-1, 1), df.weight)

print(f'{te.categories_=}')

df_te['blood_type_target'] = te.transform(df['blood_type'].values.reshape(-1, 1))
df_te

학습

• TargetEncoder(1:1 변환)

  • 범주형 데이터를 특정한 컬럼(타겟)의 값의 크기와 비례한 숫자로 인코딩, 주로 평균값
  • 인코딩 값이 ordinal처럼 숫자이지만 타겟값과 관련된 순서
  • low cardinality
  • target값을 사용하기 때문에 가능성 유 => CV를 통해 조절 가능
  • train set의 target 평균과 test set의 target 평균이 매우 다를 경우의 과적합 => smoothing 파라미터로 조절

• 코드 실행

  • 데이터 복사 후, TargetEncoder 객체 생성
  • smooth로 정밀도를 조정, target_type으로 인코딩 타입 지정
  • fit -> 데이터 학습
  • 타겟(weight) & blood_type 인코딩 -> blood_type_target 생성
  • reshape -> 인코딩 되는 값 2차원 변환 필요

2.3 범주형 데이터 → 이진 데이터

2.3.1 One-Hot-Encoding

기본

from sklearn.preprocessing import OneHotEncoder

df_ohe = df.copy()

ohe = OneHotEncoder().fit(df_ohe[['blood_type']])

print(f'{ohe.categories_=}')

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

학습

• One-Hot-Encoding(1:M 변환)

  • 하나의 컬럼에 있는 범주형 데이터를 여러개의 이진수 컬럼(수치형 데이터)로 인코딩
  • one-of-K 인코딩이라고도 함
  • matrix형태나 array형태로도 반환 가능
  • 특정 카테고리에 해당(1), 나머지(0)으로 매핑, 카테고리 종류의 개수만큼 추가적인 column들을 만들어 냄 -> 범주형 변수 값들의 종류가 많아진다면, 모델링의 학습속도가 매우 느려짐.
  • 분류 -> n개 카테고리, 회귀 -> n-1개 카테고리(자유도 반영)

• 코드 실행

  • 데이터 복사 후, OneHotEncoder 객체 생성 및 fit 적용
  • sparse matrix(희소 행렬; 0 원소 많음)로 결과 반환 -> toarray를 사용(조밀 행렬 변환) -> ndarray로 변환
  • 새로운 컬럼 삽입

2.3.2 Dummy encoding

기본

pd.get_dummies(df, columns=['sex', 'blood_type'], drop_first=False)

학습

• Dummy encoding(1:M 변환)

  • One-hot encoding과 동일한 기능
  • 회귀분석에서 범주형 변수를 고려할 때 사용
  • Pandas에서 제공
  • 여러 컬럼을 한 번에 변환 가능
  • 컬럼의 수가 상태공간 크기만큼 많아질 수 있음
  • train 데이터의 상태공간 크기와 test 데이터의 상태공간 크기가 다르면 predict할때 오류 발생

• 코드 실행

  • pd.get_dummies() 사용
  • 컬럼 지정(sex, blood_type)

2.4 연속 수치형 데이터 → 이진 데이터

2.4.1 Binarizer

기본

from sklearn.preprocessing import Binarizer

df_bin = df.copy()

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

학습

• Binarizer(1:1 변환)

  • 연속 수치형 데이터를 기준값을 기준으로 이진수로 인코딩
  • 수치형 변수에 대해서만 변환 가능
  • threshold 파라미터 -> 기준값을 나타냄

• 코드 실행

  • 데이터 복사 후, Binarizer 객체 생성 및 fit_transform 적용
  • weight_bin 생성, 기준값 50 -> 크면 1 작거나 같으면 0
  • height_bin 생성, 기준값 170 -> 크면 1 작거나 같으면 0

2.4.2 LabelBinarizer

기본

from sklearn.preprocessing import LabelBinarizer

df_lb = df.copy()

lb = LabelBinarizer().fit(df.health)

print(f'{lb.classes_ = }')

health_lb = lb.transform(df.health)
print('health_lb = \n', health_lb)

df_lb[lb.classes_] = health_lb
df_lb

학습

• LabelBinarizer(1:M 변환)

  • 연속형 데이터를 이진수 컬럼으로 인코딩
  • 하나의 컬럼(종속변수, 타겟)에만 사용 가능
  • One-Hot-Encoding 형식의 target 얻을 수 있음

• 코드 실행

  • 데이터 복사 후, LabelBinarizer 객체 생성 및 fit 적용
  • lb.classes_ -> 인코딩한 클래스 확인
  • lb.transform() -> 인코딩 변환

2.4.3 MultiLabelBinarizer

기본

from sklearn.preprocessing import MultiLabelBinarizer

df_mlb = df.copy()

df_mlb['test'] = [['math', 'english'], ['math', 'science'], ['science'], ['math', 'english'], ['science']]
df_mlb

mlb = MultiLabelBinarizer().fit(df_mlb.test)

print(f'{mlb.classes_ = }')

df_mlb[mlb.classes_] = mlb.transform(df_mlb.test)
df_mlb

학습

• MultiLabelBinarizer(1:M 변환)

  • multi-class(여러 개의 범주가 있는) 데이터를 이진수 컬럼으로 인코딩
  • 하나의 컬럼(종속변수, 타겟)에만 사용 가능
  • 한 데이터 셋에 대해 여러 레이블을 할당할 수 있음

• 첫번째 코드 실행

  • 데이터 복사 후, test 컬럼 추가
  • 해당 컬럼에는 여러 개의 범주를 적용

• 두번째 코드 실행

  • MultiLabelBinarizer 객체 생성 및 fit 적용
  • classes_로 인코딩된 클래스 확인

3. 범주화

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

3.1 K-bins discretization

기본

from sklearn.preprocessing import KBinsDiscretizer

df_kbd = df.copy()

kbd = KBinsDiscretizer(n_bins=3, encode='ordinal').fit(df[['weight', 'height']])

df_kbd[['weight_bin', 'height_bin']] = kbd.transform(df[['weight', 'height']])
df_kbd

학습

• 코드 실행

  • 데이터 복사 후 , KBinsDiscretizer 객체 생성 및 fit 적용
  • bin(3), 동일 빈도, kbd.transform() : 인코딩 변환

4. 피쳐 엔지니어링

4.1 피쳐

• 데이터 모델(특히, 인공지능)에서 예측을 수행하는 데 사용되는 입력변수를 의미
• 통계학에서는 독립 변수라고 함

4.2 피쳐의 유형

• 속성에 따라

  • 범주형(categorical): 범주나 순위가 있는 변수
  • 수치형(numerical): 수치로 표현되는 변수

• 인과관계에 따라

  • 독립변수(independent variable): 다른 변수에 영향을 받지 않고 종속변수에 영향을 주는 변수
  • 종속변수(dependent variable): 독립 변수로부터 영향을 받는 변수

• 머신 러닝에서

  • 입력(input): 변수(Feature), 속성(Attribute), 예측변수(Predictor), 차원(Dimension), 관측치(Observation), 독립변수(Independent Variable)
  • 출력(output): 라벨(Label), 클래스(Class), 목푯값(Target), 반응(Response), 종속변수(Dependent Variable)

4.3 피쳐 엔지니어링

• 머신러닝 알고리즘의 성능을 향상시키기 위하여 데이터에 대한 도메인 지식을 활용하여 변수를 조합하거나 새로운 변수를 만드는 과정
• 머신러닝 성능 향상 -> 피쳐 엔지니어링 + 하이퍼 파라미터 최적화

4.4 피쳐 추출

• 변수들 사이에 내재한 특성이나 관계를 분석하여 이들을 잘 표현할 수 있는 새로운 선형 혹은 비선형 결합 변수를 만들어 데이터를 줄이는 방법
• 고차원의 원본 피쳐 공간을 저차원의 새로운 피쳐 공간으로 투영

4.4.1 주성분 분석

• 가장 널리 사용되는 차원(변수) 축소 기법 중 하나
• 원 데이터의 분산(variance)을 최대한 보존하면서 서로 직교하는 새 기저(축)를 찾아, 고차원 공간의 표본들을 선형 연관성이 없는 저차원 공간으로 변환하는 기법
• PCA는 기존의 변수를 조합하여 서로 연관성이 없는 새로운 변수, 즉 주성분(principal component, PC)들을 만들어 냄
• 주성분의 개수를 증가시킴에 따라 원 데이터의 분산의 보존수준이 높아짐
• 변수들의 공분산 행렬이나 상관행렬을 이용
• 행의 수와 열의 수가 같은 정방행렬에서만 사용
• PCA는 Target값을 사용하지 않으므로 비지도 학습

4.4.1.1 주성분 분석 절차

1. 학습 데이터셋에서 분산이 최대인 축(axis)을 찾음
2. 첫번째 축과 직교(orthogonal)하면서 분산이 최대인 두 번째 축을 찾음
3. 첫 번째 축과 두 번째 축에 직교하고 분산을 최대한 보존하는 세 번째 축을 찾음
4. 1~3과 같은 방법으로 데이터셋의 차원(특성 수)만큼의 축을 찾음

4.4.2 선형판별분석

• 입력 데이터 세트를 저차원 공간으로 투영(projection)해 차원을 축소하는 기법
• 데이터의 Target값 클래스끼리 최대한 분리할 수 있는 축을 찾음 → 지도 학습
• 특정 공간상에서 클래스 분리를 최대화하는 축을 찾기 위해 클래스 간 분산(between-class scatter)과 클래스 내부 분산(within-class scatter)의 비율을 최대화하는 방식으로 차원을 축소
• SVM 같은 다른 분류 알고리즘을 적용하기 전에 차원을 축소시키는 데 사용

4.4.3 PCA와 LDA 수행하기

4.4.3.1 데이터셋 로드

from sklearn import datasets
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

iris = datasets.load_iris()

X = iris.data
y = iris.target
target_names = list(iris.target_names)

print(f'{X.shape = }, {y.shape = }')
print(f'{target_names = }')

x -> 피쳐 y -> 타겟 target_names -> 타겟 이름 ['setosa', 'versicolor', 'virginica']

4.4.3.2 PCA

기본

pca = PCA(n_components=2)

pca_fitted = pca.fit(X)

print(f'{pca_fitted.components_ = }')
print(f'{pca_fitted.explained_variance_ratio_ = }')

X_pca = pca_fitted.transform(X)
print(f'{X_pca.shape = }') 

학습

• PCA

  • 차원을 줄이기 위해 축을 최전 -> 새로운 축 찾아내는 방법
  • 몇 개의 점은 서로 겹치게 되는 문제점 발생 -> 정보 유실 발생 -> 분산이 가장 넓은 지역 찾기
  • 비지도 학습 -> 정답 없음, 분석가가 주성분 개수 지정
  • 주성분 개수 적음 -> 차원축소 많이 됨, 정보손실 발생
  • 주성분 개수 많음 -> 정보손실 적음, 차원축소 의미 퇴색
  • 적절한 주성분 개수 선택 중요
  • 고유값-주성분 분산 변화 확인 -> 분산 비율이 완만하게 감소되는 차원 버림
  • 데이터의 클래스 차이가 평균보다 분산의 차이에 있을 때 뛰어난 성능

• 코드 실행(코드 학습)

  • PCA 객체 생성 및 차원 설정
  • 현재 피쳐(x) 4개 -> n_components=2 2차원 설정
  • PCA는 비지도 학습이므로 y값을 넣지 않음
  • 주성분 벡터(pca_fitted.components_)와 분산 비율(pca_fitted.explained_variance_ratio_)

4.4.3.3 LDA

기본

lda = LinearDiscriminantAnalysis(n_components=2)

lda_fitted = lda.fit(X, y)

print(f'{lda_fitted.coef_=}')
print(f'{lda_fitted.explained_variance_ratio_=}')

X_lda = lda_fitted.transform(X)
print(f'{X_lda.shape = }')

학습

• LDA

  • 두 범주를 잘 구분하는 직선 -> 사영 후 두 범주 중심(평균)이 서로 멀고 그 분산이 작아야 함
  • 범주 간 분산이 최대 -> 각 범주간 중심(평균)이 서로 멀어지게 분류
  • 범주 내부 분산이 작아짐 -> 하나의 범주끼리는 조밀하게 뭉쳐있음
  • 데이터의 클래스 차이가 분산보다 평균의 차이가 있을 때 성능이 뛰어남
  • 3D plot으로 표현할 때 뛰어난 성능

• 코드 실행

  • LDA 객체 생성 및 차원 설정
  • 현재 피쳐(x) 4개 -> n_components=2 2차원 설정
  • LDA는 지도학습이므로 타겟값(y)이 필요
  • LDA의 계수(lda_fitted.coef_)와 LDA의 분산에 대한 설명력(lda_fitted.explained_variance_ratio_)

4.4.3.4 시각화

기본

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

df_pca = pd.DataFrame(X_pca, columns=['PC1', 'PC2'])
df_lda = pd.DataFrame(X_lda, columns=['LD1', 'LD2'])
y = pd.Series(y).replace({0:'setosa', 1:'versicolor', 2:'virginica'})

fig, ax = plt.subplots(1, 2, figsize=(10, 4))

sns.scatterplot(df_pca, x='PC1', y='PC2', hue=y, style=y, ax=ax[0], palette='Set1')
ax[0].set_title('PCA of IRIS dataset')

sns.scatterplot(df_lda, x='LD1', y='LD2', hue=y, style=y, ax=ax[1], palette='Set1')
ax[1].set_title('LDA of IRIS dataset')

plt.show()

학습

• 코드 실행

  • Seaborn을 이용하기 위해 데이터프레임으로 변환
  • subplot으로 시각화

4.4.4 특이값 분해

• M X N 차원의 행렬데이터에서 특이값을 추출하고 이를 통해 주어진 데이터 세트를 효과적으로 축약할 수 있는 기법

4.4.5 요인분석

• 데이터 안에 관찰할 수 있는 잠재적인 변수(Latent Variable)가 존재한다고 가정
• 모형을 세운 뒤 관찰 가능한 데이터를 이용하여 해당 잠재 요인을 도출하고 데이터 안의 구조를 해석하는 기법
• 주로 사회과학이나 설문 조사 등에서 많이 활용

4.4.6 독립성분분석

• 주성분 분석과는 달리 다변량의 신호를 통계적으로 독립적인 하부성분으로 분리하여 차원을 축소하는 기법
• 독립 성분의 분포는 비정규 분포를 따르게 되는 차원축소 기법

4.4.7 다차원 척도법

• 개체들 사이의 유사성, 비유사성을 측정하여 2차원 또는 3차원 공간상에 점으로 표현하여 개체들 사이의 집단화를 시각적으로 표현하는 분석 방법

4.5 피쳐 선택

• 피쳐 중 타겟에 가장 관련성이 높은 피쳐만을 선정하여 피쳐의 수를 줄이는 방법
• 관련없거나 중복되는 피쳐들을 필터링하고 간결한 subset을 생성
• 모델 단순화, 훈련 시간 축소, 차원의 저주 방지, 과적합(Over-fitting)을 줄여 일반화해주는 장점이 있음

4.6 피쳐 선택 기법

• 종속변수 활용여부에 따라 : Supervised(종속변수를 활용하여 선택), Unsupervised(독립변수들 만으로 선택)
• 선택 메커니즘에 따라 : Filter, Wrapper, Embedded, Hybrid(Filter + Wrapper)

4.6.1 필터 기법

• 데이터의 통계적 측정 방법을 사용하여 변수들의 상관관계를 알아냄
• 계산속도가 빠르고 변수 간 상관관계를 알아내는 데 적합하여 래퍼 기법(Wrapper Method)을 사용하기 전에 전처리하는 데 사용
• 특정 모델링 기법에 의존하지 않고 데이터의 통계적 특성부터 변수를 택하는 기법
• 모든 피쳐 배정 -> 최적의 subset 선택 -> 학습 알고리즘 -> 성능 평가

4.6.1.1 분산 기반 선택

기본

from sklearn import datasets
from sklearn.feature_selection import VarianceThreshold

iris = datasets.load_iris()

X = iris.data 
y = iris.target 
X_names = iris.feature_names 
y_names = iris.target_names 

sel = VarianceThreshold(threshold=0.2).fit(X)
print(f'{sel.variances_ = }')

X_selected = sel.transform(X)
X_selected_names = [X_names[i] for i in sel.get_support(indices=True)]

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

학습

• 분산 기반 선택 : 분산이 낮은 변수를 제거하는 방법

• 코드 실행

  • iris 데이터셋 로드, iris 데이터셋의 피쳐들(x), iris 데이터셋의 타겟(y)
  • 분산이 0.2 이상인 피쳐들만 선택하도록 학습(기준값=0.2)
  • 각 피쳐의 분산 확인(sel.variances_)
  • 분산이 0.2 이상인 피쳐들만 선택 적용
  • 선택된 피쳐들의 이름(X_selected_names)

4.6.1.2 정보 소득

• 가장 정보 소득이 높은 속성을 선택하여 데이터를 더 잘 구분하게 되는 것

4.6.1.3 카이제곱 검정

• 카이제곱 분포에 기초한 통계적 방법으로 관찰된 빈도가 기대되는 빈도와 의미있게 다른지 여부를 검증하기 위해 사용되는 검증 방법
• 범주형 데이터에서 두 요인간 독립성 검정에서 사용
• χ2-value가 크면 두 요인간 독립이 아니라는 의미(즉, 상관관계가 있음)

4.6.1.4 피셔 스코어

• 최대 가능성 방정식을 풀기 위해 통계에 사용되는 뉴턴(Newton)의 방법

4.6.1.5 상관계수

• 두 변수 사이의 통계적 관계를 표현하기 위해 특정한 상관관계의 정도를 수치적으로 나타낸 계수

4.6.1.6 Scikit-Learn 제공 피쳐 선택 메서드

• SelectKBest(): 고정된 k개의 피쳐 선택기
• SelectPercentile(): 분위수 기반 선택기
• SelectFpr(): False positive rate 기반 선택기
• SelectFdr(): 추정된 False discovery rate 기반 선택기
• SelectFwe(): familiy-wise error rate 기반 선택기
• GenericUnivariateSelect(): 단변량 피쳐 선택기

4.6.1.7 Scikit-Learn 제공 피쳐 선택 기준

• f_classif: ANOVA F-value 분류
• mutual_info_classif: 상호정보량(mutual information) 분류
• chi2: 카이제곱 분류
• f_regression: F-value 회귀
• mutual_info_regression: 상호정보량(mutual information) 회귀

4.6.1.8 F-value

• 두 모집단(확률변수)의 분산의 비율을 나타내는 값
• ANOVA, Regression에서는 모형이 설명하는 분산/잔자의 분산
• F-value가 크면 모형이 잘 설명하고 있다는 의미

4.6.1.9 상호정보량

• 하나의 확률변수가 다른 하나의 확률변수에 대해 제공하는 정보의 양
• 두 확률변수가 공유하는 엔트로피
• 두 확률변수가 독립이라면, 상호정보량은 0
• 두 확률변수의 상관관계가 강할수록 상호정보량이 커짐

4.6.1.10 기타 코드

기본

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif, f_regression, chi2

sel_fc = SelectKBest(f_classif, k=2).fit(X, y)
print('f_classif: ')
print(f'{sel_fc.scores_ = }')
print(f'{sel_fc.pvalues_ = }')
print(f'{sel_fc.get_support() = }')
print('Selected features: ', [X_names[i] for i in sel_fc.get_support(indices=True)])

sel_fr = SelectKBest(f_regression, k=2).fit(X, y)
print('\nf_regression: ')
print(f'{sel_fr.scores_ = }')
print(f'{sel_fr.pvalues_ = }')
print(f'{sel_fr.get_support() = }')
print('Selected features: ', [X_names[i] for i in sel_fr.get_support(indices=True)])

sel_chi2 = SelectKBest(chi2, k=2).fit(X, y)
print('\nchi2: ')
print(f'{sel_chi2.scores_ = }')
print(f'{sel_chi2.pvalues_ = }')
print(f'{sel_chi2.get_support() = }')
print('Selected features: ', [X_names[i] for i in sel_chi2.get_support(indices=True)])

학습

• SelectKBest : k개의 베스트 피쳐를 선택
• f분류/f회귀/카이제곱분류

4.6.2 래퍼 기법

• 예측 정확도 측면에서 가장 좋은 성능을 보이는 하위 집합을 선택하는 기법
• 검색 가능한 방법으로 하위 집합을 반복해서 선택하여 테스트하는 것이므로 탐욕 알고리즘(Greedy Algorithm)에 속함
• 반복하여 선택하는 방법으로 시간이 오래 걸리고 부분집합의 수가 기하급수적으로 늘어 과적합의 위험이 발생할 수 있음
• 일반적으로 래퍼 방법은 필터 방법보다 예측 정확도가 높음

4.6.2.1 변수 선택을 위한 알고리즘

• 전진 선택법(Forward Selection) : 모형을 가장 많이 향상시키는 변수를 하나씩 점진적으로 추가하는 방법
• 후진 제거법(Backward Elimination) : 모두 포함된 상태에서 시작하여 가장 적은 영향을 주는 변수부터 하나씩 제거
• 단계적 방법(Stepwise Method) : 전진선택과 후향제거의 결합, 각 단계에서 최상의 속성을 선택하고 나머지 속성 중 최악의 속성을 제거하는 과정을 실행
• 의사결정트리

4.6.2.2 래퍼기법의 종류

• RFE(Recursive Feature Elimination) : SVM(Support Vector Machine)을 사용하여 재귀적으로 제거하는 방법. 전진 선택, 후진 제거, 단계적 방법 사용
• SFS(Sequential Feature Selection) : 그리디 알고리즘(Greedy Algorithm)으로 빈 부분 집합에서 특성 변수를 하나씩 추가하는 방법. 전진 선택, 후진 제거 사용

4.6.2.3 코드 실행

기본

from sklearn.datasets import load_iris
from sklearn.feature_selection import RFE, RFECV, SelectFromModel, SequentialFeatureSelector
from sklearn.svm import SVC, SVR

X, y = load_iris(return_X_y=True)

svc = SVR(kernel="linear", C=3)

rfe = RFE(estimator=svc, n_features_to_select=2, step=1)
rfe_cv = RFECV(estimator=svc, step=1, cv=5) 

rfe.fit(X, y)
print('RFE Rank: ', rfe.ranking_)

X_selected = rfe.transform(X) 
X_selected_names = [X_names[i] for i in rfe.get_support(indices=True)]

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

rfe_cv.fit(X, y)
print('RFECV Rank: ', rfe_cv.ranking_)

X_selected = rfe_cv.transform(X) 
X_selected_names = [X_names[i] for i in rfe_cv.get_support(indices=True)]

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

학습

• 코드 학습

  • 분류기 SVC 객체 생성, 선형분류, 3개의 클래스
  • RFE 객체 생성, 2개의 피쳐 선택, 1개씩 제거
  • RFE+CV(Cross Validation), 5개의 폴드, 1개씩 제거
  • rank가 1인 피쳐들만 선택
  • 데이터셋에 RFECV 적용

from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
knn = KNeighborsClassifier(n_neighbors=3)
sfs = SequentialFeatureSelector(knn, n_features_to_select=2, direction='backward')

sfs.fit(X, y)
print('SFS selected: ', sfs.get_support())

X_selected = sfs.transform(X) 
X_selected_names = [X_names[i] for i in sfs.get_support(indices=True)]

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

학습

• SFS(Sequential Feature Selector) : 순차적으로 특성을 선택하는 방법
• 데이터를 로드하고, 분류기를 초기화한 후 SFS를 적용
• SFS를 학습하고, 선택된 특성을 출력

4.6.3 임베디드 기법

• 임베디드 기법은 모델의 정확도에 기여하는 변수를 학습함

4.6.3.1 SelectFromModel

기본

from sklearn.feature_selection import SelectFromModel
from sklearn import tree
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
clf = tree.DecisionTreeClassifier()
sfm = SelectFromModel(estimator=clf)

sfm.set_output(transform='pandas')

sfm.fit(X, y)
print('SFM threshold: ', sfm.threshold_)

X_selected = sfm.transform(X) 
X_selected.columns = [X_names[i] for i in sfm.get_support(indices=True)]

X_selected.head()

학습

• SelectFromModel : 의사결정나무 기반 알고리즘에서 변수를 선택하는 기법

• 코드 학습

  • 데이터를 로드하고, 분류기를 초기화한 후 SFS를 적용
  • 모형 구조 확인 및 출력을 pandas로 설정
  • 모형 학습 및 선택된 피쳐들만 선택

5. 파이프라인

• 여러 개의 데이터의 처리(preprocessor, classifier, regressor, estimator 등)를 하나의 처리과정(pipeline, sequence)으로 만들어 데이터를 일괄처리해 주는 기능
• 파이프라인을 사용하면 데이터 전처리나 모델 구축 과정 등을 더 짧은 코드로, 더 가시성 있게, 더 효율적으로 처리할 수 있음
• 다양한 패키지에서 파이프라인을 지원하고 있음

5.1 SciKit-Learn의 파이프라인

• SciKit-Learn에서는 Pipeline 클래스를 통해 파이프라인을 구현할 수 있음
• Pipeline 클래스는 여러 개의 추정기(estimator)를 하나의 추정기처럼 사용할 수 있도록 해 줌
• 파이프라인 사용 목적
• 편의성과 캡슐화 : 전체 데이터 처리 시퀀스에서 fit과 predict를 한 번만 적용하면 됨
• 통합된 하이퍼 파라미터 최적화 : grid search를 이용하여 한 번에 하이퍼 파라미터 최적화 가능
• 안전성 강화 : 교차검증(cross-validation)시 랜덤성에 의한 데이터의 통계적 특성이 변경되는 것을 방지하여 일관성을 유지할 수 있음

5.2 파이프라인을 이용하여 연결형 추정기 만들기

5.2.1 파이프라인을 사용하지 않은 경우

from sklearn.feature_selection import SelectKBest, f_classif # 피처선택 메서드
from sklearn.preprocessing import StandardScaler # 데이터 표준화
from sklearn.tree import DecisionTreeClassifier # 의사결정나무 분류기
from sklearn.datasets import load_iris # iris 데이터세트

# iris 데이터세트 로드
X, y = load_iris(return_X_y=True)

## 피쳐 선택
feat_sel = SelectKBest(f_classif, k=2)
X_selected = feat_sel.fit_transform(X, y)
print('Selected features:', feat_sel.get_feature_names_out())

## 표준화
scaler = StandardScaler()
scaler.fit(X_selected)
X_transformed = scaler.transform(X_selected)
print('Standard Scaled: \n', X_transformed[:5, :])

## 모델 학습
clf = DecisionTreeClassifier(max_depth=3)
clf.fit(X_transformed, y)
print('Estimate : ', clf.predict(X_transformed)[:3])
print('Accuracy : ', clf.score(X_transformed, y))

5.2.2 파이프라인을 사용한 경우

기본

from sklearn.pipeline import Pipeline # 파이프라인 구성을 위한 함수
from sklearn.feature_selection import SelectKBest, f_classif # 피처선택 메서드
from sklearn.preprocessing import StandardScaler # 데이터 표준화
from sklearn.tree import DecisionTreeClassifier # 의사결정나무 분류기
from sklearn.datasets import load_iris # iris 데이터세트

# iris 데이터세트 로드
X, y = load_iris(return_X_y=True)

## pipeline 구축
pipeline = Pipeline([
    ('Feature_Selection', SelectKBest(f_classif, k=2)), ## 피쳐 선택
    ('Standardization', StandardScaler()),  ## 표준화
    ('Decision_Tree', DecisionTreeClassifier(max_depth=3)) ## 학습 모델
])
display(pipeline) # 파이프라인 그래프로 구성 확인

pipeline.fit(X, y) ## 모형 학습
print('Estimate : ', pipeline.predict(X)[:3]) ## 예측
print('Accuracy : ', pipeline.score(X, y)) ## 성능 평가

from sklearn.pipeline import make_pipeline # 파이프라인 구성을 위한 함수

pipeline_auto = make_pipeline(SelectKBest(f_classif, k=2), 
              StandardScaler(), 
              DecisionTreeClassifier(max_depth=3))
display(pipeline_auto) # 파이프라인 그래프로 구성 확인

# pipiline의 Feature_Selection step의 결과 확인
# pipeline.named_steps['Feature_Selection'] == pipeline[0]
# pipeline.named_steps['Standardization'] == pipeline[1]
# pipeline.named_steps['Decision_Tree'] == pipeline[2]
print('Selected features:', pipeline.named_steps['Feature_Selection'].get_feature_names_out())
X_transformed = pipeline[1].transform(X_selected)
print('Standard Scaled: \n', X_transformed[:5, :])

학습

• 파이프라인은 (key, value)의 리스트를 구성하여 만듦
• 파이프라인을 사용하면, 변환된 데이터를 별도로 저장하지 않고 연속적으로 사용하므로 속도가 개선되고 메모리가 절약됨
• make_pipeline() 함수를 사용하여 파이프라인을 만들 수 있음
• make_pipeline() 함수는 파이프라인의 이름을 자동으로 만들어 줌
• 파이프라인의 이름은 각 추정기의 클래스 이름을 소문자로 바꾼 것과 같음
• 파이프라인의 이름을 지정하려면 Pipeline() 클래스를 사용해야 함
• 파이프라인 내부의 중간결과 확인하기 -> pipeline의 인덱스나 named_steps로 확인이 가능

5.3 파이프라인의 결합

5.3.1 수치형 데이터 파이프라인 처리

기본

import seaborn as sns
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer

# 데이터 로드
df = sns.load_dataset('diamonds')
print(df.info())
X = df.drop('price', axis=1)
y = df['price']

numeric_col = list(X.select_dtypes(exclude='category').columns)
category_col = list(X.select_dtypes(include='category').columns)
print(f'numeric_col: {numeric_col}')
print(f'category_col: {category_col}')

numeric_pipeline = Pipeline(
    steps=[
        ('imputer', SimpleImputer(strategy='mean')),
        ('scaler', StandardScaler())
    ])

display(numeric_pipeline)

numerical_data_piped = numeric_pipeline.fit_transform(X[numeric_col])
pd.DataFrame(numerical_data_piped, columns=numeric_col).head()

학습

• 데이터를 유형에 따라 분리하고, 파이프라인을 구축
• Nan 값은 평균값으로 채우고, 표준화한다.

5.3.2 범주형 데이터 파이프라인 처리

기본

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder

category_pipeline = Pipeline(
    steps=[
        ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
        ('onehot', OneHotEncoder(sparse_output=False))
    ])

display(category_pipeline)

category_data_piped = category_pipeline.fit_transform(X[category_col])

category_colnames = category_pipeline[1].get_feature_names_out(category_col)

pd.DataFrame(category_data_piped, columns=category_colnames).head()

학습

• 파이프라인 구축
• 비어있는 값 -> missing 채우기
• one-hot encoding 적용
• 파이프라인 이후 데이터는 array에서 데이터프레임이 됨

5.3.3 수치형 + 범주형 파이프라인 결합한 파이프라인

기본

from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LinearRegression

preprocessor = ColumnTransformer(
    transformers=[
        ('numeric', numeric_pipeline, numeric_col),
        ('category', category_pipeline, category_col)
    ])

pipe = make_pipeline(preprocessor, LinearRegression())
display(pipe) 
pipe.fit(X,y)

print('Estimate : ', pipe.predict(X))
print('Accuracy : ', pipe.score(X, y))

학습

• ColumnTransformer 클래스를 사용하여 수치형 데이터와 범주형 데이터의 파이프라인을 결합할 수 있음

5.3.4 ColumnTransformer

기본

from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
import pandas as pd
import numpy as np

data_df = pd.DataFrame({
    "height":[165,  np.nan, 182],
    "weight":[70,   62,     np.nan],
    "age"   :[np.nan,18,    15]
})

col_transformer = ColumnTransformer([
    ("Impute_mean", SimpleImputer(strategy="mean"), ["height"])
    ], 
    remainder="passthrough"
)

display(col_transformer)
print(data_df)
print(col_transformer.fit_transform(data_df))

col_transformer2 = ColumnTransformer([
    ("Impute_mean"  , SimpleImputer(strategy="mean")  , ["height"]),
    ("Impute_median", SimpleImputer(strategy="median"), ["weight"])
    ],
    remainder=SimpleImputer(strategy="constant", fill_value=-1)
)

display(col_transformer2)
print(data_df)
print(col_transformer2.fit_transform(data_df))

학습

• ColumnTransformer -> 컬럼 기준으로 데이터를 복합하여 처리해주는 함수
• SimpleImputer를 사용해서 height의 null 값들은 평균으로 출력하고 나머지 column은 통과 (1)
• SimpleImputer를 사용해서 mean과 median 값을 null에 넣고 나머지 열(column)에 대한 값은 상수로 -1 값을 넣어 줌 (2)

응용

test_df = pd.DataFrame({'city':['서울','부산','대구','수원','광주','울산','강릉','제주']})

pd.get_dummies(test_df['city'])

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder()
values = encoder.fit_transform(test_df[['city']]).toarray()

pd.DataFrame(values, columns = test_df['city'])

from sklearn.preprocessing import OrdinalEncoder

encoder = OrdinalEncoder()
encoder.fit(test_df)
df_tt = pd.DataFrame(encoder.transform(test_df), columns=test_df.columns)
df_tt

from sklearn.preprocessing import LabelEncoder

encoder = LabelEncoder()

test_df['label'] = encoder.fit_transform(test_df[['city']])
test_df

1.1 노이즈

노이즈라는 말은 원래 소음·잡음을 의미하는데, 이 말이 각 분야에서 여러 가지 의미로 쓰이고 있다. 데이터 분야에서는 측정된 변수에 무작위의 오류 또는 분산이 존재하는 것, 데이터를 사용할 때 제거되거나 무시되어야 하는 의미 없이 첨가된 비트나 단어들을 의미한다.

1.2 정형 데이터의 노이즈

• 정형 데이터에서 노이즈는 분산으로 나타난다.

  • 분산 : 데이터의 무작위 변동
  • 이상치 -> 데이터의 무작위 변동을 초과하는 특정한 값으로 별도 처리

• 통계 모형에서 노이즈는 오차항으로 나타난다. -오차항 : 모형에서 설명하지 못하는 무작위 변동 -예) 단순선형회귀모형에서는 오차항 ϵi가 노이즈

1.3 이미지/영상 데이터의 노이즈

• 이미지/영상 데이터에서 노이즈는 다양한 형태로 나타난다. -blur : 이미지가 흐릿하게 보이는 현상 -white noise(백색 잡음) : 모든 주파수 영역에서 동일한 에너지를 가지는 잡음 -pink noise : 특정 주파수 대역에서 강하게 나타나는 노이즈, 일반적으로 낮은 주파수 대역에서 강하게 나타남 -Gaussian noise : 평균이 0이고, 분산이 1인 정규분포(가우시안 분포)를 따르는 잡음

• 이미지/영상 데이터의 노이즈 주요 원인

• 이미지를 얻는 과정에서 수집된 광자의 양 너무 적음

• 이미지를 얻는 과정에서 센서나 렌즈의 열화가 발생

• 이미지를 전송 중에 무선 통신의 에코 및 대기 왜곡 발생 등

1.4 시계열/음성/신호 데이터의 노이즈

시계열/음성/신호에서 노이즈는 일반적으로 white noise나 Gaussian noise로 나타난다. (이미지 -> 가우시안 잡음에 관한 것.)

1.5 텍스트 데이터의 노이즈

• 텍스트 데이터의 노이즈 발생 원인은 일반적으로 철자 오류, 약어나 비표준 단어 사용, 반복되는 말, 구두점이나 대소 문자 정보 누락, “음” 및 “어”와 같은 의성어 사용 등이 있다.
• 텍스트 데이터의 노이즈는 자연어 처리의 성능을 저하시키므로 처리 대상이다.
• 자동 음성 인식, 광학 문자 인식, 기계 번역, Web Scraping 등으로 수집한 데이터에 노이즈가 많다.

1.6 비슷한 다른 용어들

• Defact(결함) : 전체 데이터에 존재하는 일부 오류 데이터 -범위에서 벗어난 이상치(outlier)가 아니라 잘못된(error) 데이터 -주로 생산이나 제조 분야에서 사용한다. (이미지 -> 반도체 결함)

• Fault(불량/기능이상) : Defact에 의해 제품/설비의 기능에 손상을 입으면 발생한다. -모든 defect가 fault를 야기하지는 않음

• Artifact : 주로 과학기술 분야에서 사용하는 용어로 특히, 이미지의 결함을 지칭한다.

• Noise : 일반적으로 그 원인을 알 수 없는 무작위 변동을 의미한다. 데이터 과학에서는 데이터의 무작위 변동을 의미한다. -무작위(ramdom)가 발생하는 메커니즘을 알 수 없다는 의미로 발생 메커니즘을 알게 되면 무작위 중 수학적 모형을 통하여 반영된 것을 제외한 것이 random이 된다. -주로 신호처리(signal processing) 분야에서 사용하는 용어임 -동작 메커니즘을 모르므로 제거는 불가하기 때문에 이를 저감(Denoising)하여야 한다.

2. 디노이징

2.1 디노이징

디노이징은 데이터에서 노이즈를 저감하여 모형이 더 좋은 성능을 할 수 있도록 하는 전처리 과정이다. 앞에서 언급했듯이 노이즈는 제거가 불가능하기 때문에 디노이징이 필요하다. 기본적인 기법으로는 평활화(smoothing, 구간평균), 구간화(binning, 구간집계), 필터링(filtering, 주파성분 저감)기법이 있다.

2.2 정형 데이터의 디노이징

• 정형 데이터의 디노이징 방법으로는 구간화와 군집화가 있다. -구간화 : 정렬된 데이터 값들을 몇 개의 bin(혹은 bucket)으로 분할하여 대표값으로 대체하는 방법 -군집화 : 유사한 값들을 하나의 군집으로 처리하여 중심점(centroid)을 대표값으로 대체하는 방법

2.3 구간화

• 구간 설정 방법

  1. 동일 간격(equal-distance) 구간화 → pandas의 cut() 사용 -정상 데이터가 한쪽으로 편중(biased)되고 이상치의 영향을 많이 받는다. -한쪽으로 몰려있는 데이터들은 다 동일한 bin으로 들어오기 때문에 skewed data를 다룰 수 없다.
  2. 동일 빈도(eual-frequency) 구간화 → pandas의 qcut() 사용 -동일한 개수의 데이터를 가지는 구간으로 설정한다.

• 구간별 대표값 설정 방법 -평균값 평활화 : bin에 있는 값들을 평균값으로 대체 -중앙값 평활화 : 중앙값으로 대체 -경계값 평활화 : 경계값 중 가까운 값으로 대체

• 기본

  import pandas as pd
  import numpy as np
  

df = pd.DataFrame({'uniform': np.sort(np.random.uniform(0,10,10)), 'normal': np.sort(np.random.normal(5,1,10)), 'gamma': np.sort(np.random.gamma(2, size=10))}) df.plot(kind='hist', bins=15, alpha=0.5) df.describe()

col = 'uniform' num_bins = 5 df_binned = pd.DataFrame() df_binned[col] = df[col].sort_values() df_binned['eq_dist_auto'] = pd.cut(df_binned[col], num_bins) df_binned['eq_dist_fixed'] = pd.cut(df_binned[col], bins=[0,2,4,6,8,10]) df_binned['eq_freq_auto'] = pd.qcut(df_binned[col], num_bins) df_binned

cols = ['uniform', 'normal', 'gamma'] df_ew = df.copy() for col in cols: df_ew[col+'_eq_dist'] = pd.cut(df_ew[col], 3) means = df_ew.groupby(col+'_eq_dist')[col].mean() df_ew.replace({col+'_eq_dist': means}, inplace=True) display(df_ew) df_ef = df.copy() for col in cols: df_ef[col+'_eq_freq'] = pd.qcut(df_ef[col], 3) means = df_ef.groupby(col+'_eq_freq')[col].mean() df_ef.replace({col+'_eq_freq': means}, inplace=True) display(df_ef)

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(10,5)) df_ew.astype(float).plot(ax=axes[0]) df_ef.astype(float).plot(ax=axes[1]) plt.show()

* 학습 (학습한 내용 #으로 표시)
```python
import pandas as pd
import numpy as np

# 데이터를 랜덤으로 생성한다. 또한 데이터 결과를 보기 용이하도록 sort한다. 10개씩 (균일분포, 정규분포, 감마분포 추출)
aa = pd.DataFrame({'uniform': np.sort(np.random.uniform(0,10,10)),
                     'normal': np.sort(np.random.normal(5,1,10)),
                     'gamma': np.sort(np.random.gamma(2, size=10))})

# 생성한 데이터를 확인한다. 히스토그램으로 나타낸다.(15)
aa.plot(kind='hist', bins=15, alpha=0.5)
aa.describe()

• Pandas로 구간화

  # cut(), qcut() 기본 동작 확인, cut()는 동일한 길이로 나누는 함수이고, qcut()는 동일한 개수로 나누는 함수이다.
  col = 'uniform'
  num_bins = 5
  aa_binned = pd.DataFrame()
  aa_binned[col] = aa[col].sort_values()  # 원 데이터(해당 열)를 오름차순 정렬
  aa_binned['eq_dist_auto'] = pd.cut(aa_binned[col], num_bins)  # 동일한 간격(5)으로 나누기
  aa_binned['eq_dist_fixed'] = pd.cut(aa_binned[col], bins=[0,2,4,6,8,10]) # 지정된 구간으로 나누기, 예) 0~2 사이, 2~4 사이...
  aa_binned['eq_freq_auto'] = pd.qcut(aa_binned[col], num_bins) # 동일 빈도(5개 묶음)로 나누기
  aa_binned

  

# 구간화하여 평균값 대체하기
cols = ['uniform', 'normal', 'gamma']

# 동일 간격 구간화 -> cut
aa_ew = aa.copy()
for col in cols:
    aa_ew[col+'_eq_dist'] = pd.cut(aa_ew[col], 3)   # 열 별로 구간(3) 나누기
    means = aa_ew.groupby(col+'_eq_dist')[col].mean() # 구간(3)별 평균값 계산
    aa_ew.replace({col+'_eq_dist': means}, inplace=True) # 각 구간별 평균값으로 대체

display(aa_ew)

# 동일 빈도 구간화 -> 묶이는 개수가 같게(qcut)
aa_ef = aa.copy()
for col in cols:
    aa_ef[col+'_eq_freq'] = pd.qcut(aa_ef[col], 3)   # 구간 개수(3)으로 나누기
    means = aa_ef.groupby(col+'_eq_freq')[col].mean() # 구간별 평균값 계산
    aa_ef.replace({col+'_eq_freq': means}, inplace=True) # 평균값으로 대체

display(aa_ef)

# 시각화
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(10,5))
aa_ew.astype(float).plot(ax=axes[0])
aa_ef.astype(float).plot(ax=axes[1])
plt.show()

실행 결과 정리 -> cut을 이용해 동일 간격, qcut을 이용해 동일 빈도로 구간화하여 평균에 대한 새로운 열을 생성한 후 그래프로 시각화 하였음.

• 응용

  import pandas as pd
  import numpy as np
  

ee = pd.DataFrame({"gender": np.random.randint(0, 2, size=11), "age": np.random.randint(20, 70, size=11), 'happiness': np.random.randint(1, 6, size=11)}) gender_lv = ['male', 'female'] ee["gender"] = pd.Categorical.from_codes(ee["gender"], gender_lv)

ee['age_cut'] = pd.cut(ee['age'], 3) ee['age_qcut'] = pd.qcut(ee['age'], 4) ee

![](https://velog.velcdn.com/images/hate_all/post/7e0bdb81-a10b-41eb-b591-2613253f2cc6/image.png)
실행 결과 정리 -> 임의의 데이터 ee를 생성한 후 cut과 qcut을 사용하여 구간화 하였다.

## 2.4 군집화
* Scikit-Learn으로 구간화
* 기본
```python
import warnings
warnings.filterwarnings("ignore")
from sklearn.preprocessing import KBinsDiscretizer

ed_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform', subsample=None)
df_ed = ed_binner.fit_transform(df)
ef_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='quantile', subsample=None)
df_ef = ef_binner.fit_transform(df)
km_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='kmeans', subsample=None)
df_km = km_binner.fit_transform(df)
df_ed = pd.DataFrame(df_ed, columns=df.columns+'_eq_dist')
df_ef = pd.DataFrame(df_ef, columns=df.columns+'_eq_freq')
df_km = pd.DataFrame(df_km, columns=df.columns+'_km')
df_bin = pd.concat([df, df_ed, df_ef, df_km], axis=1)
df_bin

for bin_col in df_bin.columns:
    col = bin_col.split('_')[0]
    means = df_bin.groupby(by=bin_col)[col].mean()
    df_bin.replace({bin_col: means}, inplace=True)
df_bin

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 3, figsize=(15,5))
pd.concat([df_bin.iloc[:,:3], df_bin.iloc[:,3:6]], axis=1).astype(float).plot(ax=axes[0])
pd.concat([df_bin.iloc[:,:3], df_bin.iloc[:,6:9]], axis=1).astype(float).plot(ax=axes[1])
pd.concat([df_bin.iloc[:,:3], df_bin.iloc[:,9:]], axis=1).astype(float).plot(ax=axes[2])
plt.show()

• 학습

  from sklearn.preprocessing import KBinsDiscretizer
  #KBinsDiscretizer() -> 파라미터 n_bins(간격/구간 수), encode, strategy, subsample=none -> training 데이터 모두 사용
  # encode -> onehot(수많은 0과 하나의 1로 구분)/onehot-dense(onehot 인코딩&조밀한 배열)/ordinal(정수 값으로 인코딩)
  #strategy -> uniform(동일간격)/quantile(동일빈도)/kmeans(K-Means 군집화)
  #fit_transform -> train data로 학습된 Scaler()의 parameter를 통해 test data의 feature 값들이 스케일 되는 것
  

동일 간격 구간화 -> uniform 사용

ed_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform', subsample=None) aa_ed = ed_binner.fit_transform(aa)

동일 빈도 구간화 -> quantile 사용

ef_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='quantile', subsample=None) aa_ef = ef_binner.fit_transform(aa)

K-means 구간화 -> kmeans 사용

km_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='kmeans', subsample=None) aa_km = km_binner.fit_transform(aa)

결과 확인

aa_ed = pd.DataFrame(aa_ed, columns=aa.columns+'_eq_dist') aa_ef = pd.DataFrame(aa_ef, columns=aa.columns+'_eq_freq') aa_km = pd.DataFrame(aa_km, columns=aa.columns+'_km') aa_bin = pd.concat([aa, aa_ed, aa_ef, aa_km], axis=1) aa_bin

![](https://velog.velcdn.com/images/hate_all/post/71da2c7f-23f8-4c67-afb1-0b1e6b915513/image.png)

```python
# 구간화하여 평균값 대체하기 (n_bins=3)
for bin_col in aa_bin.columns:
    col = bin_col.split('_')[0] #uniform/normal/gamma
    means = aa_bin.groupby(by=bin_col)[col].mean() # 구간별 평균값 계산
    aa_bin.replace({bin_col: means}, inplace=True) # 평균값으로 대체

aa_bin

# 시각화
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 3, figsize=(15,5))
pd.concat([aa_bin.iloc[:,:3], aa_bin.iloc[:,3:6]], axis=1).astype(float).plot(ax=axes[0])
pd.concat([aa_bin.iloc[:,:3], aa_bin.iloc[:,6:9]], axis=1).astype(float).plot(ax=axes[1])
pd.concat([aa_bin.iloc[:,:3], aa_bin.iloc[:,9:]], axis=1).astype(float).plot(ax=axes[2])
plt.show()

실행 결과 정리 -> strategy 파라미터로 각 방법별로 구간화를 한 후(구간 별 0/1/2로 표현) 구간별 평균값을 행별로 구하여 대체한 후 시각화를 하였다.

• 응용

  # strategy = uniform, mean 기준
  from sklearn.preprocessing import KBinsDiscretizer
  import matplotlib.pyplot as plt
  train_pt = pd.DataFrame(ii['sepal_length'])
  

est_uni = KBinsDiscretizer(n_bins=2, encode='ordinal', strategy='uniform') est_uni.fit(train_pt)

Xt_uni=est_uni.transform(train_pt) print("edges : ", est_uni.bin_edges_[0])

unique, counts = np.unique(Xt_uni, return_counts=True) print(dict(zip(unique, counts)))

plt.hist(Xt_uni, bins='auto') plt.xticks([0,0.5,1]) plt.rcParams['figure.figsize']=(5.5,6) plt.show

![](https://velog.velcdn.com/images/hate_all/post/bf5f6293-4232-432d-b0e9-58ca9fd203a0/image.png)

```python
# strategy = quantile, median 기준

est_quan = KBinsDiscretizer(n_bins=2, encode='ordinal', strategy='quantile')
est_quan.fit(train_pt)

Xt_quan=est_quan.transform(train_pt)
print("edges : ", est_quan.bin_edges_[0])

unique_q, counts_q = np.unique(Xt_quan, return_counts=True)
print(dict(zip(unique_q, counts_q)))

plt.hist(Xt_quan, bins='auto')
plt.xticks([0,0.5,1])
plt.rcParams['figure.figsize']=(5.5,6)
plt.show

# strategy = kmeans, normal distribution 2개 생성

est_km = KBinsDiscretizer(n_bins=2, encode='ordinal', strategy='kmeans')
est_km.fit(train_pt)

Xt_km=est_km.transform(train_pt)
print("edges : ", est_km.bin_edges_[0])

unique_k, counts_k = np.unique(Xt_km, return_counts=True)
print(dict(zip(unique_k, counts_k)))

plt.hist(Xt_km, bins='auto')
plt.xticks([0,0.5,1])
plt.rcParams['figure.figsize']=(5.5,6)
plt.show()

실행 결과 정리 -> iris의 sepa_length 열을 그룹핑하여 세 방법으로 범주화하였다.

3. Scikit-Learn

3.1 Scikit-Learn

python을 대표하는 머신러닝 라이브러이다. Scikit-Learn이 시행할 수 있는 여러 가지 데이터 전처리 도구 및 알고리즘은 지도 학습, 비지도 학습, 데이터 평가 등 기계 학습의 다양한 분야를 망라하고 있다.

3.2 주요 기능

분류: 로지스틱 회귀, 결정 트리, 서포트 벡터 머신(SVM) 회귀: 선형 회귀, 릿지 회귀 등 군집화: k-평균 군집화, 계층적 군집화 등 차원 축소: 주성분 분석(PCA), t-분산 확률적 이웃 내재화(t-SNE) 등 전처리: 데이터 정규화, 스케일링, 인코딩 등

3.3 장점

• 매우 다양한 전처리 도구와 알고리즘을 제공하고 있어 머신러닝 기법을 배우는 데 적합하다. -예제와 사용 설명서가 잘 되어있어 참고하여 코드를 작성하기 용이하다.

• 데이터 분석을 위한 간단하고 효율적인 도구를 제공한다. -간단하고 직관적인 API를 제공하므로 다양한 수준의 전문 지식을 가진 사용자가 접근 가능하다. -fit(), transform(), predict() 등 체계적이고 일관된 분석 및 학습모형 운용 체계를 갖추고 있다. -다른 많은 패키지도 scikit-learn과 동일한 체계를 제공하여 유사한 프레임에서 사용이 가능하다.

• NumPy, Pandas, SciPy 및 matplotlib를 기반으로 구축되어 있어 다른 파이썬 패키지와 함께 사용하기 용이하다. -NumPy: 다차원 배열을 위한 기본 패키지 -Pandas: 데이터프레임을 위한 기본 패키지 -SciPy: 과학 계산용 함수를 모아놓은 패키지 -matplotlib: 데이터 시각화를 위한 패키지

3.4 단점

하지만 딥러닝, 강화학습, 시계열 모형에는 매우 약하고 최근 개발된 대용량을 위한 데이터프레임인 Polars와 같은 라이브러리와는 연동이 잘 안 된다는 단점이 있다.

4. 스케일링

4.1 Scikit-Learn Preprocessing

• Scikit-learn의 전처리 기능은 크게 4가지로 나눌 수 있다. -스케일링(scaling): 서로 다른 변수의 값 범위를 선형변환을 통하여 일정한 수준으로 맞추는 것으로 표준화, 정규화, 변환이 있음 -이진화(binarization): 연속적인 값을 0 또는 1로 나누는 것, 연속형 변수 → 이진형 변수 -인코딩(encodig): 범주형 값을 적절한 숫자형으로 변환하는 작업, 범주형 변수 → 수치형 변수 -변환(transformation): 데이터의 분포를 변환하여 정규성을 확보하는 것

4.2 스케일링의 필요성

• 독립변수(feature)별로 값의 변위가 다르면 종속변수(target)에 대한 영향이 독립변수의 변위에 따라 크게 달라지기 때문에 머신러닝 시 학습효과가 떨어지므로 스케일링이 필요하다.
• 다차원의 값들을 동일한 수준에서 비교 분석하기 용이하게 만들어 준다.
• 컴퓨터의 비트수로 인하여 다른 값으로 인식되는 오버플로우(overflow)나 언더플로우(underflow)를 방지한다.
• 최적화 과정에서의 안정성 및 수렴 속도를 향상한다.
• 특히 k-means 등 거리 기반의 모델에서는 스케일링이 매우 중요하다.

4.3 스케일링 절차

• Scaler 객체를 이용한다. -fit(): 주어진 데이터에 맞추어 학습한다. 데이터 변환을 위한 기준 정보 설정을 적용한다. (ex.최소값,최대값 등) -transform(): Scaler 적용, fit()된 정보를 이용해 데이터를 변환한다. -fit_transform() : fit()과 transform()을 한 번에 실행한다.

• 훈련(training) 데이터와 평가(test) 데이터의 스케일링 변환 시 유의점 -훈련 데이터는 fit()과 transform() 모두 적용 가능하다. -평가 데이터는 fit()은 필요없으므로 transform()만 적용해야 한다. 훈련 데이터로 fit()된 스케일링 기준 정보를 그대로 테스트에 적용해야하기 때문이다.

4.4 표준화

• 표준화를 하면 평균은 0, 분산과 표준편차는 1이 되므로 데이터의 분포가 단순화되어 독립변수간 데이터 수준의 비교가 용이하다.

• RBF 커널(가우시안 방사 기저함수)을 이용하는 서포트 벡터 머신, 선형회귀, 로지스틱 회귀는 데이터가 정규분포를 가지고 있다고 가정하고 구현되므로 표준화를 하면 좋다.

• 표준화는 이상치에 민감하며, 분류보다는 회귀에 유용하다.

• 기본

  import pandas as pd
  import seaborn as sns
  

pd.set_option('display.float_format', lambda x: f'{x:.4f}') iris = sns.load_dataset('iris') iris = iris.select_dtypes(exclude='object') iris.describe() sns.jointplot(data=iris, x='petal_length', y='petal_width', kind='reg')

from sklearn.preprocessing import StandardScaler, RobustScaler

standard_scaler = StandardScaler() robust_scaler = RobustScaler() iris_standard = pd.DataFrame(standard_scaler.fit_transform(iris), columns=iris.columns) iris_robust = pd.DataFrame(robust_scaler.fit_transform(iris), columns=iris.columns) print('Standard Scaled: \n', iris_standard.describe()) print() print('Robust Scaled: \n', iris_robust.describe())

import seaborn as sns import patchworklib as pw pw.overwrite_axisgrid()

g1 = sns.jointplot(data=iris_standard, x='petal_length', y='petal_width', kind='reg') g1 = pw.load_seaborngrid(g1) g1.set_suptitle("Standard Scaled") g2 = sns.jointplot(data=iris_robust, x='petal_length', y='petal_width', kind='reg') g2 = pw.load_seaborngrid(g2) g2.set_suptitle("Robust Scaled") g12 = (g1|g2) g12

* 학습
```python
#데이터 로드
import pandas as pd
import seaborn as sns

# 소수점 4째자리 이하에서 반올림 설정
pd.set_option('display.float_format', lambda x: f'{x:.4f}')

# iris 데이터 로드
ii = sns.load_dataset('iris')

# iris의 수치형 변수만 선택(문자형 제외)
ii = ii.select_dtypes(exclude='object')

# iris의 기술통계량을 확인
ii.describe()

# sepal_lengh와 petal_length의 jointplot을 그림
# 조인트 플롯 -> 두 수치형 변수 간의 관계 연구 가능
sns.jointplot(data=ii, x='petal_length', y='petal_width', kind='reg')

#표준화
from sklearn.preprocessing import StandardScaler, RobustScaler

# Scaler 객체 생성
#StandardScaler(): 기본 스케일러, 평균과 표준편차 사용
#RobustScaler(): 중앙값과 IQR(Q3-Q1)을 사용. 이상치의 영향을 최소화
standard_scaler = StandardScaler()
robust_scaler = RobustScaler()

# 데이터 변환, 각각 (평균=0, 표준편차=1) (중앙값=0, IQR=1)
ii_standard = pd.DataFrame(standard_scaler.fit_transform(ii), columns=ii.columns)
ii_robust = pd.DataFrame(robust_scaler.fit_transform(ii), columns=ii.columns)

# 결과 출력
print('Standard Scaled: \n', ii_standard.describe())
print()
print('Robust Scaled: \n', ii_robust.describe())

# 그래프로 확인
# seaborn의 jointplot은 figure의 axes를 지정할 수 없어 subplot을 그리기가 어려움
# patchworklib 패키지를 사용하여 subplot을 그림
import seaborn as sns
import patchworklib as pw
pw.overwrite_axisgrid()

# 첫번째 그래프 
g1 = sns.jointplot(data=ii_standard, x='petal_length', y='petal_width', kind='reg')
g1 = pw.load_seaborngrid(g1)
g1.set_suptitle("Standard Scaled")

# 두번째 그래프 
g2 = sns.jointplot(data=ii_robust, x='petal_length', y='petal_width', kind='reg')
g2 = pw.load_seaborngrid(g2)
g2.set_suptitle("Robust Scaled")

# 그래프 합치기
g12 = (g1|g2)
g12

실행 결과 정리 -> iris 데이터의 수치형 변수만을 골라서 변수 간의 관계에 대하여 시각화 하였다. 그리고 두 스케일러를 사용하여 데이터를 변환한 다음 시각화를 하였다.

4.5 정규화

• 정규화 → 규격화(특정 범위(주로 [0,1]) 로 스케일링)

• 기본

  from sklearn.preprocessing import MinMaxScaler, MaxAbsScaler
  

minmax_scaler = MinMaxScaler() maxabs_scaler = MaxAbsScaler() iris_minmax = pd.DataFrame(minmax_scaler.fit_transform(iris), columns=iris.columns) iris_maxabs = pd.DataFrame(maxabs_scaler.fit_transform(iris), columns=iris.columns) print('MinMax Scaled: \n', iris_minmax.describe()) print() print('MaxAbs Scaled: \n', iris_maxabs.describe())

g3 = sns.jointplot(data=iris_minmax, x='petal_length', y='petal_width', kind='reg') g3 = pw.load_seaborngrid(g3) g3.set_suptitle("MinMax Scaled") g4 = sns.jointplot(data=iris_maxabs, x='petal_length', y='petal_width', kind='reg') g4 = pw.load_seaborngrid(g4) g4.set_suptitle("MaxAbs Scaled") g34 = (g3|g4) g34

* 학습
```python
from sklearn.preprocessing import MinMaxScaler, MaxAbsScaler

# Scaler 객체 생성
# MinMaxScaler(): 범위가 [0,1]이 되도록 스케일링
# MaxAbsScaler(): 양수는 [0,1], 음수는 [-1,0], 양수&음수는 [-1,1]이 되도록 스케일링
minmax_scaler = MinMaxScaler()
maxabs_scaler = MaxAbsScaler()

# 데이터 변환 각각 [0,1] [0,1]로
ii_minmax = pd.DataFrame(minmax_scaler.fit_transform(ii), columns=ii.columns)
ii_maxabs = pd.DataFrame(maxabs_scaler.fit_transform(ii), columns=ii.columns)

# 결과 출력
print('MinMax Scaled: \n', ii_minmax.describe())
print()
print('MaxAbs Scaled: \n', ii_maxabs.describe())

# 세번째 그래프 
g3 = sns.jointplot(data=ii_minmax, x='petal_length', y='petal_width', kind='reg')
g3 = pw.load_seaborngrid(g3)
g3.set_suptitle("MinMax Scaled")

# 네번째 그래프 
g4 = sns.jointplot(data=ii_maxabs, x='petal_length', y='petal_width', kind='reg')
g4 = pw.load_seaborngrid(g4)
g4.set_suptitle("MaxAbs Scaled")

# 그래프 합치기
g34 = (g3|g4)
g34

실행 결과 정리 -> 표준화 때와 마찬가지로 두 스케일러를 가지고 그래프로 시각화 하여 두 변수 사이의 관계를 나타냈다.

4.6 변환

• 변환(특정한 분포나 모양을 따르도록 스케일링)

• 기본

  import numpy as np
  from sklearn.preprocessing import PowerTransformer, Normalizer
  

power_scaler = PowerTransformer() normal_scaler = Normalizer() iris_power = pd.DataFrame(power_scaler.fit_transform(iris), columns=iris.columns) iris_normal = pd.DataFrame(normal_scaler.fit_transform(iris), columns=iris.columns) print('PowerTranformer Scaled: \n', iris_power.describe()) print() print('Normalizer Scaled: \n', iris_normal.describe()) print('Euclidian Distance from 0: \n', np.linalg.norm(iris_normal, axis=1))

g5 = sns.jointplot(data=iris_power, x='petal_length', y='petal_width', kind='reg') g5 = pw.load_seaborngrid(g5) g5.set_suptitle("PowerTransformer Scaled") g6 = sns.jointplot(data=iris_normal, x='petal_length', y='petal_width', kind='reg') g6 = pw.load_seaborngrid(g6) g6.set_suptitle("Normalizer Scaled") g56 = (g5|g6) g56

from sklearn.preprocessing import QuantileTransformer

gaussian_scaler = QuantileTransformer(output_distribution='normal') uniform_scaler = QuantileTransformer(output_distribution='uniform') iris_gaussian = pd.DataFrame(gaussian_scaler.fit_transform(iris), columns=iris.columns) iris_uniform = pd.DataFrame(uniform_scaler.fit_transform(iris), columns=iris.columns) print('QuantileTranformer_Gaussian Scaled: \n', iris_gaussian.describe()) print() print('QuantileTranformer_Uniform Scaled: \n', iris_uniform.describe())

g7 = sns.jointplot(data=iris_gaussian, x='petal_length', y='petal_width', kind='reg') g7 = pw.load_seaborngrid(g7) g7.set_suptitle("QuantileTranformer_Gaussian Scaled") g8 = sns.jointplot(data=iris_uniform, x='petal_length', y='petal_width', kind='reg') g8 = pw.load_seaborngrid(g8) g8.set_suptitle("QuantileTranformer_Uniform Scaled") g78 = (g7|g8) g78 (g1|g2|g3|g4)/(g5|g6|g7|g8)

* 학습
```python
import numpy as np
from sklearn.preprocessing import PowerTransformer, Normalizer

# Scaler 객체 생성
# PowerTransformer(): 정규분포화(정규성 변환)(Box-Cox 변환, Yeo-Johnson 변환)
# Normalizer(): 한 행의 모든 피처들 사이의 유클리드 거리가 1이 되도록 변환
power_scaler = PowerTransformer()
normal_scaler = Normalizer()

# 데이터 변환 각각 (평균=0, 표준편차=1) (각 행의 벡터 크기 1)
ii_power = pd.DataFrame(power_scaler.fit_transform(ii), columns=ii.columns)
ii_normal = pd.DataFrame(normal_scaler.fit_transform(ii), columns=ii.columns)

# 결과 출력
print('PowerTranformer Scaled: \n', ii_power.describe())
print()
print('Normalizer Scaled: \n', ii_normal.describe())
print('Euclidian Distance from 0: \n', np.linalg.norm(ii_normal, axis=1))

# 다섯번째 그래프
g5 = sns.jointplot(data=ii_power, x='petal_length', y='petal_width', kind='reg')
g5 = pw.load_seaborngrid(g5)
g5.set_suptitle("PowerTransformer Scaled")

# 여섯번째 그래프
g6 = sns.jointplot(data=ii_normal, x='petal_length', y='petal_width', kind='reg')
g6 = pw.load_seaborngrid(g6)
g6.set_suptitle("Normalizer Scaled")

# 그래프 합치기
g56 = (g5|g6)
g56

from sklearn.preprocessing import QuantileTransformer

# Scaler 객체 생성
# QuantileTransformer(): 균일(Uniform)분포 또는 정규(Gaussian)분포로 변환
gaussian_scaler = QuantileTransformer(output_distribution='normal')
uniform_scaler = QuantileTransformer(output_distribution='uniform')

# 데이터 변환
ii_gaussian = pd.DataFrame(gaussian_scaler.fit_transform(ii), columns=ii.columns)
ii_uniform = pd.DataFrame(uniform_scaler.fit_transform(ii), columns=ii.columns)

# 결과 출력
print('QuantileTranformer_Gaussian Scaled: \n', ii_gaussian.describe())
print()
print('QuantileTranformer_Uniform Scaled: \n', ii_uniform.describe())

# 일곱번째 그래프
g7 = sns.jointplot(data=ii_gaussian, x='petal_length', y='petal_width', kind='reg')
g7 = pw.load_seaborngrid(g7)
g7.set_suptitle("QuantileTranformer_Gaussian Scaled")

# 여덟번째 그래프
g8 = sns.jointplot(data=ii_uniform, x='petal_length', y='petal_width', kind='reg')
g8 = pw.load_seaborngrid(g8)
g8.set_suptitle("QuantileTranformer_Uniform Scaled")

# 그래프 합치기
g78 = (g7|g8)
g78

# 모든 그래프 합치기
(g1|g2|g3|g4)/(g5|g6|g7|g8)

실행 결과 정리 -> 마찬가지로 세 스케일러를 통해 데이터를 변환한 후 그래프로 시각화하여 변수간 관계를 나타냈다.

• 응용

  import pandas as pd
  import numpy as np
  

df = pd.DataFrame({'x1' : np.arange(11), 'x2' : np.arange(11) ** 2}) from sklearn.preprocessing import StandardScaler

scaler = StandardScaler() df_std = scaler.fit_transform(df)

pd.DataFrame(df_std, columns = ['x1_std', 'x2_std'])

![](https://velog.velcdn.com/images/hate_all/post/f345f91e-9a5e-4665-88f5-6c10a198ccd8/image.png)
```python
import pandas as pd
import numpy as np

df = pd.DataFrame({'x1' : np.arange(11), 'x2' : np.arange(11) ** 2})
from sklearn.preprocessing import RobustScaler

scaler = RobustScaler()
df_std = scaler.fit_transform(df)

pd.DataFrame(df_std, columns = ['x1_std', 'x2_std'])

실행 결과 정리 -> 간단한 데이터셋(x, x^2)에 대하여 StandardScaler와 RobustScaler를 적용하여 새로운 데이터셋으로 나타내었다. 확실히 후자가 이상치의 영향을 덜 받는다는 것이 납득이 간다.