만년필잉크의 데이터 분석 지식 저장소

 이전 포스트까지 Wide & Deep Learning 모델을 사용해서 다중 입력 모델을 만들어보았다. 이번엔 이전 모델에 추가로 출력층을 추가하여 출력층을 2개로 만들어 보도록 하자.

다중 출력 모델

• 일반적으로 다중 출력 모델을 사용하는 이유는 다음과 같다.

1. 프로세스가 서로 독립적인 경우:
   동일한 데이터 셋에서 두 개 이상의 출력층을 생성하지만, 출력된 결과는 전혀 다른 작업을 위해 실행되는 경우로, 예를 들어 인터넷 사용 Log 데이터를 기반으로, 대상의 관심사 파악(분류 모델)과 인터넷 사용률 예측(회귀 모델)은 별개의 목적을 위해 진행된다.
2. 프로세스가 한 목적을 위해 상호 보완적으로 이루어지는 경우:
   하나의 목적을 이루기 위해 두 개 이상의 출력 값이 필요하여, 동일한 데이터 셋에서 두 개 이상의 출력층을 뽑아내는 경우로, 예를 들어 영상 속 물건을 인식하는 모델을 만든다면, 영상 속 물건의 위치(회귀 모델)와 물건의 종류(분류 모델)를 동시에 파악해야 한다.
3. 규제 도구로써의 다중 출력 모델:
   하위 네트워크가 나머지 네트워크에 의존하지 않고, 그 자체로 유용한 성능을 내는지 확인을 하기 위한 규제 기법으로 사용

 이번 포스트에서는 Wide & Deep Learning model에 다중 출력 모델을 규제 도구로써 사용해보도록 하자.

1. 규제 도구로써의 다중 출력 모델

• 보조 출력층(Auxiliary Output)을 통해, 하위 네트워크가 나머지 네트워크에 의존하지 않고 그 자체로 유용한 것을 학습하는지 확인한다. 위 모델대로라면, Deep model에서의 출력된 값이 Wide model과의 연결로 인해, 원하는 결과를 뽑아내는 것인지, Deep model으로 인해 그러한 결과가 나왔는지 확인할 수 있다.
• 이를 통해, 과대 적합을 감소시키고, 모델의 일반화 성능이 높이도록 학습에 제약을 가할 수 있다.

2. 모델 생성 이전까지의 코드 가져오기

• 이전 포스트에서 만들었던, 모델 이전까지의 코드를 모두 가지고 온다.
• 입력층이 2개일 때는 입력 데이터를 목적에 맞게 나눴어야 했지만, 이번엔 출력층이 다른 데이터를 출력하는 것이 아니라, 보조 출력층(Auxiliary Output)과 주 출력층(Main Output)이 동일한 정답에 대해 어느 정도의 손실 값과 정확도를 내보내는지 알고 싶은 것이므로, Label dataset을 나누지 않아도 된다.

#################################### Import Module ####################################
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import callbacks
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import (Input, Dense, concatenate)
########################################################################################





#################################### Import Dataset ####################################
# 캘리포니아 데이터 가져오기
Rawdict = fetch_california_housing()
CaliFornia_DF = pd.DataFrame(Rawdict.data, columns=Rawdict.feature_names)
########################################################################################




#################################### Data Handling #####################################
# 데이터를 쪼개기 좋게 변수의 순서를 바꾸자
CaliFornia_DF = CaliFornia_DF[["HouseAge", "Population", "Latitude", "Longitude", "MedInc",
                               "AveRooms", "AveBedrms", "AveOccup"]]

# train, validation, test set으로 쪼갠다.
X_train_all, X_test, y_train_all, y_test = train_test_split(CaliFornia_DF.values, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 정규화시킨다.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 데이터 셋을 input layer의 수만큼 쪼갠다.
X_train_A, X_train_B = X_train[:, :1], X_train[:,1:]
X_valid_A, X_valid_B = X_valid[:, :1], X_valid[:,1:]
X_test_A, X_test_B = X_test[:, :1], X_test[:,1:]
########################################################################################

3. 모델 생성

######################################## Model ########################################
input_A = Input(shape=[1], name = "deep_input")
input_B = Input(shape=[7], name = "wide_input")
hidden1 = Dense(30, activation="relu", name = "hidden1")(input_A)
hidden2 = Dense(30, activation="relu", name = "hidden2")(hidden1)
concat = concatenate([input_B, hidden2], name = "concat")
output = Dense(1, name="main_output")(concat)

# 보조 출력층 생성
aux_output = Dense(1, name="aux_output")(hidden2)
model = keras.Model(inputs=[input_A, input_B], outputs=[output, aux_output])
########################################################################################

>>> model.summary()
Model: "model"
__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
deep_input (InputLayer)         [(None, 1)]          0                                            
__________________________________________________________________________________________________
hidden1 (Dense)                 (None, 30)           60          deep_input[0][0]                 
__________________________________________________________________________________________________
wide_input (InputLayer)         [(None, 7)]          0                                            
__________________________________________________________________________________________________
hidden2 (Dense)                 (None, 30)           930         hidden1[0][0]                    
__________________________________________________________________________________________________
concat (Concatenate)            (None, 37)           0           wide_input[0][0]                 
                                                                 hidden2[0][0]                    
__________________________________________________________________________________________________
main_output (Dense)             (None, 1)            38          concat[0][0]                     
__________________________________________________________________________________________________
aux_output (Dense)              (None, 1)            31          hidden2[0][0]                    
==================================================================================================
Total params: 1,059
Trainable params: 1,059
Non-trainable params: 0
__________________________________________________________________________________________________

• 앞서 학습했던 방법처럼 보조 출력층 생성 역시 Keras API 함수로 구현하는 것은 꽤 단순하다.
• 보조 출력층(aux_output)과 데이터를 받는 층(hidden2)을 연결시키고, model에서 outputs을 2개 다 잡아주면 된다.

4. 모델 컴파일

• 다중 입력 모델과 달리 다중 출력 모델에서는 모델 컴파일 방법이 바뀌게 된다.
• 이는, 컴파일에서 출력층에서 모델을 평가하게 되는 손실 함수를 결정하기 때문이고, 이 손실 함수는 출력층마다 다르게 설정해야 하기 때문이다.

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = ["msle", "msle"],
              metrics=["accuracy"],
              loss_weights=[0.9, 0.1])

