'이온 스위칭'이라는 이름인데, 고등학교 때 어깨너머로 배운 생명과학2가 생각이 났다. 흥분의 전도 배울 때, 나트륨 통로, 칼륨 통로, 나트륨 칼륨 펌프 이렇게 배웠던 것 같다. 큰 도움은 되지 않지만, 약간의 domain knowledge를 기억해내자면,
세포 내부는 기본적으로 약한 음전하를 띄고, 세포 외부는 양전하를 가지고 있는 상태이다. 이때의 전위차를 휴지 전위 라고 한다. 이때 세포에 자극이 주어졌을 때, 세포막에 있는 통로가 열리면서 세포 외부의 양전하를 띄는 이온들이 세포 내부로 들어오게 되면서 세포 내부의 전하가 + 가 된다. 이때 + 전하의 값을 활동 전위, 이 활동 전위가 나타나는 현상을 탈분극이라고 한다.
깜짝 놀란 세포는 다시 휴지전위로 돌아가고자 들어왔던 양이온들을 다시 내보낸다. 이를 재분극이라고 한다. 이때 일시적으로 휴지 전위보다 전하량이 더 낮아지는 과정이 있는데, 이런 현상을 과분극이라고 한다. 하지만 곧 보통의 휴지 전위 상태로 돌아온다.
데이터를 받아보면 'time, signal, open_channels' 딱 3개의 변수만 주어져있다. 이중 open_channels 가 우리가 예측해야할 타겟 변수이다. time 은 말 그대로 시간이고, 총 10개의 실험데이터가 1개 실험당 50초, 0.001초 단위로 나누어져 있다. 총 데이터 행 수는 5000000행이다. time 데이터는 순서대로 0.001초 단위로 주어지지만, 각 10개의 실험은 독립적으로 실행된 것이라고 주최측은 밝힌 바 있다. signal 은 이 0.001초 단위로 기록된 세포의 전위 상태를 의미하고, open_channels는 그때 측정된 열려있는 이온 통로의 갯수이다. 아무래도 signal의 값이 커질수록 세포가 더 강한? 많은? 자극을 받았다는 의미이고, 더 많은 이온 통로가 열려서 양이온들이 많이 세포로 들어갔기 때문에 이런 값이 관측되었을 것이다. 다만, 막상 시각화를 해 보면 아주 정확하게 딱딱 나눠지지는 않는다.
측정 공식은 'F1-macro' 방식이다.
일단 현재 랭킹은 768팀 중에 411등이다. 역시 사람들 개 잘한다. LightGBM을 쓰는 사람도 있고 CNN, U-Net 다른 딥러닝 모델들도 쓰이고 있... 는 것 같다. 한번 열심히 해봐야지.
타이타닉 대회를 마무리하고, 다음으로 도전해볼 만한 캐글 컴퍼티션이 뭐가 있을까 찾아보다가 이 집값을 예측하는 대회를 찾았다. 오호, 집값을 예측한다고? 나도 그럼 부동산으로 돈 한번 땡겨 볼 수 있을까? 하는 생각에 신나게 대회 참가 버튼을 눌렀다.
타이타닉보다는 훨씬 데이터도 많고, (하지만 여전히 적음) 다루기도 어렵다. 그리고 타이타닉과 같은 'Classification', 분류 문제가 아니라 'Regression' 회귀 문제이다. Regression 문제는 정답이 어떤 실수 형태로 주어져서, 이 값을 예측하는 문제이다. 반면 Classification 문제는 타이타닉처럼 데이터가 어떤 종류인가 (생존인가, 사망인가) 를 맞추는 문제이다. 그럼 생존 확률을 맞추라그러는거는 뭐냐? 여기서 LogisticRegression 을 처음 들어본 사람은 멘붕이 온다. LogisticRegression은 이름에는 Regression 이라고 되어 있지만, 사실은 Classification 문제에 사용한다. 쉽게 생각하면, 이 LogisticRegression은 해당 클래스의 확률 값을 찾는 Regression이어서 이름에는 Regression 이 들어가지만, Classification 문제에 사용된다고 생각하면 된다. Classification 이어도, 문제에 따라서는 확률 값을 제출하기를 요구하는 문제들도 있다.
1. 데이터 로드 (Load Data & Packages)
import pandas as pd
import numpy as np
from scipy.stats import norm
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns
import warnings; warnings.simplefilter('ignore')
마찬가지로 데이터를 불러와준다. 주피터 노트북 파일과 저 csv 파일들이 같은 폴더 안에 있을때 잘 작동한다. 여기서는 data 라는 변수에 train을 다시 저장했는데, 데이터를 보면 변수가 매우 많고, 손을 많이 댈 예정이라서 꼬일 수도 있기 때문에 data 라는 변수를 새로 만들었다.
print 문의 결과를 보자면
(1460, 80) (1459, 79) (1459, 1) 이라고 출력될 것이다.
총 1460 행의 train 데이터를 가지고 1459 행의 test 데이터의 집값을 예측해야 한다. 이때 변수는 79개... 로 꽤나 많이 주어진다. 손이 많이 갈 것이다.
2. 데이터 분석하기
2.1. 타겟 변수 확인 (Distribution of Target)
이번 대회는 Regression 문제인 만큼 더더욱 타겟 변수의 분포를 확인해야 할 필요성이 생겼다. 코드를 보면,
좌 : 타겟 변수의 분포, 우 : 타겟변수에 로그를 취한 분포. 우측이 더 정규분포에 가깝게 보인다.
왼쪽 그래프를 대충 보아도 약 400000 정도 값이 중심인 것을 알 수 있다. 하지만 많은 데이터가 400000보다 왼쪽으로 치우쳐 있는데, 이렇게 데이터의 분포가 비대칭인 정도를 'Skewness' 라고 한다. 한국어로 번역하면 '왜도' 라고 한다. 이 Skewness의 꼬리가 오른쪽으로 길게 있으면 'Right Skewed' 또는 'Positive Skewed', 왼쪽으로 길게 있으면 'Left Skewed' 또는 'Negative Skewed' 라고 한다. 오른쪽이든 왼쪽이든 심한 비대칭은 머신러닝 알고리즘이 학습을 잘 하지 못하도록 방해하는 요소 중 하나이다. 대부분의 데이터가 왼쪽에 있다면, 오른쪽 꼬리 부분은 데이터가 적어서 학습이 잘 안될 가능성이 있다. 따라서 예측 결과물도 의심할 수 밖에 없다. 이런 상황에서 'Right Skewed' 를 해결하는 대표적인 방법이 바로 해당 변수에 로그를 취하는 것이다. 키야~ 로그에 취한다~
확실히 로그를 취하면 비대칭도가 줄어들고, 정규분포에 가깝게 데이터가 분포되어 있는 것을 확인할 수 있다. 우리는 이렇게, 머신러닝에게 로그를 취한 값을 타겟 변수로 주어서 예측하게끔 한 다음에, 마지막에 제출할 때만 지수 계산을 해서 제출하면 그만이다.
어떤 두 개의 변수 A와 B가 있을때, 변수 A 의 값이 커질때, 변수 B의 값도 커지면 이 둘은 양의 상관관계를 갖고 있다고 한다. 반대로, 변수 A의 값이 커질때, 변수 B의 값이 작아지면 이 둘은 음의 상관관계를 갖고 있다고 말한다. 그렇다면 상관관계가 0인 경우는? 그렇다. 변수 A가 어떻게 움직이든 변수 B에 별 영향이 없는 경우를 말한다. 이 상관관계를 측정하는 값을 '상관계수' 라고 말하고, 우리는 주로 '피어슨 상관계수' 를 이용해 상관계수를 분석한다. 이 그래프는 타겟 변수인 'SalePrice' 와 가장 큰 상관관계를 가진 40개의 변수를 표시하는 그래프이다. 그래프를 뜯어보면, 변수 'OverallQual' 이라는 변수가 상관계수 0.79로 타겟변수와 가장 큰 상관관계를 가지고 있는 것으로 나타났다. 전반적으로 OverallQual 이 증가하면, 집값도 증가한다고 볼 수 있다는 뜻이다.
sns.regplot(data['GrLivArea'], data['SalePrice'])
GrLivArea 와 SalePrice 의 관계를 표시한 그래프
두번째로 큰 상관계수를 가진 'GrLivArea' 의 그래프를 띄워보면 위와 같다. 전체적으로 'GrLivArea' 가 증가하면 집값도 증가한다는 것을 확인할 수 있다. 다만 눈에 약간 거슬리는 부분이 있는데, 오른쪽 아래에 점 두개이다. 저 점들의 분포는 그래프 상의 저 직선으로 표현이 가능한데, 오른쪽 아래에 있는 저 두 점들은 전혀 다른 결과를 보여주고 있다. 저런 데이터들을 '이상치' (Outlier)로 간주하고 삭제해주는 것도 머신러닝의 정확도를 높일 수 있는 방법 중 하나이다.
타겟 변수를 미리 Ytrain으로 빼서 저장하고 위에서 말한듯이 로그를 씌웠다. 로그를 씌우는데 +1 을 해주는 이유는 log0 의 값이 없기 때문이다. 공짜 집은 없겠지만 만약 Ytrain의 값중 하나가 0이라면..? log0은 마이너스 무한대로 커지기 때문에 +1씩 해주어서 이를 방지한다. 이를 'log1p' 라고 하기도 한다.
log1p 의 그래프
2.3. 전체 데이터에서 결측치 확인 (Check Missing Values)
이 데이터는 사실 상당히 깔끔하지만, 막상 꺼내어 보면 결측치가 참 많이 있다. 이는 캐글에서 데이터를 다운로드 받을 때 같이 딸려오는 'data description.txt' 파일을 읽어보면, 집에 해당 시설물이 없는 경우는 결측치로 처리되어 있음을 알 수 있다. 물론 중간에는 진짜 결측지도 있겠지만, 없는 경우가 더 많다. 따라서 결측치를 처리하는 방법이 매우 간단하다.
cols=list(all_data)
for col in list(all_data):
if (all_data[col].isnull().sum())==0:
cols.remove(col)
else:
pass
print(len(cols))
list(all_data) 를 사용하면 all_data 라는 데이터프레임의 열 이름을 리스트로 만들 수 있다. 다음 코드는 반복문을 통해서 all_data 에서 해당 열에 결측치가 없으면 리스트에서 그 열의 이름을 지운다. 그러면 남은 리스트에는 결측치가 있는 변수 이름만 남아있을 것이다. print 문으로 출력해보면 아래 코드에 있는 이름들이 나올 것이다.
for col in ('PoolQC', 'MiscFeature', 'Alley', 'Fence', 'FireplaceQu', 'GarageType', 'GarageFinish', 'GarageQual', 'GarageCond', 'BsmtQual', 'BsmtCond', 'BsmtExposure', 'BsmtFinType1', 'BsmtFinType2', 'MasVnrType', 'MSSubClass'):
all_data[col] = all_data[col].fillna('None')
for col in ('GarageYrBlt', 'GarageArea', 'GarageCars', 'BsmtFinSF1', 'BsmtFinSF2', 'BsmtUnfSF','TotalBsmtSF', 'BsmtFullBath', 'BsmtHalfBath', 'MasVnrArea','LotFrontage'):
all_data[col] = all_data[col].fillna(0)
for col in ('MSZoning', 'Electrical', 'KitchenQual', 'Exterior1st', 'Exterior2nd', 'SaleType', 'Functional', 'Utilities'):
all_data[col] = all_data[col].fillna(all_data[col].mode()[0])
print(f"Total count of missing values in all_data : {all_data.isnull().sum().sum()}")
첫번째, 집에 해당 시설물이 없는 경우 (범주형 변수), 이때는 결측치를 'None' 이라는 문자열로 채운다. (이 작은 따옴표 없는 None 과 문자열 'None' 은 다르다!)
두번째, 집에 해당 시설물이 없는 경우(수치형 변수), 이때는 결측치를 0으로 채운다. 차고면적=0 이면 차고 없음 이런식으로 생각할 수 있다.
세번째, 해당 시설물이 없다고 보기 힘든 경우에 있는 결측치, 이때는 결측치를 해당 열의 최빈값으로 채운다. 집에 외벽 시설이 없을리는 없고, 집이 판매가 되었는데 거래 타입이 정해지지 않을리는 없다.
지하실, 1층, 2층 면적을 모두 합한 '총 면적' 이란 변수를 추가로 만들었다. 오른쪽 아래에 있는 그래프가 나머지 3개를 합한 면적을 나타낸 그래프인데, 상당히 타겟변수를 잘 설명할 수 있다. 상관관계도 꽤 높아보인다. 이는 총 면적이 증가하면, 집값이 더 비싸진다고 볼 수 있다. 이들을 더해서 'TotalSF' 라는 이름으로 저장해야겠다.
욕실 갯수는 'FullBath' 와 'HalfBath', 그리고 지하에 있는지 여부, 총 4개 열로 이루어져있었는데, 이들을 모두 더해 하나로 만들어 보았다. FullBath 는 욕조 및 샤워 시설이 포함되어있는 욕실이고, HalfBath는 변기와 세면대 정도 있는 간단한 욕실을 말한다. 이름에 맞게 FullBath는 1개로 카운트하고, HalfBath 는 0.5개로 카운트해서 모두 더했더니 다음과 같은 그래프를 얻을 수 있었다.
욕실 수의 총합
이를 보면 욕실 수가 많을수록 더 집값이 비싸진다고 볼 수 있다. (더 큰 집일수록 욕실수가 많을 것이라 생각한다). 하지만 여기서 특이한 점이 하나 있는데, 욕실 갯수가 5개, 6개인 집들은 막대그래프 위의 검정 세로선이 보이지 않는다. 에 이게뭐지? 할 수도 있지만, 저 검정 선은 편차를 의미한다. 그렇다면 편차가 없다는것이 무슨뜻이지? 값이 다른 데이터가 두개만 있어도 편차가 발생할텐데? 화장실 갯수가 5개, 6개인 집은 각각 하나씩밖에 없다는 뜻으로 볼 수 있다. 이들은 역시 outlier 로 판단하고 지워도 상관이 없다.
건축 연도와 리모델링 연도의 평균을 구하는것이 무슨 의미가 있나 할 수도 있다. 하지만 아주 의미가 없지는 않다! 건축 연도가 오래 되었어도, 최근에 리모델링을 하면 이 값이 높게 나왔을 것이고, 건축 이후 리모델링을 하지 않았다면 이 값은 아주 낮게 나왔을 것이다. 따라서 이 값이 높은 집들은 '지어진지 얼마 되지 않은 신축 건물 + 최근에 리모델링까지함' 에 가깝고, 이 값이 낮은 집들은 '오래된 건물 + 리모델링도 안함' 에 가까울 것이다. 그리고 이는 집값에 유의미한 영향이 있다고 초록색 그래프를 보면 판단할 수 있다.
데이터 설명을 보면 나와있지만 'MSSubClass' 는 사실 숫자로 이루어진 데이터지만, 각각의 숫자가 의미를 갖고있는 범주형 변수이다. 그리고 판매 연, 월도 역시 연산 개념을 적용하는데는 무리가 있다. 그래서 이들을 문자열로 바꿔주자.
나는 사람들이 집을 볼때, 1층을 쭉 둘러보고 '괜찮네', 2층을 보고 '별로네', 지하층과 차고를 보고 '좋네' 이런식으로 판단할 거라고 생각했다. 이 평가의 기준 점수는 사람마다 약간 다르겠지만, 해당 시설물을 종합적으로 보고 판단하는 행위는 모두가 비슷할 것이라 생각했다. 나는 그래서 집의 시설물들을 묶어서 점수를 매기기로 했다.
범주형 변수가 상당히 많은 데이터셋이다. 범주형 변수를 다짜고짜 1, 2, 3, 4, ... 로 인코딩해주면 머신러닝이 오해할 소지가 충분하기 때문에 일단 모조리 원핫 인코딩을 한다.
non_numeric=all_data.select_dtypes(np.object)
def onehot(col_list):
global all_data
while len(col_list) !=0:
col=col_list.pop(0)
data_encoded=pd.get_dummies(all_data[col], prefix=col)
all_data=pd.merge(all_data, data_encoded, on='Id')
all_data=all_data.drop(columns=col)
print(all_data.shape)
onehot(list(non_numeric))
3.2. 수치형 변수 (Numeric Feature)
수치형 변수는 비대칭이 너무 심해지지 않게끔, Right Skewed 가 크게 되어있는 데이터들에만 로그를 씌워 적절히 변형시켜준다.
numeric=all_data.select_dtypes(np.number)
def log_transform(col_list):
transformed_col=[]
while len(col_list)!=0:
col=col_list.pop(0)
if all_data[col].skew() > 0.5:
all_data[col]=np.log(all_data[col]+1)
transformed_col.append(col)
else:
pass
print(f"{len(transformed_col)} features had been tranformed")
print(all_data.shape)
log_transform(list(numeric))
그럼 이제 데이터를 나누는 일만 남았다. all_data 항목을 test 데이터의 갯수에 맞게끔 잘라서 따로 저장하면 된다.
원래 train 데이터의 갯수와 데이터를 가공한 Xtrain 데이터의 갯수가 1458 개로 동일하다. (위에서 'GrLivArea' 할 때 train 에서 두개를 지웠었다!)
4. 머신러닝 모델로 학습
from sklearn.linear_model import ElasticNet, Lasso
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import RobustScaler
from xgboost import XGBRegressor
import time
import optuna
from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_squared_error
머신러닝에 입문하는 사람들이라면 누구나 들어봤을, 모두가 머신러닝 입문용으로 시작하는 바로 '그' 경진대회이다. 그 이름은 타이타닉. 나도 타이타닉으로 머신러닝에 입문했었다. 지금은 약 1년 몇 개월 전의 일이네. 내가 지금까지 참가한 대회 중에서 가장 성적이 높은 대회이기도 하다...(눈물 주르륵 광광)
정확도 약 82.2% 라는 뜻이다
데이콘이라는 사이트에서도 타이타닉 컴퍼티션이 있다. 참고로 캐글에서 0.82296의 점수는 (2020년 3월 4일 기준) 16000여 명 중에서 471등을 기록하고 있다. 캐글의 타이타닉 대회에서는 점수 측정공식이 '정확도' 인 반면, 데이콘에서는 'RMSE' 를 사용한다. RMSE를 사용한다면, 아무래도 데이터를 사망 여부 (사망시 0, 생존시 1) 로 딱딱 떨어지게 예측하기보다는, 생존 확률 (0.6인경우, 60퍼센트의 확률로 생존 가능성) 로 결과물을 제출하는 것이 더 낫기 때문에, 코드의 마지막 줄만 바꾸어서 데이콘에 제출했더니 3위이다.
1등과 점수차이가 좀 나긴 하지만, 그래도 3등이다!
뭐 이런 튜토리얼성 경진대회 잘한다고 실력이 좋은, 뛰어난 데이터 사이언티스트의 싹이 보인다는 뜻은 당연히... 맞을 수도 있지만 아닐 가능성도 있다. 그래도 입문하면서 점수가 잘 나오면, 기분이 매우 좋다! 나는 처음 캐글을 시작하면서 랭킹이 바로바로 업데이트 되는 것을 보고 아주 환장을 하고 죽기살기로 덤볐었다. 랭킹 몇 등 올리는것이 당시 나에게는 세상 그 무엇보다도 재미있는 일이었다.
아무튼, 나는 이 코드를 이미 캐글에 수백 번 제출했었고, 내가 하는 스터디에서도 발표했었고, 캐글 노트북(캐글 커널) 에도 업로드를 했었고, 아주 수도 없이 우려먹었었지만, 이제 마지막으로 우려먹으려고 한다. 이 블로그에 나의 머신러닝에 관한 모든 기록을 담아서 보관할 예정이라서, 여기에도 업로드를 하려고 한다.
아마 구글 검색해서 나오는 코드들중에서는 내 코드가 가장 쉬울 거라고 생각한다.... 아무리 봐도 내 코드는 너무 쉬워보인다..
머신러닝에 입문하는 사람들에게 약간이나마 도움이 되었으면 합니다.
지식은 고여있으면 썩는 법이니까.
21.02. - 처음에는 리더보드가 test 일부만 가지고 채점되어서 0.82296이었는데, 현재는 test 전체를 이용해서 채점하기 때문에 점수가 바뀌었습니다. 0.79186이네요. 데이콘에서도 지금은 RMSE를 사용하지 않습니다!
1. 패키지 로드
import pandas as pd
import numpy as np
%matplotlib inline
import seaborn as sns
import matplotlib.pyplot as plt
from scipy.stats import norm
간단히 설명을 하자면
pandas : 데이터 (주로 행렬 데이터) 를 분석하는데 쓰이는 파이썬 패키지. 특히 표 데이터를 다룰때 거의 무조건 사용한다.
numpy : 선형대수 연산 파이썬 패키지. 그냥 수학 계산을 편하고 빠르게 할 수 있는 패키지라고 생각하면 쉽다.
%matplotlib.inline : 그래프를 주피터 노트북 화면상에 바로 띄울 수 있게 하는 코드. 근데 없어도 seaborn 그래프 잘만 되더라.
seaborn : 쉽고 직관적인 방법으로 그래프를 띄울 수 있는 패키지.
matplotlib.pyplot : matplotlib 라는 그래프 띄우는 패키지 중 일부. 나는 여러개의 그래프를 한 결과로 띄우고 싶을때만 주로 사용한다.
norm : 정규분포를 의미. 데이터의 분포 그래프를 띄울때, 이 norm 을 불러와주면 정규분포랑 손쉽게 비교해 볼 수 있다.
train.csv, test.csv, submission.csv 이 세 파일이 지금 작업하고있는 주피터 노트북과 같은 폴더 안에 있을 때 작동한다. 만약 다른 폴더에 있다면, '/Users/뭐시기/뭐시기/Desktop/train.csv' 처럼 경로를 지정해준다면 잘 열릴 것이다.
pd(판다스) 의 'read_csv' 라는 메소드를 이용해서 csv 파일을 쉽게 읽어올 수 있다. 'index_col' 은 해당 열을 (여기서는 승객번호) 인덱스로 사용할 수 있게끔 해준다. 이후에 데이터를 보면 알겠지만, 승객번호는 1번, 2번, 3번, .... 800몇번 이런식으로 쭉 증가하는 고유한 값이기 때문에 나는 이 열을 인덱스로 사용했다.
마지막 print 문을 실행하면 결과는 아마
(891, 11) (418, 10) (418, 1)
이라고 출력이 될 것이다. 이 괄호 안의 숫자들이 우리가 읽어온 데이터 행렬의 크기를 나타낸다. 표시되는건, (행 숫자, 열 숫자) 로 출력이 된다. 우리는 train.csv 에 있는 891명의 승객 데이터를 가지고, test.csv 에 있는 418명의 생존 여부를 예측해서 제출해야 한다는 의미이다.
3. 데이터 분석 시작
이제 남은 일은 내 입맛대로 데이터를 분석하고 요리하면 되는 것이다. 내가 행렬 데이터를 보면 항상 하는 순서가 있는데, 그 순서대로 해보겠다.
이렇게 데이터의 열에 '이름' 이 붙어있다면, 데이터를 분석할 때 상식적인 선에서의 '가설' 을 세우고 접근하는 방법이 있다. 예를 들면, 여성이 남성보다 생존 확률이 높을 것이다. 어린이들은 생존 확률이 높을 것이다. 라는 등의 가설을 세울 수 있겠다. 이는 경우에 따라서는 상당히 좋은 방법이다. 일반적인, 그니까 상식적인 수준에서 가설을 세울 수 있다면 데이터 분석 과정을 상당히 빠르게 해낼 수 있다. 다만, 데이터가 '익명화' 되어서 데이터 열에 이름이 없는 경우, 가설을 세우기가 상당히 어려워진다. 또한, 해당 분야의 배경지식이 필요한 전문 분야의 데이터일수록 가설 세우기는 더더욱 어렵게 된다. 전문 지식이 있으면 좀 낫겠지만. 하지만 1년 몇개월 간의 짧은 경험 상으로는 없다고 해서 크게 문제되지는 않았다. '컴퍼티션 진행하는데 배경 지식이 있으면 훨씬 쉬웠겠지만, 없어도 지장은 없다.' 정도의 느낌을 받았다.
3.1. 타겟 변수 확인
먼저 우리가 예측해야하는 '생존 여부' 가 어떻게 이루어져 있는지 보자. 생존 여부는 train 데이터에만 있고 test 에는 없다. 우리는 train 데이터에서 주어진 승객들의 정보와 그들의 생존 여부를 머신러닝에게 학습하도록 하고, test 데이터에 존재하는 승객들의 생존 여부를 맞출 것이다. 이렇게 우리가 맞춰야 하는 데이터를 타겟 변수(target variable), 혹은 종속 변수 라고 부른다. 나는 거의 타겟 변수라고 많이 부른다.
아마 이런 결과물이 나올 것이다. 0이 사망자, 1이 생존자를 의미한다. 그래프를 보면 사망자의 수가 생존자의 수보다 더 많은 것을 알 수 있다.
데이터별로 이런 타겟 변수가 한쪽의 값만 지나치게 많은 경우, 우리는 이를 'Class imbalanced problem' 이라고 부른다. 카드 사기 거래 여부, 하늘에서 운석이 떨어지는 경우를 예를 들어 보면 사기가 아닌경우, 운석이 떨어지지 않을 경우가 반대의 경우보다 그 수가 압도적으로 많다. 이때 별다른 처리 없이 머신러닝에게 데이터를 학습시킨다면, 머신러닝이 모든 데이터를 0(사망, 혹은 정상거래, 혹은 운석 안떨어짐) 이라고 예측할지도 모른다. 그리고 이 정확도를 보면, 상당히 높게 나온다. 실제로 우리가 예측하려는 데이터에도 운석이 떨어지는 날은 몇일 되지 않을 것이니까. 하지만 이 녀석은 참으로 의미없는 머신러닝 모델이 될 것이다. 실제로 우리나라 일기예보도 '365일 비 안옴' 이라고 예측하면 정확도가 75% 정도 된다고 하지만, 이것이 의미있는 예측은 아니지 않은가. 이럴때는 여러 방법들을 통해 이 불균형을 해결한 후 머신러닝 알고리즘으로 학습을 시켜야 의미있는 예측을 하는 경우가 대부분이다. 그리고 타이타닉 데이터에 있는 이 불균형정도면, 상당히 양호한 편이라고 할 수 있다.
참고로, 모든 승객을 사망 이라고 처리하고 제출해도 캐글 정확도는 약 60% 가 넘게 나온다.
결측치는 말 그대로 측정하지 못한 값이다. 'Age' 와 'Cabin' 열에서 결측치가 특히 많이 발생한 것을 볼 수 있다. 생각해보면 결측치는 '없는 데이터' 이기 때문에, 머신러닝이 여기서 배울 수 있는것은 전혀 없다. 그리고 사용하는 머신러닝 알고리즘에 따라서 데이터에 결측치가 있는 경우 에러가 날 수도 있다. 결측치를 처리하는 방법으로는, 결측치가 있는 데이터를 지워버리는 방법도 있고, 주변값 또는 대표값으로 결측치를 채워 넣는 방법도 있다. 나는 일단 Cabin 을 먼저 지워버려야겠다.
train 데이터와 test 데이터에 성별 데이터를 '인코딩' 해 준다. 머신러닝 알고리즘은 기본적으로 문자를 인식하지 못한다. 'male' 이라고 써있으면, 사람이야 바로 아 남성~ 하지만 머신러닝 알고리즘이 이걸 어떻게 알아듣겠는가? 그래서 이런 데이터를 0, 1 같은 숫자로 바꿔주는 일을 '인코딩' 이라고 한다.
첫 줄의 코드를 말로 설명하자면, "train 에서 [ train 데이터의 [성별] 이 'male' 인 사람의, '성별' 칸에는] = 0 이라고 입력해라." 정도로 해석할 수 있다. 밑에 줄들도 마찬가지.
이제 다음 칸에 "train['Sex']" 라고 쳐보면, 남성은 0, 여성은 1 로 데이터가 바뀌어있는것을 볼 수 있다.
보면, 1등석일수록 생존 확률이 높고, 3등석에는 사망률이 높아진다는 것을 알 수 있다. 역시 돈이 최고다. 아무튼 3등석보다 2등석이, 2등석보다 1등석이 생존 확률이 더 높다는 것은 머신러닝에게 좋은 정보로 작용할 것이다. 그럼 이 정보도 역시 인코딩 해주어야한다. 어? 근데 데이터가 1, 2, 3 숫자네? 아싸 개꿀~ 하려고 하는데 근데 여기서 문제가 생긴다.
기존 0과 1에서는 생기지 않았던 문제인데, 생각해보면 (1등석) + (2등석) = (3등석) 이 성립하는가?
(2등석) ^ 2 = (1등석) + (3등석) 이것도 성립하나? 개념상으로는 맞지 않다는것을 바로 알 수 있다. 이런 형태의 데이터를 '범주형 변수', 영어로 'categorical feature' 이라고 한다. 이렇게 숫자로 넣어주면 머신러닝 알고리즘은 딱 오해하기 좋다. 혹시나 수학 계산 과정이 필요한 알고리즘이라면, 위와 같은 오해를 하기 정말 좋은 상황이다. 이럴때 필요한게 바로 '원-핫 인코딩(one-hot encoding)' 이다.
이런 상황에서 원래대로 인코딩을 한다면, 데이터는 1개의 열에 모두 저장되어서 다음과 같이 표시될 것이다.
객실등급 : 1, 3, 2, 3, ....
하지만 원-핫 인코딩은 여러 개의 열을 추가한다. 이런 데이터에서 예를 들어보면,
객실 1등급 여부 : True, False, False, False, ...
객실 2등급 여부 : False, False, True, False, ...
객실 3등급 여부 : False, True, False, True, ...
이런식으로 인코딩을 진행한다. 이렇게 되면, 이 열들을 어떻게 더하고 곱하고 지지고 볶아도 중복이 나오지 않는다! 하지만 이 원핫 인코딩의 치명적인 단점은, 처리해야할 변수의 갯수가 아주아주 많아진다는 것이다. (그럴 일은 없겠지만) 만약에 객실이 60개 등급으로 이루어졌다면.... 총 60개의 변수가 생긴다. 이는 Tree 기반의 머신러닝 알고리즘에서 그닥 좋은 영향은 주지 못한다. 때에 따라서 원핫 인코딩할 변수가 너무 많다면, 그냥 1, 2, 3, ... 으로 인코딩 하기도 한다. (머신러닝 라이브러리 sklearn 에서는 이를 'LabelEncoder' 로 구현해두었다.) 상황에 따라 적절한 대처가 필요하다.
코드를 말로 해석해보자면 "train 데이터에 있는 ['Pclass_3'] 이라는 열에 (없으면 만들고) train 데이터의 ['Pclass'] 열의 값이 3인 애들은 True, 아니면 False 로 입력해줘라" 라는 뜻이다. 밑에 줄도 마찬가지로 해석할 수 있다. 이렇게 되면 위에서 언급한 대로 원-핫 인코딩을 할 수 있다. 원-핫 인코딩을 완료했으니, 더이상 필요가 없어진 원래의 'Pclass' 열은 삭제하도록 하자.
못보던게 하나가 등장했는데 'fit_reg' 이다. 이 lmplot(엘 엠 플랏) 은 이런 점찍혀있는 그래프와, 점들을 대표하는 하나의 직선이 있는 그래프인데, 나는 점만 보고 싶어서 선을 없앴다. 이 선을 없애는 명령이 'fit_reg=False' 이다. 선 궁금하면 한번 'fit_reg=True' 라고 해봐도 된다.여기서만 볼때는 딱히 유의미하다고 판단하기가 어렵다. 그래프를 확대해보자.
train, test 각 데이터의 SibSp, Parch 를 더하고 1을 더해서 'FamilySize' 라는 이름의 변수를 추가로 만들었다. 여기서 보면 알 수 있는 사실은, FamilySize 가 2 ~ 4 인 경우에는 생존률이 더 높았다는 사실을 알 수 있다. 핵가족의 전형적인 인원수이다. 이들은 빠르게 뭉쳐서 다같이 빠른 판단을 해서 생존률이 높은 것일까? 가설의 진실은 알 수 없지만, 이들 데이터가 가진 사실은 알 수 있다. 이들은 생존률이 높았다는 것이다.
영어 이름에는 성별 정보가 포함되어 있다. 이는 이름을 가지고도 생존 여부를 어느정도 예측할 수 있다고 볼 수도 있다. 또한 한 가족은 한 성씨(Last Name)를 따르니까, 위에서 말한 FamilySize를 남겨놓고 (LastName + FamilySize) 를 만들어서 일종의 FamilyID 를 만들 수도 있을 것이다. 예를들면, Johnson5 이런식이다. Johnson 성을 가진 5명 일행. 아마 일행중 한명이 사망했다면, 다른 구성원들도 사망했을지도 모른다. 이런식의 가설 세우기도 충분히 가능하지만, 난 귀찮으니 안하겠다. 해보고싶으면 한번 해봐도 좋을 것이다. 절대 내가 귀찮아서 그런게 아니다.
Mr 은 남자의 호칭이다. Ms, Mrs 는 여자의 호칭이다. 이는 위에서 보았던 성별 차이에 따른 생존률의 차이와 일맥상통한다. 하지만 여기서 특이한점은 'Master' 호칭의 사람들도 생존 숫자가 더 많았다는 것이다. 나중에 알게 되었는데, 이 'Master' 가 옛날 영어에서 어린 남자들을 지칭하는 호칭이란다. 카더라. 아무튼 우리가 알 수 있는 정보는, Master 호칭을 가진 남자들은 생존률이 더 높다는 것을 의미한다.
train과 test 에서 'Master' 여부 True or False 를 구분하는 변수를 만들고, 나머지 이름 데이터를 삭제한다.
여기서 굳이 Ms, Mrs 를 따로 같이 뽑아주지 않았냐고 물어보신다면, 이미 얘네들은 여자이기 때문에, 머신러닝 알고리즘은 얘네들을 살 가능성이 높다고 판단할 것이라고 생각했다. 하지만 이 머신러닝은 남자들은 대부분 죽었다고 판단할 것이다. 우리가 데이터 분석을 하면서 정확도를 올릴 수 있는 방법은, 머신러닝이 죽었다고 판단할 남자들 중 살았을 확률이 높은 부분, 살았다고 판단했을 여자들이 죽었을 확률이 높은 부분을 찾아서 변수로 추가해주어야 정확도를 높일 수 있다. 여기서 Ms, Mrs 를 추가한다는것은 아무 의미 없이 변수만 늘리는 행위일 뿐이다. 위에서도 언급했듯이, 변수가 많아지면 결과에 좋은 영향을 끼치지 않을 가능성이 꽤 높다.
티켓은 티켓 번호를 의미한다. 그냥지우자. 귀찮다.
4. 머신러닝 모델 생성 및 학습
이제 머신러닝 모델을 만들고 학습시키고 데이터를 예측시키면 모든 과정이 끝이 난다.
머신러닝 모델은 sklearn(scikit-learn) 의 DecisionTree를 사용할 것이다.
우리가 맞춰야 할 '생존여부' 를 Ytrain 이라는 이름에 변수에 저장했고, 승객 정보를 담고있는 나머지 데이터 (train 데이터에서 Survived 를 제외한 나머지 열) 들을 Xtrain, Xtest 라는 변수에 담았다.
다시 말하지만, 이 Xtrain 안에 있는 승객 정보를 가지고 Ytrain (생존여부) 를 학습한다. 그리고 머신러닝이 본 적 없는 데이터인 Xtest 에 대해서도 Ypred(예상 생존여부) 를 예측하는 것이 우리의 목표이다.
저 print 문이 실행된다면 아마 이렇게 출력될 것이다 :
(891, 10) (891,) (418, 10)
이때 확인해야 할 것은, Xtrain 과 Ytrain의 행 수가 일치하는지, Xtrain 과 Xtest 의 열 수가 일치하는지를 확인해야 한다. 이게 안맞으면 안돌아간다. 위에 데이터 분석 과정에서 무언가 빼먹었다는 뜻이다. '.head()' 라는 메소드는 해당 데이터프레임 (여기서는 Xtrain) 의 첫 5개 줄(행) 을 보여준다.
데이터 분석하고 정리한 머신러닝에 들어갈 최종 결과물
model=DecisionTreeClassifier(max_depth=8, random_state=18)
# random_state is an arbitrary number.
model.fit(Xtrain, Ytrain)
predictions=model.predict(Xtest)
submission['Survived']=predictions
submission.to_csv('Result.csv')
submission.head()
model 은 머신러닝 모델인 DecisionTreeClassifier을 저장했다. 여기서는 깊이 8을 설정했다.
model.fit(Xtrain, Ytrain) : Xtrain 으로 Ytrain 을 학습해라.
model.predict(Xtest) : .fit() 이 끝난 이후에 실행할 수 있다. Xtest를 예측해라.
그러면 이제 submission 파일의 'Survived' 에다가 예측한 결과를 넣어서 '.to_csv' 로 저장할 수 있다. 저장된 파일은 주피터 노트북 파일과 같은 경로에 저장된다.
VAE로 이미지의 특성을 뽑아서, 이미지에 변형을 가하며 새로운 이미지를 생성할 수 있다. 웃지 않는 사진에 웃음을 추가한다던지, 선글라스를 씌운다던지 할 수 있다는 것을 할 수 있다.
또 다른 생성 모델은 'GAN'이다. Generative Adversarial Network, (생성적 적대 신경망)이라고 하는데, 처음 논문이 나왔을 때 아주 혁신적인 아이디어로 세간의 이목을 집중시켰다고 한다.
GAN은 생성자와 판별자, 두 개의 신경망으로 이루어진 신경망이다. 생성자와 판별자는 서로 경쟁하는 구도를 가지는데, 각각의 역할이 존재한다. 판별자는 이미지가 Input으로 들어오면 이 이미지가 원래 있던 이미지인지(target = 1), 아니면 새로 생성된 이미지인지 (target = 0)을 예측하는 역할을 한다. 생성자는 랜덤한 노이즈가 주어지면, 이를 이용해서 이미지를 생성하는 역할을 한다. 이렇게 생성된 이미지는 판별자에게 주어져서, 판별자는 이 이미지의 진위여부를 판단하게 된다. 이 두 모델은 서로 계속해서 학습하며 판별자는 더더욱 생성된 이미지를 잘 구분할 수 있게 되고, 생성자는 더더욱 판별자가 잘 구분할 수 없는 '진짜 같은' 이미지를 만들어내게 된다.
지금 들어도 예측 모델링만 하던 내가 이 아이디어를 듣고 와 정말 신기하다. 여기서 이렇게 할 수도 있구나 라는 생각을 했었다. 이번에는 camel numpy 파일을 이용해 직접 GAN을 만들어보고, 새로운 데이터를 생성해보자.
camel numpy 데이터는 구글의 'Quick, Draw!' 데이터셋의 일부이다. 이 데이터셋은 온라인 게임으로부터 수집되었는데, 유저가 그림을 그린 것을 신경망이 맞추는 게임이다. 이 결과물이 주제별로 묶어져 .npy 파일로 저장되어있다.
GAN의 원본 논문에서는 Convolution층 대신에 Fully-Connected 층을 사용했다고 한다. 하지만 그 이후로 합성곱 층이 판별자의 예측 성능을 크게 높여 준다고 밝혀진 이후로, 간단한 GAN 모델들도 합성곱 층을 사용하고 있다. 이러한 모델은 사실 DCGAN (Deep Convolution GAN)이라고 부르는 게 정확하지만, 합성곱 층이 너무나 많이 쓰이고 있어서 GAN이라고 해도 DCGAN의 의미를 포함하고 있다고 한다.
1. 패키지 및 데이터 로드
import pandas as pd
import numpy as np
import keras
import keras.backend as K
from keras.layers import Conv2D, Activation, Dropout, Flatten, Dense, BatchNormalization, Reshape, UpSampling2D, Input
from keras.models import Model
from keras.optimizers import RMSprop
from keras.preprocessing.image import array_to_img
import warnings ; warnings.filterwarnings('ignore')
import matplotlib.pyplot as plt
from tqdm import tqdm
책과 다른 게시물에서는 -1 ~ 1로 값을 맞춰주는데, 그냥 귀찮아서 0 ~ 1 로 맞추어주었다. 그렇다면, 마지막 단계, 생성자의 이미지 출력물을 0~1 사이로 맞춰주는 sigmoid를 사용해야겠다.
2. 판별자 만들기
disc_input = Input(shape=(28, 28, 1))
x = Conv2D(filters=64, kernel_size=5, strides=2, padding='same')(disc_input)
x = Activation('relu')(x)
x = Dropout(rate=0.4)(x)
x = Conv2D(filters = 64, kernel_size=5, strides=2, padding='same')(x)
x = Activation('relu')(x)
x = Dropout(rate=0.4)(x)
x = Conv2D(filters=128, kernel_size=5, strides=2, padding='same')(x)
x = Activation('relu')(x)
x = Dropout(rate=0.4)(x)
x = Conv2D(filters=128, kernel_size=5, strides=1, padding='same')(x)
x = Activation('relu')(x)
x = Dropout(rate=0.4)(x)
x = Flatten()(x)
disc_output = Dense(units=1, activation='sigmoid', kernel_initializer='he_normal')(x)
discriminator = Model(disc_input, disc_output)
discriminator.summary()
discriminator의 앞 4자 disc를 사용해서 판별자를 만들었다.
판별자를 만드는 코드를 간단히 설명하자면, 단순히 4번의 Convolution을 거쳐서, 해당 이미지가 참인지 거짓인지만을 판별한다. 마지막의 sigmoid 함수를 지나서 이 이미지가 진짜일 확률을 출력하게 된다.
판별자 모델 요약
3. 생성자 만들기
gen_dense_size=(7, 7, 64)
gen_input = Input(shape = (100, ))
x = Dense(units=np.prod(gen_dense_size))(gen_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Reshape(gen_dense_size)(x)
x = UpSampling2D()(x)
x = Conv2D(filters=128, kernel_size=5, padding='same', strides=1)(x)
x = BatchNormalization(momentum=0.9)(x)
x = Activation('relu')(x)
x = UpSampling2D()(x)
x = Conv2D(filters = 64, kernel_size=5, padding='same', strides=1)(x)
x = BatchNormalization(momentum=0.9)(x)
x = Activation('relu')(x)
x = Conv2D(filters=64, kernel_size=5, padding='same', strides=1)(x)
x = BatchNormalization(momentum=0.9)(x)
x = Activation('relu')(x)
x = Conv2D(filters=1, kernel_size=5, padding='same', strides=1)(x)
gen_output = Activation('sigmoid')(x)
generator = Model(gen_input, gen_output)
generator.summary()
gen_dense_size에 shape를 하나 주었는데, 이 값은 랜덤 노이즈로부터 처음 생성할 Raw 이미지의 사이즈이다. 이 Raw 이미지는 몇 번의 UpSampling2D와 Convolution2D 레이어를 거쳐서 원본 이미지와 같은 shape를 가진 이미지로 바뀐다. 여기서 Conv2DTranspose (전치 합성곱) 층 대신에 UpSampling2D를 사용했는데, 이 둘은 픽셀을 다루는 원리가 약간씩 다르다. Conv2D 같은 경우에는 합성곱 연산을 진행하기 전에 픽셀 사이에 0을 추가하는 반면, UpSampling2D는 각 행렬을 단순히 반복하여 이미지 사이즈를 두배로 만든다. Conv2DTranspose를 사용하면 이미지에 계단 모양이나 체크무늬 패턴을 만들어서 이미지 품질을 저하시킬 수 있다고 알려져 있지만, 뛰어난 GAN 논문에서 여전히 많이 사용된다. 따라서 두 방식을 모두 시도해보고 더 좋은 결과를 출력하는 방법을 사용하는 것이 바람직하다.
생성자의 코드를 확인해보자면, 100차원의 랜덤 노이즈를 7 * 7 * 64 사이즈의 이미지로 만들고, 이를 키우면서 진행된다. 이전 레이어에서 받은 이미지를 UpSampling 하여 두 배로 크기를 늘리고, Convolution을 진행하고, 다시 UpSampling 하고, Convolution 하고를 반복한다. 마지막에는 sigmoid 함수를 적용시켜서 출력 결과물이 원본 데이터와 같은 스케일 안에 있게끔 만든다. 내가 시작할 때 Xtrain 데이터를 0 ~ 1 사이의 값으로 만들었기 때문에 다른 코드들처럼 tanh를 사용하지 않고 sigmoid 함수를 사용하는 것이 맞다고 판단했다.
이제 생성자를 컴파일해줘야 하는데, 생성자에서 생성한 이미지를 판별자에 넣고 그 이미지의 참 거짓을 판별하도록 하는 모델을 만들어서 컴파일을 한다. 어차피 이렇게 모델을 새로 컴파일해도, 그 안에 있는 생성자도 같이 컴파일되므로, 추후에 생성자만 이용해서 이미지를 생성하는 것이 가능하다.
일반적으로 판별자가 더 강력해야, 생성자가 판별자의 학습을 따라가면서 점점 좋은 결과물을 생산해내기 때문에, 판별자의 learning rate의 절반으로 생성자를 컴파일해준다.
이때 헷갈리는 것 중 하나가, 'discriminator.trainable = False'인데, 이 코드가 있어야 생성자에서 생성된 데이터를 학습하는 과정에서 판별자의 가중치가 업데이트되지 않는다. 이 trainable 속성은 모델이 컴파일할 때 작동하는데, 설명하자면 아래와 같다.
1. 판별자를 컴파일할 때는 trainable=True로 되어있는 상태로 컴파일 진행.
2. 판별자를 컴파일한 이후 trainable=False로 설정해주어도 이미 컴파일된 판별자에는 적용되지 않음.
3. 새로 판별자를 컴파일한 모델을 만드는데, 이때는 아까 trainable=False로 해두었기 때문에 판별자의 가중치가 업데이트되지 않음. 하지만 기존에 판별자만 컴파일할 때 trainable=True 이므로, 판별자만 학습을 진행할 때는 가중치가 업데이트됨.
정도로 이해하면 된다. trainable 속성이 컴파일 시에 적용되는 건지를 모르고 있다가 이제야 알게 되었다.
요약하자면, 새로 만든 model 객체는, 100차원의 데이터를 받아서 생성자에 입력하고, 생성자가 출력한 이미지를 판별자에 넣어서 이 이미지의 진위여부를 판별자로 하여금 예측하도록 한다.
5. GAN 모델 훈련
GAN은 다른 것보다 훈련하는 아이디어가 핵심이다.
1. 원본 데이터에서 랜덤하게 데이터를 추출하여 판별자 학습. (target = 1)
2. 학습되지 않은 생성자가 랜덤 노이즈를 이용해서 생성한 이미지로 판별자 학습 (target = 0)
을 해주면서 판별자는 원본 이미지와 생성된 이미지의 차이를 구분하게 된다. 생성자가 잘 훈련이 되려면, 이 이미지가 판별자의 input으로 주어졌을 때, 판별자가 1을 뱉어내기 시작한다면 학습이 잘 진행되고 있다는 의미이다.
판별자 학습 함수에서는, 원본 데이터에서 배치 사이즈만큼 랜덤하게 뽑아와서 타겟 1 (진짜)를 주고 학습을 시키고, 생성자가 만들어낸 이미지에다가는 타겟 0 (가짜)를 주고 학습을 시킨다. 생성자를 훈련할 때 이 생성자는 점점 진짜 같은 이미지를 생성하게 되므로 이렇게 학습을 반복해주면 판별자는 원본 이미지와 만들어진 이미지를 더욱 잘 구분할 수 있게 된다.
학습은 다음과 같은 과정의 반복으로 이루어진다.
1. 판별자는 원본 이미지를 가져와서 1로, 생성된 이미지를 0으로 학습한다.
2. 생성자는 랜덤 노이즈로부터 이미지를 1이라고 지정하고 학습하며, 가중치를 업데이트한다.
3. 판별자는 다시 원본 이미지와 (업데이트된) 생성자가 생성한 이미지를 가지고 다시 원본 이미지와 생성된 이미지를 각각 1, 0으로 학습한다.
판별자는 원본과 생성 이미지를 정확히 구분하면 loss 가 낮아진다. 반면 생성자의 목표는 판별자의 loss를 높이는(원본과 생성이미지를 구분하지 못하도록)것이 목표이다. model 객체에서 표시되는 loss는, 생성된 이미지에 대한 판별자의 loss를 의미하므로, 학습이 잘 진행될수록 이 결과는 점점 높아질 것이다.
배치 사이즈 64로, 2000 에포크만큼 학습을 진행해보았다.
for epoch in tqdm(range(2000)):
train_discriminator(Xtrain, 64)
train_generator(64)
학습 초반학습 중반학습 후반
학습이 진행될수록 'model' 객체에 표시되는 loss 가 점차적으로 증가하고 있다. 다시 한번 요약하자면, 여기에 표시되는 loss는 새로 생성된 이미지에 대한 판별자의 loss이기 때문에, 점점 증가해야 한다.
VAE(Variational AutoEncoder)와 AE(AutoEncoder)는 구조상으로는 비슷하지만 의미적인(?) 측면에서 약간의 차이가 있다. 일반적인 오토인코더는 입력된 데이터를 저차원으로 최대한 잘 압축하는 방법에 그 초점이 맞춰져 있다면, VAE는 입력 데이터를 저차원으로 잘 압축시키고, 그 특성에 따라 새로운 데이터를 잘 생성해 내는 것에 초점이 더 맞춰져 있다.
AE의 문제라고 한다면, AE의 결과물은 잠재 공간의 한 포인트가 되므로, 잠재 공간이 연속적으로 만들어지지 않는다는 것이다. 만약 인코딩된 결과물 (2, -2)가 숫자 4의 이미지로 완벽하게 디코딩이 되더라도, 포인트 (2.1, -2.1) 이 4와 비슷한 이미지로 디코딩될 것이라는 보장은 그 어디에도 없다. 그럴 필요도 없고. 잠재 공간이 2차원이라면 이런 문제는 상당히 덜해지지만, 잠재 공간의 차원이 늘어날수록 이 문제는 더더욱 심해지게 된다.
VAE는 여기서 출발하는데, AE와 가장 직접적인 차이점은 VAE는 이미지를 잠재 공간의 한 점으로 직접 매핑시키는 것이 아니라, (그 포인트의 주변까지도 약간씩 포함 할 수 있도록) 그 점 주변의 다변수 정규 분포 함수에 매핑한다는 것이다. 이렇게 되면 인코딩 결과물 (2,-2)가 숫자 4의 이미지로 정확히 디코딩될 수 있다면, (2.1, -2.1) 역시 점 (2, -2)와 상당히 비슷한 위치에 있기 때문에 숫자 4와 상당히 비슷한 디코딩 결과를 낸다고 추론할 수 있다.
요약하자면, VAE의 인코더는 입력된 이미지를 잠재 공간의 (한 포인트를 중심으로 하는) 다변수 정규 분포로 만들게 된다. 이미지 1을 일반적인 오토인코더로 인코딩한 결과가 (1, 1)이라면, VAE는 이 이미지 1을 (1, 1)을 중심으로 하는 (다변수) 정규 분포 함수를 만든다. 따라서 디코더는 이 (1, 1) 근처의 점들은 정규분포에 따라서 이미지 1 일 '확률' 이 높다고 판단하고, 이미지 1과 비슷한 형태를 띠도록 디코딩을 학습할 가능성이 높다. 하지만 점 (1, 1)과 멀리 떨어진 점 (100, 100)에 대해서는 정규분포에 따라서 이미지 1일 '확률' 이 높지 않다고 판단하고, 디코딩 결과물이 이미지 1과 비슷해지지 않도록 학습할 것이다.
정규 분포를 정의하려면 두가지의 변수가 필요한데, 바로 평균과 분산이다. 따라서, 인코더는 입력된 이미지에 대하여, 평균과 분산, 두 가지 아웃풋을 낸다. 여기에다가 'epsilon' 항을 추가해서 정규 분포를 만드는데, epsilon 은 표준 정규분포에서 랜덤하게 샘플링 한 값이다. 이 epsilon의 역할은 '인코더가 만들어낸 다차원 정규분포에서 얼마나 떨어진 곳을 디코딩 시작 포인트로 잡을까'를 결정한다. 이 값이 결정되면 디코더는 인코더의 정확한 결과물 (인코더가 만들어낸 정규분포의 중심점) 이 아닌, 그 포인트 주변의 약간 떨어진 점으로부터 디코딩을 시작해야 하므로 한 번도 본 적 없는 포인트에 대해서 디코딩을 진행해야 한다. 하지만 그 시작점이 인코더의 정확한 결과물과 아주 크게 다르지는 않기 때문에 (epsilon도 정규분포를 따르므로, epsilon 값이 비정상적으로 큰 값이 나올 확률 매우 적다) 원본과 비슷한 결과물을 내야만 Loss 가 커지지 않을 것이다.
책을 천천히 다시 읽어보고 이해한 결과를 정리했다. 머릿속으로 3차원을 넘어가는 그림이 그려지지는 않아서, (그게 됐다면 난 이런거 쓰고 있지 않았겠지?) 그리고 고등학교 수포자 이과생인 전력이 있는 나이기 때문에 정확한 수학적 이해나, 확률론(?)적으로 깔끔하게 설명할 수는 없지만, 굳이 이해를 하자면 이렇게 될 것이다.
VAE에서는 잠재 공간의 차원 사이에는 어떤 상관관계가 없다고 가정하고 시작한다. 다시 말하면, 잠재 공간에서의 차원간의 상관계수는 0이고, 공분산 행렬은 계산할 필요가 없으며, 그러므로 인코더가 입력을 평균, 분산으로만 매핑할 수 있게끔 가정을 한다.
VAE를 만드는 일은 생각보다 간단한데, 일반적인 오토인코더를 만든 후, 인코더가 정규분포를 만들 수 있도록 수정, 손실 함수가 정규분포를 인식할 수 있도록 수정해주면 된다. 단어가 조금 이상하다.
대충 코드를 보자면 다음과 같다.
1. VAE 만들기
import pandas as pd
import numpy as np
import keras
from keras.layers import Input, Conv2D, Flatten, Dense, Conv2DTranspose, Reshape, Activation, LeakyReLU, Dropout, BatchNormalization, MaxPooling2D, Lambda
from keras.models import Model
from keras import backend as K
from keras.optimizers import Adam
from keras.utils import to_categorical
from sklearn.metrics import mean_squared_error as mse
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
인코더가 정규분포(에서 샘플링한 한 포인트) 를 내뱉도록 설계가 완료되었으면, 이제 손실 함수를 수정하면 된다. 기존의 AE에서는 픽셀 별로 값을 비교해서 구한 mean squared error 만 사용했다면, 여기서는 KL 발산(Kullback - Leibler Divergence, 쿨백 - 라이블러 발산)을 추가로 사용한다.
KL발산에 대한 설명을 간단히 요약하자면, 한 확률분포가 다른 확률분포와 얼마나 다른지를 측정하는 방법이라고 할 수 있다. VAE가 생성해낸 평균 mu, 분산 log_var인 정규분포가 표준 정규분포와 얼마나 다른지를 측정해야 하기 때문에, 손실 함수(loss_function) 에 KL발산 항을 추가한다. 이때 KL 발산을 계산하려면 다음과 같이 하면 된다.
모든 차원에서 잠재공간상의 정규분포가 mu = 0, log_var = 0 일 때 kl_loss는 최소가 된다. 이렇게 추가한 KL 발산 항은 네트워크가 샘플을 표준 정규분포에서 크게 벗어나게 인코딩할 때 큰 페널티를 가하게 된다.
optimizer=Adam(lr=0.0005)
r_loss_factor=1000 # This is a Hyperparameter
def vae_r_loss(y_true, y_pred): ## MSE
r_loss = K.mean(K.square(y_true-y_pred), axis=[1,2,3])
return r_loss_factor * r_loss
def vae_kl_loss(y_true, y_pred): ## KL-Divergence
kl_loss= -0.5 * K.sum(1+log_var - K.square(mu) - K.exp(log_var), axis=1)
return kl_loss
def vae_loss(y_true, y_pred):
r_loss=vae_r_loss(y_true, y_pred) #Loss of Decoder
kl_loss = vae_kl_loss(y_true, y_pred) #Loss of Encoder
return r_loss + kl_loss #Sum of these two
AutoEncoder.compile(optimizer=optimizer, loss= vae_loss, metrics=[vae_r_loss, vae_kl_loss])
새로 만들 VAE에서의 loss function은 여기서 정의한 'vae_loss' 함수를 이용한다. vae_loss 는 기존의 MSE 손실 함수와 KL 발산의 합으로 계산된다. MSE 손실 함수는 (원본 이미지 픽셀과 생성 이미지 픽셀을 비교하여) 디코더가 원본과 비슷한 이미지를 생성해내지 못할 시 더 큰 페널티를 주고, KL발산은 인코더가 표준 정규분포와 많이 다른 분포로 데이터를 인코딩할수록 더 큰 페널티를 주게 된다.
여기서는 또 'r_loss_factor' 이라는 것이 추가되었는데, 이는 mse에 곱해주는 가중치로 KL 발산 손실과 균형을 맞추는 용도이다. 이 'r_loss_factor'는 하이퍼파라미터로, VAE를 훈련할 때 튜닝을 잘해주어야 한다. 이 가중치가 너무 크면, KL발산(인코더의 Loss)이 역할을 제대로 못하게 되고, 너무 작으면 (디코더의 Loss에 대한 비중이 적어지기때문에) 생성된 이미지의 퀄리티가 좋지 않을 것이다.
세상에서 가장 간단한 오토인코더를 만들었었다. 이 오토인코더에 몇 개의 레이어를 추가해 성능을 조금 더 향상시켜보자.
원래 코드를 맥북에서 작성하는게 더 편해서, 간단한 딥러닝 모델 정도는 맥북으로 그냥 돌리고 마는데, 여기부터는 컴퓨터가 힘들어하기 시작해서 게이밍 노트북으로 옮겨서 실행했다. 역시 GPU는 짱짱이다.
그냥 뭐 설명을 적어놓을건 딱히 더 없으니 코드만 대충 약간 올려놔야겠다.
import pandas as pd
import numpy as np
import keras
from keras.layers import Input, Conv2D, Flatten, Dense, Conv2DTranspose, Reshape, Activation, LeakyReLU, Dropout, BatchNormalization, MaxPooling2D, Lambda
from keras.models import Model
from keras import backend as K
from keras.optimizers import Adam
from keras.utils import to_categorical
from sklearn.metrics import mean_squared_error as mse
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
오토인코더 학습을 반복문으로 10회 반복 학습시키고, 학습당 20 에포크를 준다. 시간 여유가 좀 있으니까 (+GPU를 사용하면 빠르니까) 총 200 에포크만큼 반복 학습을 시킨다. 이때 20 에포크당 Xtrain에서 랜덤하게 데이터 1개를 가져와서 결과물 이미지랑 비교한다.
얼추 그럴싸해보이는 이미지 복원 결과물5 모양이 학습이 힘든가보다. 여전히 3이랑 더 가까워보인다. 1처럼 단순한 형태는 쉽게 학습하는듯
총 200번의 에포크를 성공적으로 학습했다. 역시 딥러닝에는 GPU를 써야 정신건강에 도움이 되는 것 같다. 이제 VAE에 대해서 좀 더 알아봐야겠다.
예를 들면, 인코더는 숫자 2 라는 이미지를 받아서 이를 분석한 후 2차원 좌표평면에 있는 점 (1, 1)에 점을 찍는다. 숫자 2 이미지는 위에서 설명한 고차원 데이터이고, 결과물 표현 벡터는 점 (1, 1)에 해당한다. 이때 2차원 좌표평면을 잠재 공간(latent space)라고 한다. 디코더는 이제 (1, 1)이라는 점을 보고 숫자 2의 이미지를 생성해내는 신경망이다. 따라서 디코더는 잠재 공간의 어떤 점의 좌표가 주어진다면, 그 점에 해당하는 이미지를 생성할 수 있다. 예를 들어 (9, 8)이라는 좌표를 보고 숫자 7의 이미지를 생성하는 식이다. 오토인코더는 이러한 일련의 과정을 학습하며, 점차 이미지의 특성을 잡아내면서, 이미지를 재생성할 수 있는 능력을 갖게 된다. 인코더는 더욱 효과적으로 표현 벡터를 나타내는 방법을, 디코더는 표현 벡터로부터 이미지의 특징을 더해 원본과 비슷한 이미지를 생성하는 과정을 학습하게 된다.
1. 가장 간단한 오토인코더 만들기
1.1. 패키지 import
import pandas as pd
import numpy as np
import keras
from keras.layers import Input, Conv2D, Flatten, Dense, Conv2DTranspose, Reshape, Activation, LeakyReLU, Dropout, BatchNormalization, MaxPooling2D
from keras.models import Model
from keras import backend as K
from keras.optimizers import Adam
from keras.utils import to_categorical
from sklearn.metrics import mean_squared_error as mse
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
이번에는 손글씨로 이루어진 숫자 이미지 데이터셋 (MNIST) 를 사용한다. 이 데이터셋은 28 * 28 사이즈의 손글씨로 적힌 숫자를 포함하는 이미지이고, 데이터는 0 ~ 255의 픽셀 강도로 이루어져 있다. 일반적으로 신경망은 -1 ~ 1 사이의 값에서 가장 잘 동작하므로 255로 데이터를 나누어 주면 입력 데이터를 0 ~ 1로 맞춰줄 수 있다.
디코더 모델은 의외로 간단하게 만들 수 있다. 인코더 모델의 layer 들을 역순으로 해주면 쉽게 만들 수 있다.
이때 꼭 인코더 모델과 대칭(?)을 이루도록 만들지 않아도 된다는 점이 포인트이다. 인코더에서는 Convolution을 두 번 거쳤지만, Decoder에서는 한 번만 해도 된다는 뜻이다. 인코더에 입력으로 들어오는 데이터와 같은 차원, 같은 크기이기만 하면 어떤 구조를 가져도 상관없다.
여기서는 또 특이한 점 두가지 중 첫 번째는, Conv2DTranspose 가 들어가 있다. 이것은 일반적인 Conv2D의 역연산이라고 생각하면 쉽다. (Convolution 자체의 수학적 원리를 아직 모르기 때문에... 물어보지 마세요 엉엉)
두 번째는 마지막에 오는 활성화 함수인데, 'Sigmoid' (시그모이드 함수) 라 불린다. Logistic Regression에서 주로 봤었던 Sigmoid... 여기서는 Conv2 DTranspose의 결과물을 0 ~ 1 사이의 값으로 만들어주는 역할을 한다. 그럼 입력 데이터와 값의 스케일이 맞겠다. 단지 그뿐이다.
1.5. 인코더, 디코더 연결하기
입력 이미지는 인코더를 거쳐 -> 잠재 공간의 한 벡터로 변환될 것이고 -> 이 벡터는 디코더를 거쳐 -> 다시 원본 이미지를 만들어내게끔 학습할 것이다. 이제, 인코더와 디코더를 연결만 해주면 되는데, 케라스에서는 이 과정은 그냥 껌이다.
이렇게 만든 'AutoEncoder' 모델을 한번에 컴파일해도, 'model_encoder' 와 'model_decoder' 를 각각 사용할 수 있다.
2. 가장 간단한 오토인코더 학습 & 새로운 이미지 생성
이제 마찬가지로 모델을 컴파일하고, 학습을 시키면 된다.
#Compile AE Model
optimizer=Adam(lr=0.001)
AutoEncoder.compile(optimizer=optimizer, loss='mean_squared_error')
#Fit AE Model
AutoEncoder.fit(Xtrain, Xtrain, batch_size=10, shuffle=True, epochs=1)
시간이 없으니, 1회만 학습시켜보자.
여기서 내가 처음에 실수했던 게, 타겟 변수에다가 자기 자신을 넣지 않고, 원래 타겟 변수를 넣었다. 자기 자신의 이미지와, 새로 생성한 자기 자신의 이미지를 비교하는 것이기 때문에, 입력 : Xtrain, 타겟 : Xtrain 이 맞다. loss 하이퍼파라미터의 'mean_squared_error'는 각각의 픽셀에 대하여 오차를 계산한다. 생성된 이미지가 원본과 비슷한 숫자라면, 비슷한 위치의 값이 같이 올라갈 것이다.
위 코드를 실행하면 Xtrain(원본) 과, result(생성 이미지)의 첫 번째 값을 이미지 파일로 볼 수 있다.
대충 확인해보자면
원본 이미지와 새로 생성된 이미지 비교
원본은 딱 봐도 5이지만, 새로 생성한 이미지는 대충 보면 3같이 보인다. 억지로 보면 5로 이어서 볼 수는 있지만, 딱 봐도 5처럼 보여야 진짜 잘 생성한 이미지이니... 썩 좋은 결과는 아니지만, 그래도 모델이 돌아갔다는 것에 의의를 두자. Convolution과, 전결합층을 적절히 쌓고, 에포크를 충분히 주고 학습시키면 더 좋은 결과물을 얻을 수 있을지도 모른다.
처음에는 텐서플로우와 케라스가 뭔지도 몰랐다. "아니, 텐서플로우는 텐서플로우고, 케라스는 그럼 뭡니까? 왜 텐서플로우랑 같이 언급이 되는 거죠?"라고 묻던 게 불과 몇 주 전의 일이었다. 처음 딥러닝을 해봐야겠다 생각이 들었을 때는 텐서플로우 버전에 대한 개념이 없어서, 텐서플로우 2.0 버전을 깔고, 'tf.placeholder' 같은 코드를 따라 치다가 실행이 안 되기 시작하면서 때려치웠던 기억이 있다. (tf.placeholder... 코드는 TF 1.x 버전에서 주로 쓰던 코드라고 들었다. 지금은 쓰이지 않는다고...) 그래서 파이토치 코드를 따라 쳤는데, MNIST에서 돌아가는 데 성공했다. 단순히 실행에 성공했다는 이유로, 파이토치를 사용했었는데, 케라스를 조금 익히니까, 이거, 물건이다. 정말 간편하다. 케라스를 익힌 이유는, 이 책에서 예제 코드가 모두 케라스로 작성되어 있다... (만약 파이토치로 작성되어 있었다면, 케라스 같은 건 모르고 있었겠지.)
아무튼, 목표는 작곡하는 인공지능 만들기, 강화학습으로 핸드폰 게임 클리어하기이다. 나는 음악도 매우 좋아하는데, 신은 불행하게도 나에게 '보통 사람들보다 약간 좋은 음악적 감' 은 주셨지만, '작곡을 하며 음악을 즐길 수 있을 정도의 능력' 은 주시지 않으셨다. 대신 '코드를 읽고 쓰고 배우고 작성할 수 있는 능력' 은 주셨으니, 난 이걸로 음악을 즐겨야겠다.