• 최적화나 모델 평가 지표는 출력층의 수와 상관없기 때문에 바뀌지 않는다.
• 손실 함수는 출력층이 2개가 되었으므로, 2개를 잡아줘야 한다(만약, 손실 함수를 하나만 잡아준다면, 모든 출력의 손실 함수가 같다고 가정한다 - 위 경우에는 출력층이 회귀모형이므로, msle로 같은 손실 함수를 사용하므로, msle 하나만 사용해도 된다).
• loss_weights: 출력 층별 손실 값의 가중치를 정해준다. 케라스는 기본적으로 출력된 손실 값들을 모두 더해 최종 손실을 구하며, 이를 기반으로 학습을 한다. 여기서 사용된 보조 출력은 규제로 사용되었기 때문에 주 출력이 더 중요하다. 그러므로, 주 손실 값에 더 많은 가중치를 부여하였다.

5. 모델 학습 및 평가

• 모델 학습과 평가에서의 차이는 Label 역시 각 출력층에 맞게 2개가 들어가야 한다는 것이다.
• 해당 다중 출력 모델은 규제 목적으로 보조 출력층을 추가한 것이므로, 동일한 데이터를 label로 사용해도 된다.

early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

# 학습
history = model.fit([X_train_A, X_train_B], [y_train, y_train],
                    epochs=300,
                    batch_size = 32,
                    validation_data=([X_valid_A, X_valid_B], [y_valid, y_valid]),
                    callbacks=[early_stop])

Epoch 1/300
362/362 [==============================] - 3s 6ms/step - loss: 0.2162 - main_output_loss: 0.1988 - aux_output_loss: 0.3726 - main_output_accuracy: 0.0027 - aux_output_accuracy: 0.0023 - val_loss: 0.0697 - val_main_output_loss: 0.0633 - val_aux_output_loss: 0.1276 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 2/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0650 - main_output_loss: 0.0584 - aux_output_loss: 0.1243 - main_output_accuracy: 0.0026 - aux_output_accuracy: 0.0026 - val_loss: 0.0619 - val_main_output_loss: 0.0544 - val_aux_output_loss: 0.1295 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 3/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0584 - main_output_loss: 0.0509 - aux_output_loss: 0.1260 - main_output_accuracy: 0.0027 - aux_output_accuracy: 0.0027 - val_loss: 0.0598 - val_main_output_loss: 0.0522 - val_aux_output_loss: 0.1279 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 4/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0555 - main_output_loss: 0.0480 - aux_output_loss: 0.1229 - main_output_accuracy: 0.0018 - aux_output_accuracy: 0.0018 - val_loss: 0.0591 - val_main_output_loss: 0.0514 - val_aux_output_loss: 0.1281 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048

...

Epoch 54/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0522 - main_output_loss: 0.0444 - aux_output_loss: 0.1227 - main_output_accuracy: 0.0024 - aux_output_accuracy: 0.0024 - val_loss: 0.0556 - val_main_output_loss: 0.0476 - val_aux_output_loss: 0.1276 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048
Epoch 55/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0524 - main_output_loss: 0.0446 - aux_output_loss: 0.1225 - main_output_accuracy: 0.0026 - aux_output_accuracy: 0.0026 - val_loss: 0.0540 - val_main_output_loss: 0.0460 - val_aux_output_loss: 0.1263 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048
Epoch 56/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0525 - main_output_loss: 0.0448 - aux_output_loss: 0.1215 - main_output_accuracy: 0.0024 - aux_output_accuracy: 0.0024 - val_loss: 0.0539 - val_main_output_loss: 0.0458 - val_aux_output_loss: 0.1265 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 57/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0535 - main_output_loss: 0.0457 - aux_output_loss: 0.1234 - main_output_accuracy: 0.0033 - aux_output_accuracy: 0.0033 - val_loss: 0.0543 - val_main_output_loss: 0.0463 - val_aux_output_loss: 0.1264 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048

>>> model.evaluate([X_test_A, X_test_B], [y_test, y_test])

194/194 [==============================] - 0s 1ms/step - loss: 0.0533 - main_output_loss: 0.0454 - aux_output_loss: 0.1241 - main_output_accuracy: 0.0029 - aux_output_accuracy: 0.0032
[0.05328081175684929,
 0.04541592299938202,
 0.12406466901302338,
 0.0029069767333567142,
 0.0032299740705639124]

• 이전과 달리 값이 굉장히 많이 나오기 때문에 이를 파악하기 어려울 수 있는데, 그 내용은 생각보다 상당히 단순하다.
• 손실 값은 loss: 0.0533, main_output_loss: 0.0454, aux_output_loss: 0.1241이 나왔다.
• 여기서 loss만 신경 쓰면 된다. 위에서 우리는 main_output_loss와 aus_output_loss의 가중치를 0.9, 0.1로 부여하였는데, loss는 각 손실 값에 해당하는 가중치를 곱하여 합한 값이기 때문이다.

$$ 0.0533 = 0.9*0.0454 + 0.1*0.1241 $$

• Deep model의 손실 값과 Wide & Deep Learning model의 손실 값을 동시에 반영하여, 총 손실 값을 계산하였으므로, Deep model이 Wide model과의 결합 없이도 우수한 성능을 보이는 것을 알 수 있다.
• 주 출력층의 Accuracy는 0.0029, 보조 출력층의 Accuracy도 0.0032로 Deep model, Wide & Deep Learning model 모두 Accuracy가 괜찮게 나왔다. 이로 인해 Deep model 자체만으로도 우수한 성능을 보이는 것을 알 수 있다.

5.1. 손실 값과 정확도를 시각화해보자.

def Drawing_Scalars(history_name):
    
    history_DF = pd.DataFrame(history_name.history)
    # 그래프의 크기와 선의 굵기를 설정해주었다.
    history_DF.plot(figsize=(12, 8), linewidth=3)

    # 교차선을 그린다.
    plt.grid(True)

    plt.legend(loc = "upper right", fontsize =15)

    plt.title("Learning Curve", fontsize=30, pad = 30)
    plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
    plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

    # 위 테두리 제거
    ax=plt.gca()
    ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
    ax.spines["top"].set_visible(False) # 위 테두리 제거
    
    plt.show()
    
    
Drawing_Scalars(history)

• 굉장히 많은 지표들이 추가되었지만, Early Stopping의 기준으로 사용한 val_loss를 본다면, patience가 30이었으므로, epochs 27에서 모델이 수렴하였다는 것을 알 수 있다.

[참고 자료]

 이번 포스트에서는 다중 출력 모델을 Wide & Deep Learning model에서의 규제 기법으로 사용해보았다. Deep model의 결괏값에 대한 평가가 모델 전체 평가에 반영되었으므로, Deep Model의 일반화가 잘 이루어진 모델이 만들어졌다고 할 수 있다. 

 지금까지 Wide & Deep Learning 모델을 기반으로 다중 입력, 다중 출력 모델을 만드는 방법과 이를 통해 Wide & Deep Learning Model을 더 잘 사용할 수 있도록 해보았다.

 이전 포스트에서는 Wide & Deep Learning 모델에 대한 간단한 설명과 함수형 API를 사용해서 기초적인 Wide & Deep Learning 모델을 만들어보았다. 이때는 완전히 동일한 Input 데이터를 바라보았으나, Wide & Deep Learning 모델은 다른 Input Layer를 만들어 Wide model과 Deep model에 따로 학습시킬 수 있다.

1. 다중 입력 Wide & Deep Learning

• Wide & Deep Learning model의 특징은 Wide model에 전달되는 Feature와 Deep model에 전달되는 Feature를 다르게 할 수 있다는 것이다.
• 즉, 입력되는 Feature에서 일부 특성은 Wide model로 나머지 특성은 Deep model로 전달할 수 있다.
  (각 모델로 전달되는 특성은 중복 가능하다).
• Deep model은 입력된 모든 데이터를 MLP에 있는 모든 층에 통과시키다 보니, 간단한 패턴이 연속된 변환으로 인해 왜곡될 위험이 있다.
• 때문에 Wide & Deep Learning model에서는 일반적으로 간단한 패턴이 있는 Column은 Wide model 쪽으로, 복잡한 패턴이 있는 Column은 Deep model 쪽으로 보낸다.
• 간단한 패턴이 있어 Wide model로 보낸 Column 역시 Deep model에서 숨겨진 패턴을 찾는데 도움이 될 수 있으므로, Wide model로 Input 될 데이터의 일부 혹은 전체를 Deep model에 같이 넣기도 한다.
• 이를 도식화해보면 다음과 같다.

• 위 모델을 보면 Input Layer가 2개 존재하는 것을 볼 수 있는데, 이처럼 한 번에 2개 이상의 Input이 존재하여 동시에 여러 입력을 하는 것을 다중 입력 모델이라 한다.
• 다중 입력 모델은 Keras의 함수형 API를 사용하면 쉽게 구현할 수 있다.

2. 데이터의 각 변수별 상세 정보 파악

• 이전 포스팅에서 해당 모델을 Input Layer 1개로 넣었을 때, 이미 Accuracy 0.0034, Loss 0.0242로 꽤 괜찮은 결과가 나왔었다. 굳이 데이터를 나눠서 넣을 필요는 없으나, Keras API를 이용해서 다중 입력하는 방법을 학습하기 위해, 데이터 셋을 쪼개 보도록 하겠다.
• 해당 포스트의 참고 논문(Heng-Tze Cheng et al.(2016))에서 예시로 든 단순한 패턴은 "설치한 앱"과 "열람한 앱"을  Cross-product transformation으로 생성한 희소 특징(Sparse feature)이다.
• 그러나, 해당 데이터셋에는 그 대상이 될 수 있는 범주형 데이터가 따로 없으므로, 데이터 패턴을 보는 가장 기초적인 방법인 히스토그램과 독립변수와 종속변수 간의 산점도(상관관계)를 만들어, 패턴이 아주 단순한 경우는 Wide model로, 그렇지 않은 경우는 Deep model로 넣어보겠다.

# Import Module
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import callbacks
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import (Input, Dense, Concatenate, concatenate)

2.1. 데이터 셋 정보 보기

• sklearn에서 기본으로 제공하는 데이터에서는 아주 쉽게 메타 정보를 볼 수 있다.

>>> Rawdict = fetch_california_housing()
>>> print(Rawdict.DESCR)
.. _california_housing_dataset:

California Housing dataset
--------------------------

**Data Set Characteristics:**

    :Number of Instances: 20640

    :Number of Attributes: 8 numeric, predictive attributes and the target

    :Attribute Information:
        - MedInc        median income in block
        - HouseAge      median house age in block
        - AveRooms      average number of rooms
        - AveBedrms     average number of bedrooms
        - Population    block population
        - AveOccup      average house occupancy
        - Latitude      house block latitude
        - Longitude     house block longitude

    :Missing Attribute Values: None

This dataset was obtained from the StatLib repository.
http://lib.stat.cmu.edu/datasets/

The target variable is the median house value for California districts.

This dataset was derived from the 1990 U.S. census, using one row per census
block group. A block group is the smallest geographical unit for which the U.S.
Census Bureau publishes sample data (a block group typically has a population
of 600 to 3,000 people).

It can be downloaded/loaded using the
:func:`sklearn.datasets.fetch_california_housing` function.

.. topic:: References

    - Pace, R. Kelley and Ronald Barry, Sparse Spatial Autoregressions,
      Statistics and Probability Letters, 33 (1997) 291-297

• 캘리포니아 주택 데이터 셋의 각 Row인 객체는 블록이다.
• MedInc: 소득의 중앙값
• HouseAge: 건물 연령 중앙값
• AveRooms: 평균 객실 수
• AveBedrms: 평균 침실 수
• Population: 인구수
• AveOccup: 평균 주택 점유율
• Latitude: 위도
• Longitude: 경도
• 종속변수(Target): MedHouseVal: 캘리포니아 지역의 주택 가격 중앙값

2.1. 변수별 히스토그램 보기

# 독립변수의 히스토그램 그리기
CaliFornia_DF = pd.DataFrame(Rawdict.data, columns=Rawdict.feature_names)
CaliFornia_DF.hist(figsize=(12,8), linewidth=3)
plt.show()

# 종속변수 히스토그램 그리기
plt.hist(Rawdict.target)
plt.show()

2.2 변수별 종속변수와의 산점도

fig, axes = plt.subplots(nrows=4, ncols=2, figsize = (12, 20))
ax = axes.ravel()

xlabels = Rawdict.feature_names
plt.suptitle("Predict Variable & MedHouseVal Scatter", y=0.93, fontsize=25)

for i in range(Rawdict.data.shape[1]):

    X = Rawdict.data[:,i]
    Y = Rawdict.target

    ax[i].scatter(X, Y, alpha = 0.025)
    ax[i].set_title(xlabels[i], fontsize=15, fontweight ="bold")

• Row가 20,640으로 단순하게 산점도로 그리기엔 그 양이 너무 많아, alpha를 0.025로 주어, 데이터가 동일한 위치에 많이 존재하지 않는다면 연하게, 많이 겹칠수록 진하게 그려지도록 설정하였다.
• 각 변수별 히스토그램과 독립변수 & 종속변수의 산점도를 볼 때, 단순한 패턴을 갖는 것은 AveRooms, AveBedrms, Population, AveOccup로 이들은 히스토그램에서도 데이터가 한쪽에 지나치게 모여있기 때문에 딱히 패턴이 존재하지 않는다. 그러므로, 이들을 Wide model에 넣겠다.
• MedInc은 그 정도가 강하다고 할 수 있는 수준은 아니지만, 위 데이터 중 가장 뚜렷한 경향성을 가지고 있다. 이를 단순한 패턴으로 인식할지도 모르니, Wide model과 Deep model 양쪽에 넣어보자.

3. 데이터셋 쪼개기

• 입력층이 2개이므로, Train dataset, Validation dataset, Test dataset 모두 2개로 쪼개져야 한다.
• 출력층은 1개이므로, Label은 쪼개지 않아도 된다.

# 데이터를 쪼개기 좋게 변수의 순서를 바꾸자
CaliFornia_DF = CaliFornia_DF[["HouseAge", "Latitude", "Longitude", "MedInc",
                               "AveRooms", "AveBedrms", "Population", "AveOccup"]]

# train, validation, test set으로 쪼갠다.
X_train_all, X_test, y_train_all, y_test = train_test_split(CaliFornia_DF.values, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 정규화시킨다.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 데이터 셋을 input layer의 수만큼 쪼갠다.
X_train_A, X_train_B = X_train[:, :4], X_train[:,3:]
X_valid_A, X_valid_B = X_valid[:, :4], X_valid[:,3:]
X_test_A, X_test_B = X_test[:, :4], X_test[:,3:]

>>> X_train_A.shape
(11558, 4)

>>> X_train_B.shape
(11558, 5)

4. 모델 생성하기

input_A = Input(shape=[4], name = "deep_input")
input_B = Input(shape=[5], name = "wide_input")
hidden1 = Dense(30, activation="relu", name = "hidden1")(input_A)
hidden2 = Dense(30, activation="relu", name = "hidden2")(hidden1)
concat = concatenate([input_B, hidden2], name = "concat")
output = Dense(1, name="output")(concat)
model = keras.Model(inputs=[input_A, input_B], outputs=[output])

• 다중 입력 모델 생성 시, 주의사항은 층을 연결하는 부분인 concatenate layer다.
• 이전 포스트에서는 Concatenate layer를 사용하였고, 이번 포스트에선 맨 앞이 소문자인 concatenate layer를 사용하였는데, 둘 사이의 차이는 inputs(At least 2)라는 파라미터 여부다.
• 참고 1: tf.keras.layers.concatenate 공식 API 문서
• 참고 2: tf.keras.layers.Concatenate 공식 API 문서

>>> model.summary()

Model: "model"
__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
deep_input (InputLayer)         [(None, 4)]          0                                            
__________________________________________________________________________________________________
hidden1 (Dense)                 (None, 30)           150         deep_input[0][0]                 
__________________________________________________________________________________________________
wide_input (InputLayer)         [(None, 5)]          0                                            
__________________________________________________________________________________________________
hidden2 (Dense)                 (None, 30)           930         hidden1[0][0]                    
__________________________________________________________________________________________________
concat (Concatenate)            (None, 35)           0           wide_input[0][0]                 
                                                                 hidden2[0][0]                    
__________________________________________________________________________________________________
output (Dense)                  (None, 1)            36          concat[0][0]                     
==================================================================================================
Total params: 1,116
Trainable params: 1,116
Non-trainable params: 0
__________________________________________________________________________________________________

5. 모델 학습 및 평가하기

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = "msle",
              metrics=["accuracy"])

early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

# 학습
history = model.fit((X_train_A, X_train_B), y_train,epochs=300,
                    validation_data=((X_valid_A, X_valid_B), y_valid),callbacks=[early_stop])

Epoch 1/300
362/362 [==============================] - 2s 5ms/step - loss: 0.1601 - accuracy: 0.0015 - val_loss: 0.0413 - val_accuracy: 0.0028
Epoch 2/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0390 - accuracy: 0.0018 - val_loss: 0.0376 - val_accuracy: 0.0028
Epoch 3/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0367 - accuracy: 0.0017 - val_loss: 0.0364 - val_accuracy: 0.0028
Epoch 4/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0342 - accuracy: 0.0022 - val_loss: 0.0354 - val_accuracy: 0.0028

...

Epoch 277/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0256 - accuracy: 0.0029 - val_loss: 0.0291 - val_accuracy: 0.0028
Epoch 278/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0247 - accuracy: 0.0020 - val_loss: 0.0290 - val_accuracy: 0.0028
Epoch 279/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0258 - accuracy: 0.0027 - val_loss: 0.0295 - val_accuracy: 0.0028
Epoch 280/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0256 - accuracy: 0.0019 - val_loss: 0.0288 - val_accuracy: 0.0028

>>> model.evaluate((X_test_A, X_test_B), y_test)
194/194 [==============================] - 0s 753us/step - loss: 0.0300 - accuracy: 0.0040
[0.02998056262731552, 0.004037467762827873]

def Drawing_Scalars(history_name):
    
    history_DF = pd.DataFrame(history_name.history)
    # 그래프의 크기와 선의 굵기를 설정해주었다.
    history_DF.plot(figsize=(12, 8), linewidth=3)

    # 교차선을 그린다.
    plt.grid(True)

    plt.legend(loc = "upper right", fontsize =15)

    plt.title("Learning Curve", fontsize=30, pad = 30)
    plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
    plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

    # 위 테두리 제거
    ax=plt.gca()
    ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
    ax.spines["top"].set_visible(False) # 위 테두리 제거
    
    plt.show()
    
    
Drawing_Scalars(history)

• 이전 포스트에서는 모든 데이터 셋을 Wide model과 Deep model에 넣었을 때는 Accuracy: 0.0034, Loss: 0.0242, epochs: 63에서 학습이 끝났으나, 이번 방법으로는 Accuracy: 0.0040, Loss: 0.0300, epochs: 280으로 기대에 미치는 성능이 나오진 않았다.
• 학습에 대한 평가는 큰 차이가 없으나, 도리어 epochs가 63에서 280으로 학습 시간이 크게 늘어, 성능이 도리어 크게 떨어진 모습을 보여주었다.

6. 위 문제를 해결해보자.

• 조기종료가 된 epochs가 63에서 280으로 증가했다는 소리는 주어진 데이터 셋이 이전보다 적합하지 않아, 학습하는데 시간이 오래 걸렸다는 소리다.
• 그렇다면, 위에서 보았던 독립변수의 데이터 분포(히스토그램)와 독립변수와 종속변수의 상관관계(산점도)로 데이터 패턴의 단순한 정도를 본 방법이 틀린 것일까?
• 앞서 우리가 학습하였던, "Tensorflow-4.0. 다층 퍼셉트론을 이용한 회귀모형 만들기"에서 회귀모형(Regression model)은 독립변수와 종속변수 간에 어떠한 경향성이 있다는 전제하에 독립변수가 변할 때, 종속변수가 변하고 이를 가장 잘 나타내는 계수를 찾는 것이 목적이라고 했다.
• 딥러닝 역시 회귀모형의 원리와 매우 유사하게 돌아가므로, 이번에는 독립변수와 종속변수의 산점도(상관관계)에서 어떠한 경향성도 갖지 않는 "HouseAge", "AveRooms", "AveBedrms", "Population", "AveOccup", "Latitude", "Longitude" 모두를 Wide model에 넣고, 약한 선형 관계를 보이는 "MedInc"만 Deep model에 넣어보도록 하겠다.

# Dataset 생성
# 데이터를 쪼개기 좋게 변수의 순서를 바꾸자
CaliFornia_DF = CaliFornia_DF[["HouseAge", "Population", "Latitude", "Longitude", "MedInc",
                               "AveRooms", "AveBedrms", "AveOccup"]]

# train, validation, test set으로 쪼갠다.
X_train_all, X_test, y_train_all, y_test = train_test_split(CaliFornia_DF.values, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 정규화시킨다.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 데이터 셋을 input layer의 수만큼 쪼갠다.
X_train_A, X_train_B = X_train[:, :1], X_train[:,1:]
X_valid_A, X_valid_B = X_valid[:, :1], X_valid[:,1:]
X_test_A, X_test_B = X_test[:, :1], X_test[:,1:]

# Model 
input_A = Input(shape=[1], name = "deep_input")
input_B = Input(shape=[7], name = "wide_input")
hidden1 = Dense(30, activation="relu", name = "hidden1")(input_A)
hidden2 = Dense(30, activation="relu", name = "hidden2")(hidden1)
concat = concatenate([input_B, hidden2], name = "concat")
output = Dense(1, name="output")(concat)
model = keras.Model(inputs=[input_A, input_B], outputs=[output])


# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = "msle",
              metrics=["accuracy"])

early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

# 학습
history = model.fit((X_train_A, X_train_B), y_train,epochs=300,
                    validation_data=((X_valid_A, X_valid_B), y_valid),callbacks=[early_stop])

Epoch 1/300
362/362 [==============================] - 2s 5ms/step - loss: 0.2047 - accuracy: 0.0032 - val_loss: 0.0548 - val_accuracy: 0.0014
Epoch 2/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0520 - accuracy: 0.0031 - val_loss: 0.0470 - val_accuracy: 0.0014
Epoch 3/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0477 - accuracy: 0.0036 - val_loss: 0.0451 - val_accuracy: 0.0014
Epoch 4/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0439 - accuracy: 0.0041 - val_loss: 0.0443 - val_accuracy: 0.0014

...

Epoch 46/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0438 - accuracy: 0.0019 - val_loss: 0.0438 - val_accuracy: 0.0014
Epoch 47/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0446 - accuracy: 0.0036 - val_loss: 0.0439 - val_accuracy: 0.0014
Epoch 48/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0446 - accuracy: 0.0033 - val_loss: 0.0444 - val_accuracy: 0.0014
Epoch 49/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0430 - accuracy: 0.0029 - val_loss: 0.0440 - val_accuracy: 0.0014

>>> model.evaluate((X_test_A, X_test_B), y_test)
194/194 [==============================] - 0s 966us/step - loss: 0.0468 - accuracy: 0.0024
[0.04679189994931221, 0.002422480611130595]

>>> Drawing_Scalars(history)

• Deep model로는 1개의 변수만 집어넣었고, Wide model로 7개 변수를 넣었더니, Accuracy: 0.0024, Loss: 0.0468, epochs: 49(EarlyStopping의 patience인자가 30이므로, 실제 수렴은 epoch 19에서 한 것을 알 수 있다)로 수렴하였다.
• 모든 변수를 Deep model과 Wide model로 보내는 경우, Accuracy: 0.0034, Loss: 0.0242, epochs: 63으로, 정확도가 미미한 수준으로 더 좋아졌고, 수렴 속도가 보다 빨라졌으나, 큰 차이가 있진 않다.
• Deep Learning은 아주 많은 양의 데이터가 있을 때, 그 안에 우리가 인식하지 못하는 패턴을 찾아내는 것이므로, 위와 같은 밀집 특징(Dense Feature)에 대해서는 모든 데이터를 넣는 것을 추천한다.
• 희소 특징(Sparse Feature)은 Deep model을 통과하며, 학습이 제대로 이루어지지 않을 수 있으므로, Wide model에는 희소 특징만 넣도록 하자.

7. 참고 - 일반적인 다중 입력 모델의 사용 예

• 위 그림처럼 다중 입력은, 전혀 다른 데이터 셋 들로부터 하나의 결과를 도출해낼 수도 있다.
• 예를 들어, 물건 판매 웹사이트 사용자들에 대해 패턴을 뽑고자 한다면, 사용자들의 정보는 Dense 모델로, 사용자의 제품 후기는 RNN 모델로, 사용자의 관심 있는 제품 사진들을 CNN 모델로 학습시키고 이를 하나로 합쳐 하나의 결괏값을 뽑아낼 수도 있다.

[참고 자료]

arxiv.org/abs/1606.07792

ai.googleblog.com/2016/06/wide-deep-learning-better-together-with.html

 지금까지 Wide & Deep Learning model을 Input Layer를 2개로 하여 다중 입력 모델로 만들어보았다. Keras API로 모델을 만드는 경우, 위처럼 쉬운 방법으로 다중 입력, 다중 출력 모델을 만들 수 있으므로, Keras로 모델을 만들 땐, 가능한 API로 만들도록 하자.

 지금까지 Wide & Deep Learning model의 개념을 어느 정도 알아보았으니, 다음 포스트에서는 좀 더 가볍게 해당 모델로 다중 입력, 다중 출력 모델을 만들어보도록 하겠다.

 이전 포스트에서 다뤘던 선형 회귀 모형은 단일 입력층과 단일 출력층을 갖는 형태였다. 그러나, Keras를 사용하는 Tensorflow의 가장 큰 장점인 함수형 API모델을 사용하면, 다중 입력과 다중 출력을 갖는 모델을 만들 수 있다.

이번 포스트에서는 Keras의 장점인 함수형 API로 대규모 회귀 및 분류 모델에서 주로 사용되는 Wide & Deep Learning 모델을 만들어보자.

와이드 & 딥(Wide & Deep) 신경망

• 2016년 헝쯔 청(Heng-Tze Cheng et al.)의 논문에 소개된 신경망이다.
  Heng-Tze Cheng et al., "Wide & Deep Learning for Recommender Systems." Proceedings of the First Workshop on Deep Learning for Recommender Systems (2016): 7 - 10. http://homl.info/widedeep

• 인간은 일반화와 암기를 통해 학습을 한다.

• 일반화(Deep Models): 인간은 "참새는 날 수 있다.", "비둘기는 날 수 있다."를 통해 "날개를 가진 동물은 날 수 있다"라 일반화를 시킨다.
• 암기(Wide Models): 반면에 "펭귄은 날 수 없다.", "타조는 날 수 없다." 등과 같은 예외 사항을 암기하여, 일반화된 규칙을 더욱 세분화시킨다.

• Wide & Deep Learning은 이러한 인간의 일반화와 암기를 결합하여 학습하는 점에 착안하여, 만들어진 기계 학습 방법이다.
• 앞서 우리가 학습해왔던 심층 신경망(Deep Network)은 대상으로부터 공통된 패턴을 찾아내어 일반화시키지만, 그 패턴을 가지고 있으나, 이에 해당하지 않는 많은 반례들이 존재한다.
  (일반적으로 딥 러닝에서는 이를 감안한 데이터 셋을 준비해 학습한다.)
• Wide & Deep Learning은 여기서 더 나아가 넓은 선형 모델을 공동으로 학습시켜, 일반화(Deep Learning)와 암기(Wide Linear model)의 장점을 얻는다.
• Wide & Deep Learning은 추천 시스템, 검색 및 순위 문제 같은 많은 양의 범주형 특징(Categorical Feature)이 있는 데이터를 사용하는 대규모 회귀, 분류 모델에서 유용하게 사용된다.
• Wide & Deep Learning은 위 그림처럼 앞서 학습했던 다층 퍼셉트론(MLP - Deep way)에 입력 데이터의 일부 또는 전체 데이터가 출력층에 바로 연결(Wide way)되는 부분이 추가된 것이다.
• 이로 인해, Wide & Deep Learning은 복잡한 패턴과 간단한 규칙을 모두 학습할 수 있다.
  (MLP에서는 간단한 패턴이 연속된 변환으로 인해 왜곡될 수 있다.)

1. Tensorflow의 함수형 API를 사용하여 Wide & Deep Learning을 구현해보자.

• sklearn에서 제공하는 캘리포니아 주택 가격 데이터 셋을 사용해보자.
• sklearn에서 제공하는 기초 함수로 데이터 셋을 분리해보자.
• sklearn에서 제공하는 기초 함수로 데이터 셋의 스케일 조정을 실시해보자.

• Wide model과 Deep model이 같은 데이터를 바라보는 Input이 1개인 Wide & Deep Learning Model을 만들어보자.

1.1 데이터셋 준비

# import Module
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import pandas as pd

# 캘리포니아 주택 가격 데이터 셋 확인
Rawdict = fetch_california_housing()

Cal_DF = pd.DataFrame(Rawdict.data, columns=Rawdict.feature_names)
Cal_DF

# Data의 모든 컬럼들의 data type을 확인한다.
>>> Cal_DF.dtypes
MedInc        float64
HouseAge      float64
AveRooms      float64
AveBedrms     float64
Population    float64
AveOccup      float64
Latitude      float64
Longitude     float64
dtype: object


# Data의 모든 컬럼들의 결측값 개수를 확인한다.
>>> Cal_DF.isnull().sum()
MedInc        0
HouseAge      0
AveRooms      0
AveBedrms     0
Population    0
AveOccup      0
Latitude      0
Longitude     0
dtype: int64

• 데이터 셋은 모두 소수(float64)로 구성되어 있다.
• 결측 값은 모든 칼럼에 존재하지 않는다.

1.2 데이터셋 분리

>>> X_train_all, X_test, y_train_all, y_test = train_test_split(Rawdict.data, Rawdict.target, test_size = 0.3)
>>> X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)
>>> print("Train set shape:", X_train.shape)
>>> print("Validation set shape:", X_valid.shape)
>>> print("Test set shape:", X_test.shape)

Train set shape: (11558, 8)
Validation set shape: (2890, 8)
Test set shape: (6192, 8)

• sklearn.model_selection.train_test_split(array, test_size, shuffle): dataset을 쉽게 나눌 수 있는 sklearn 함수로 일반적으로 dataset, label 이 두 array를 동시에 넣고 사용한다.
• test_size: test Dataset의 비율(float)이나 총 숫자(int)로 나눠준다.
• shuffle: Dataset을 쪼개기 전에 섞을지 여부를 정해준다.

1.3. 데이터셋 스케일 조정

# 스케일 조정
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

• sklearn.preprocessing.StandardScaler(): 표준 정규분포로 스케일링할 준비를 한다.
• sklearn.prepocessing은 이밖에도 MinMaxScaler, MaxAbsScaler, RobustScaler 등 다양한 스케일링 기법을 제공한다.

1. MinMaxScaler(): 최소-최대 스케일 변환, 이상치 영향이 크다.
2. MaxAbsScaler(): 최대 절대 값을 1로 변환(-1.0 ~ 1.0으로 만드나, 전부 양수인 경우, MinMaxscaler와 동일하다), 이상치 영향이 크다.
3. StandardScaler(): 표준 정규분포 스케일 변환
4. RobustScaler(): 중앙값과 사분위 범위(Interquartile range)를 사용하며, StandardScaler보다 표준화 후 동일한 값을 더 넓게 분포 시킴

• StandardScaler().fit_transform(): 데이터셋을 표준 정규분포화 한다. 단, fit_transform에 들어가는 Dataset의 평균과 표준편차를 기준으로 저장하게 된다.
• StandardScaler().transform(): 데이터셋을 표준 정규분포화 한다. 표준 정규분포화하는 평균과 표준편차는 fit 된 Dataset을 따른다.
• 앞서 학습하였듯, 스케일링 조정의 기준은 훈련 셋(Train set)이다. 그러므로, fit_transform()에는 Train set이 들어가야 하고, transform에는 검증 셋(Validation set)이나 시험 셋(Test set)이 들어가야 한다.

2. 모델 만들기

• Wide & Deep Learning 같은 순차적이지 않은 신경망을 만들기 위해선 keras의 특징인 함수형 API를 이용해서 Layer를 만들어야 한다.
• 이번 모델은 1개의 Input Layer와 1개의 Output Layer를 갖는 Wide-Deep Learning 모델을 만들어보겠다.

from tensorflow import keras
from tensorflow.keras.layers import (Input, Dense, Concatenate)

# Model 생성하기
input_ = Input(shape=X_train.shape[1:])
hidden1 = Dense(30, activation="relu")(input_)
hidden2 = Dense(30, activation="relu")(hidden1)
concat = Concatenate()([input_, hidden2])
output = Dense(1)(concat)
model = keras.Model(inputs=[input_], outputs=[output])

• 함수형 API 모델 생성 방법

1. Input 객체 생성: Input layer는 배치 크기를 포함하지 않는, array의 모양을 정한다. 즉, Data의 크기가 아닌, 한 Row의 Data의 모양만 반영된다. 예를 들어, shape = (32,)가 되면, 32차원의 벡터가 입력된다는 의미다.
   (변수 이름에 _가 들어간 것은 파이썬에서 언더스코어(_)의 기능을 이용한 것으로, 단순하게 input함수와 충돌되지 않도록 이렇게 만든 것이다.)
2. 은닉층 객체 생성: 기존처럼 Layer를 add로 만들어진 모델에 은닉층을 쌓는 것이 아닌, 함수로 만들어 변수에 담는다. 여기서 케라스에서 층이 연결될 방법만 선언하였고, 그 어떤 데이터 처리도 발생하지 않은 상태이다.
3. 결합층 객체 생성: Wide-Deep Learning은 선형 모델과 딥러닝 모델을 동시에 사용하는 방법이므로, 입력될 객체인 input_과 hidden2를 연결해준다.
   
4. 출력층 객체 생성: 결합층에서 전달된 내용을 출력함
5. 모델 생성: 입력과 출력이 지정된 Keras 모델 생성

• tf.keras.layers.Concatenate(): 연결층이 Tensor를 연결하는 방법은 아래와 같다.

>>> x = np.arange(1, 41, 2).reshape(2,2,5)
>>> x
array([[[ 1,  3,  5,  7,  9],
        [11, 13, 15, 17, 19]],

       [[21, 23, 25, 27, 29],
        [31, 33, 35, 37, 39]]])


>>> y = np.arange(2, 21, 2).reshape(2,1,5)
>>> y
array y:
 [[[ 2  4  6  8 10]]

 [[12 14 16 18 20]]]


>>> tf.keras.layers.Concatenate(axis=1)([x, y])
<tf.Tensor: shape=(2, 3, 5), dtype=int32, numpy=
array([[[ 1,  3,  5,  7,  9],
        [11, 13, 15, 17, 19],
        [ 2,  4,  6,  8, 10]],

       [[21, 23, 25, 27, 29],
        [31, 33, 35, 37, 39],
        [12, 14, 16, 18, 20]]])>
   
   
>>> np.concatenate((x, y), axis=1)
array([[[ 1,  3,  5,  7,  9],
        [11, 13, 15, 17, 19],
        [ 2,  4,  6,  8, 10]],

       [[21, 23, 25, 27, 29],
        [31, 33, 35, 37, 39],
        [12, 14, 16, 18, 20]]])

• tf.keras.layers.Concatenate()는 np.concatenate() 함수와 동일한 역할을 하며, axis를 어떻게 잡느냐에 따라, 출력되는 Tensor의 모양을 다르게 할 수 있다.

3. 모델 학습 및 최종 코드 정리

• 지금까지 작성했던 코드와 이전에 사용했던 괜찮은 기능들을 합쳐 코드를 정리해보자.

# Import Module
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import callbacks
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import (Input, Dense, Concatenate)

# Dataset 생성
Rawdict = fetch_california_housing()
X_train_all, X_test, y_train_all, y_test = train_test_split(Rawdict.data, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 스케일 조정
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 모델 생성
input_ = Input(shape=X_train.shape[1:])
hidden1 = Dense(30, activation="relu")(input_)
hidden2 = Dense(30, activation="relu")(hidden1)
concat = Concatenate()([input_, hidden2])
output = Dense(1)(concat)
model = keras.Model(inputs=[input_], outputs=[output])

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = "msle",
              metrics=["accuracy"])

# 학습
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

history = model.fit(X_train, y_train, 
                    epochs=100,
                    batch_size=32,
                    validation_data=(X_valid, y_valid),
                    callbacks=[early_stop])

Epoch 1/100
362/362 [==============================] - 3s 5ms/step - loss: 0.1195 - accuracy: 0.0031 - val_loss: 0.0360 - val_accuracy: 0.0014
Epoch 2/100
362/362 [==============================] - 1s 1ms/step - loss: 0.0340 - accuracy: 0.0031 - val_loss: 0.0342 - val_accuracy: 0.0014
Epoch 3/100
362/362 [==============================] - 1s 1ms/step - loss: 0.0329 - accuracy: 0.0027 - val_loss: 0.0326 - val_accuracy: 0.0014
Epoch 4/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0336 - accuracy: 0.0034 - val_loss: 0.0321 - val_accuracy: 0.0014

...

Epoch 60/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0219 - accuracy: 0.0045 - val_loss: 0.0263 - val_accuracy: 0.0014
Epoch 61/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0221 - accuracy: 0.0033 - val_loss: 0.0285 - val_accuracy: 0.0014
Epoch 62/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0244 - accuracy: 0.0033 - val_loss: 0.0267 - val_accuracy: 0.0010
Epoch 63/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0227 - accuracy: 0.0032 - val_loss: 0.0264 - val_accuracy: 0.0010

>>> model.evaluate(X_test, y_test)
194/194 [==============================] - 0s 750us/step - loss: 0.0242 - accuracy: 0.0034
[0.02424260601401329, 0.0033914728555828333]

def Drawing_Scalars(history_name):
    
    history_DF = pd.DataFrame(history_name.history)
    # 그래프의 크기와 선의 굵기를 설정해주었다.
    history_DF.plot(figsize=(12, 8), linewidth=3)

    # 교차선을 그린다.
    plt.grid(True)

    plt.legend(loc = "upper right", fontsize =15)

    plt.title("Learning Curve", fontsize=30, pad = 30)
    plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
    plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

    # 위 테두리 제거
    ax=plt.gca()
    ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
    ax.spines["top"].set_visible(False) # 위 테두리 제거
    
    plt.show()
    
    
Drawing_Scalars(history)

• 위 모델의 학습 결과를 보면, accuracy는 빠르게 0에 가깝게 떨어진 것을 볼 수 있다.
• model.evaluate()에서 test set을 대상으로 모델을 평가한 결과 Accuracy는 0.0034가 나왔다.
• 분류 모델을 사용할 때와, 위와 같은 연속형 데이터에 대한 회귀 모델은 Accuracy의 기준이 다르므로, 위 경우엔 Accuracy, loss 모두 0에 가깝게 나오는 것이 좋다.
• 참고자료: "머신러닝-5.2. 손실함수(3)-평균제곱근오차(RMSE)"
• loss는 model.evaluate()에서 0.0242로 최종 손실 값이 0에 가깝게는 나왔으나, 기존 모델보다는 크게 나왔다. 그러나, 손실 값은 상대적인 기준이므로, 0에 가까울수록 좋은 것이긴 하나, 단순하게 나쁘게 봐서는 안된다.

[참고 자료]

arxiv.org/abs/1606.07792

ai.googleblog.com/2016/06/wide-deep-learning-better-together-with.html

 지금까지 Input layer가 1개인 Wide & Deep Learning model을 만들어보았다. 그러나, Wide & Deep Learning model의 가장 큰 특징은 Input 되는 층이 지금까지처럼 1개의 동일한 Layer가 아니라, 암기(Linear Learning)를 위한 데이터와 일반화(Deep Learning)를 위한 데이터가 Input 될 층을 따로 구성될 수 있다는 것이다.

 다음 포스트에서는 Input layer가 2개인 경우에 대하여 Wide & Deep Learning model을 만들어보면서, Wide & Deep Learning model에 대해 더 알아보도록 하자.