스마트워치를 착용하여 6개월 동안 수집된 데이터셋을 활용하여 간단한 신경망을 이용하여 예측 모델을 만들어보겠습니다.

데이터셋에 포함된 특성들은 다음과 같습니다.

날짜
칼로리 소모량
걸음 수
이동 거리
층수
정적인 시간(분)
약간 활동적인 시간(분)
상당히 활동적인 시간(분)
매우 활동적인 시간(분)
활동 칼로리

먼저 데이터를 판다스 패키지로 읽어보겠습니다.

import pandas as pd

df = pd.read_csv('fitbit_export_2021.csv', thousands = ',')

print(df.columns)

Index(['날짜', '칼로리 소모량', '걸음 수', '이동 거리', '층수', '정적인 시간(분)', '약간 활동적인 시간(분)',
       '상당히 활동적인 시간(분)', '매우 활동적인 시간(분)', '활동 칼로리'],
      dtype='object')

print(df)

               날짜  칼로리 소모량   걸음 수  ...  상당히 활동적인 시간(분)  매우 활동적인 시간(분)  활동 칼로리
0    2021. 1. 29.     2230   6304  ...               0              0     726
1    2021. 1. 30.     2883  13187  ...              26             25    1639
2    2021. 1. 31.     2756  12702  ...              14              8    1535
3     2021. 2. 1.     2674   9775  ...              13              9    1299
4     2021. 2. 2.     1667    538  ...               0              0     124
..            ...      ...    ...  ...             ...            ...     ...
120  2021. 6. 12.     2740  14267  ...              24              9    1536
121  2021. 6. 13.     1657   1073  ...               0              0     136
122  2021. 6. 14.     2435   9433  ...               6             22     987
123  2021. 6. 15.     1943   3492  ...               7             12     412
124  2021. 6. 16.     2063   4232  ...               6              2     608

[125 rows x 10 columns]

단층 퍼셉트론 신경망

먼저 단층 퍼셉트론 신경망 모델을 실습하기 위해, 걸음 수를 입력하면 이동 거리를 예측하는 간단한 모델을 만들어보겠습니다.

다음과 같이 모델 입출력을 구성합니다.

X: 걸음 수
Y: 이동 거리

다음과 같이 데이터셋을 구성합니다.

훈련셋: 1번째 ~ 100번째 샘플
시험셋: 101번째 ~ 125번째 샘플

x = df['걸음 수']
y = df['이동 거리']

x_train = x[:100]
y_train = y[:100]
x_test = x[100:]
y_test = y[100:]

걸음 수를 입력하면 이동 거리를 구하는 모델이기 때문에, 테스트로 입력할 걸음 수 정보를 먼저 확인해봅니다. 우리는 인공지능 모델이 아래 걸음 수를 입력했을 때, 적정한 이동 거리를 구하기를 희망하는 것입니다.

print(x_test)

100     6771
101     8225
102     3853
103     7625
104      377
105     3921
106     9740
107     5761
108     6214
109     4089
110     6325
111     8123
112    10884
113    13917
114    13917
115     6885
116     7629
117     6104
118     3590
119     1897
120    14267
121     1073
122     9433
123     3492
124     4232
Name: 걸음 수, dtype: int64

위의 문제를 풀기 위해, 과거 데이터로 패턴을 익힌 후 사용할 수 있는 모델을 만들어보겠습니다. 먼저 과거 데이터 즉 훈련셋을 살펴보겠습니다.

import matplotlib.pyplot as plt

plt.scatter(x_train, y_train)
plt.xlabel('steps')
plt.ylabel('distance')
plt.show()

'걸음 수'와 '이동 거리'는 서로 비례 관계를 가지고 있습니다. 이런 패턴은 선형회귀 문제로 풀 수 있으며, 여러가지 모델이 있으나 가장 간단한 단층 퍼셉트론 신경망으로 풀어보겠습니다.

케라스를 사용하기 위해 필요한 패키지를 가져옵니다.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

"Y = w * X + b"에서 주어진 X, Y에 대해 학습에 의해 갱신될 가중치(w) 하나와 바이어스(b)를 하나를 가진 네트워크 아키텍처를 정의합니다.

model = Sequential([
    Dense(1, input_dim=1)
])

model.summary()

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
dense (Dense)                (None, 1)                 2
=================================================================
Total params: 2
Trainable params: 2
Non-trainable params: 0
_________________________________________________________________

손실함수는 회귀문제에 적합한 'mse'로 설정하고, 최적화기(optimizer)는 'rmsprop'으로 설정하여 모델을 컴파일 합니다. 평가 매트릭은 수치 차이를 직관적으로 알 수 있도록 'mae'로 설정했습니다.

model.compile(loss='mse', optimizer='rmsprop', metrics=['mae'])

모델을 학습하기 위해 준비한 훈련셋으로 학습을 시작합니다. 반복횟수(epochs)는 100번으로 배치사이즈는 4로 설정했습니다.

model.fit(x_train, y_train, epochs=100, batch_size=4)

Epoch 1/100
25/25 [==============================] - 1s 2ms/step - loss: 455934.7500 - mae: 598.7256
Epoch 2/100
25/25 [==============================] - 0s 2ms/step - loss: 220361.5469 - mae: 421.6461
Epoch 3/100
25/25 [==============================] - 0s 2ms/step - loss: 85503.8672 - mae: 257.3829
Epoch 4/100
25/25 [==============================] - 0s 2ms/step - loss: 19942.9707 - mae: 121.8781
Epoch 5/100
25/25 [==============================] - 0s 2ms/step - loss: 1008.2024 - mae: 23.2775
Epoch 97/100
25/25 [==============================] - 0s 2ms/step - loss: 19.8990 - mae: 2.5496
Epoch 98/100
25/25 [==============================] - 0s 2ms/step - loss: 24.6426 - mae: 2.7806
Epoch 99/100
25/25 [==============================] - 0s 2ms/step - loss: 24.1225 - mae: 2.9470
Epoch 100/100
25/25 [==============================] - 0s 2ms/step - loss: 12.1345 - mae: 1.5692





<tensorflow.python.keras.callbacks.History at 0x7f8de212b3d0>

학습 과정 중에 평가 매트릭인 mae이 3이하로 나온다면, 훈련셋에 대해 실제값과 예측값 사이의 오차가 3km 이하라고 보시면 됩니다. get_weights() 함수를 사용하여 학습된 가중치와 바이어스를 살펴볼 수 있습니다.

w, b = model.get_weights()

print(w, b)

[[0.00074581]] [0.08114602]

이렇게 학습된 모델을 사용해보겠습니다. 10,000보를 걸었을 경우, 실제 이동거리는 얼마나 될까요?

x_pred = [[10000]]
y_pred = model.predict(x_pred)
print(y_pred)

[[7.5392127]]

앞서 우리가 정의한 시험셋에 대해 평가하기 위해 25개 샘플의 "걸음 수"를 모델에 입력하여 "이동 거리"를 예측해봅니다.

'mae'로 정량적으로 평가하기 위해 evaluate() 함수에 x_test와 y_test을 입력하면, 모델 출력과 y_test를 컴파일 시에 지정한 metric에 의해 계산된 값을 반환합니다. 이를 출력하면 시험셋에 대한 모델의 정확도를 구할 수 있습니다.

y_pred = model.predict(x_test)

print(y_pred)

loss, mae = model.evaluate(x_test, y_test)

print(mae)

[[ 5.1310034 ]
 [ 6.215406  ]
 [ 2.954739  ]
 [ 5.767922  ]
 [ 0.36231512]
 [ 3.005454  ]
 [ 7.345303  ]
 [ 4.3777385 ]
 [ 4.715589  ]
 [ 3.1307495 ]
 [ 4.798373  ]
 [ 6.1393337 ]
 [ 8.198506  ]
 [10.460538  ]
 [10.460538  ]
 [ 5.2160254 ]
 [ 5.7709055 ]
 [ 4.63355   ]
 [ 2.758592  ]
 [ 1.4959413 ]
 [10.72157   ]
 [ 0.88139653]
 [ 7.1163406 ]
 [ 2.685503  ]
 [ 3.2373998 ]]
1/1 [==============================] - 0s 120ms/step - loss: 0.2753 - mae: 0.4704
0.47042927145957947

마지막으로 실제값과 모델의 예측값을 가시화 시켜서 어느정도 차이가 나는 지 확인해보겠습니다.

plt.scatter(x_test, y_test, c = 'r', label='true')
plt.scatter(x_test, y_pred, c = 'b', label='pred')

plt.xlabel('steps')
plt.ylabel('distance')
plt.legend(loc='lower right')

plt.show()

다층 퍼셉트론 신경망

다층 퍼셉트론 신경망 모델을 실습하기 위해, 조금 더 복잡한 문제를 풀어보겠습니다. 걸음 수, 이동 거리, 심박수를 입력하면, 칼로리 소모량을 예측하는 것입니다.

다음과 같이 모델 입출력을 구성합니다.

X
- 걸음 수
- 이동 거리
- 정적인 시간(분)
- 약간 활동적인 시간(분)
- 상당히 활동적인 시간(분)
- 매우 활동적인 시간(분)
Y
- 칼로리 소모량

다음과 같이 데이터셋을 구성합니다.

훈련셋: 1번째 ~ 100번째 샘플
시험셋: 101번째 ~ 125번째 샘플

x = df[['걸음 수', '이동 거리', '정적인 시간(분)', '약간 활동적인 시간(분)', '상당히 활동적인 시간(분)', '매우 활동적인 시간(분)']]
y = df['칼로리 소모량']

x_train = x[:100]
y_train = y[:100]
x_test = x[100:]
y_test = y[100:]

여러 개의 속성을 입력하여 칼로리 소모량을 구하는 모델이기 때문에, 테스트로 입력할 속성 정보를 먼저 확인해봅니다. 우리는 인공지능 모델이 아래 속성들을 입력했을 때, 적정한 칼로리 소모량을 구하기를 희망하는 것입니다.

print(x_test)

      걸음 수  이동 거리  정적인 시간(분)  약간 활동적인 시간(분)  상당히 활동적인 시간(분)  매우 활동적인 시간(분)
100   6771   4.68       1247            149              24             20
101   8225   5.81       1269            120              16             35
102   3853   2.62       1309            122               3              6
103   7625   5.20       1146            187               8             18
104    377   0.26       1371             14               0              0
105   3921   2.68       1373             40               5             22
106   9740   6.68       1229            192               4             15
107   5761   4.05       1304            136               0              0
108   6214   4.28       1276            154               1              9
109   4089   2.80       1261            179               0              0
110   6325   4.30       1281            149               5              5
111   8123   5.58       1153            172               9             18
112  10884   7.44       1159            238              21             22
113  13917   9.52       1299             19               0            122
114  13917   9.52       1440              0               0              0
115   6885   4.84       1183            242               6              9
116   7629   5.24       1198            230               5              7
117   6104   4.21       1257            173               1              9
118   3590   2.51       1296            144               0              0
119   1897   1.30       1366             74               0              0
120  14267   9.79       1068            339              24              9
121   1073   0.73       1282             38               0              0
122   9433   6.46        795            183               6             22
123   3492   2.42       1340             81               7             12
124   4232   2.90       1312            120               6              2

모델 구성에 앞서 딥러닝 모델이 잘 학습할 수 있도록 입력 데이터의 전처리를 수행합니다. 속성별로 상이한 스케일을 가진 데이터를 입력하면 스케일이 큰 속성에 영향을 많이 미치는 경우가 발생하기 때문에, 이 경우 정규화 과정을 거치게 됩니다. 속성별로 평균을 구한 뒤, 각 인스턴스에다 평균을 빼고 표준 편차로 나누겠습니다.

시험셋을 입력할 때, 즉 모델을 학습 후에 사용할 때도 동일하게 정규화를 시켜야하므로, 훈련셋에서 구한 평균과 표준 편차를 기억해둡니다.

mean = x_train.mean(axis=0)
x_train -= mean
std = x_train.std(axis=0)
x_train /= std

print(mean)
print(std)

걸음 수              8166.280
이동 거리                5.718
정적인 시간(분)          992.050
약간 활동적인 시간(분)      207.990
상당히 활동적인 시간(분)      11.820
매우 활동적인 시간(분)       16.050
dtype: float64
걸음 수              4021.631183
이동 거리                2.854176
정적인 시간(분)          242.142390
약간 활동적인 시간(분)       82.894419
상당히 활동적인 시간(분)      13.810682
매우 활동적인 시간(분)       16.014119
dtype: float64

입력 속성이 6개이고 출력이 1개인 네트워크 아키텍처를 설계합니다. 비선형 문제를 풀 수 있도록 'relu'활성화 함수를 가진 여러 층으로 구성했습니다.

model = Sequential([
    Dense(16, input_dim=6, activation='relu'),
    Dense(16, activation='relu'),
    Dense(1)
])

model.summary()

Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
dense_1 (Dense)              (None, 16)                112
_________________________________________________________________
dense_2 (Dense)              (None, 16)                272
_________________________________________________________________
dense_3 (Dense)              (None, 1)                 17
=================================================================
Total params: 401
Trainable params: 401
Non-trainable params: 0
_________________________________________________________________

손실함수는 회귀문제에 적합한 'mse'로 설정하고, 최적화기(optimizer)는 'rmsprop'으로 설정하여 모델을 컴파일 합니다. 평가 매트릭은 수치 차이를 직관적으로 알 수 있도록 'mae'로 설정했습니다.

model.compile(loss='mse', optimizer='rmsprop', metrics=['mae'])

모델을 학습하기 위해 준비한 훈련셋으로 학습을 시작합니다. 반복횟수(epochs)는 1000번으로 배치사이즈는 4로 설정했습니다.

model.fit(x_train, y_train, epochs=1000, batch_size=4)

Epoch 1/1000
25/25 [==============================] - 1s 2ms/step - loss: 5864717.5000 - mae: 2398.3564
Epoch 2/1000
25/25 [==============================] - 0s 3ms/step - loss: 5862944.0000 - mae: 2397.9932
Epoch 3/1000
25/25 [==============================] - 0s 3ms/step - loss: 5860843.5000 - mae: 2397.5662
Epoch 4/1000
25/25 [==============================] - 0s 2ms/step - loss: 5858182.5000 - mae: 2397.0266
Epoch 5/1000
25/25 [==============================] - 0s 3ms/step - loss: 5855016.5000 - mae: 2396.3713
Epoch 997/1000
25/25 [==============================] - 0s 4ms/step - loss: 5633.3574 - mae: 60.4163
Epoch 998/1000
25/25 [==============================] - 0s 3ms/step - loss: 5694.2544 - mae: 60.3158
Epoch 999/1000
25/25 [==============================] - 0s 3ms/step - loss: 5626.2715 - mae: 60.1077
Epoch 1000/1000
25/25 [==============================] - 0s 3ms/step - loss: 5669.3198 - mae: 60.6162





<tensorflow.python.keras.callbacks.History at 0x7f8dd034fb90>

앞서 우리가 정의한 시험셋에 대해 평가하기 위해 25개 샘플의 6개 속성을 모델에 입력하여 "칼로리 소모량"를 예측해봅니다.

여기서 주의해야 할 것은 모델에 속성 데이터를 입력할 때, 훈련셋에서 사용된 평균과 표준편차를 이용하여 정규화를 해야된다는 것입니다.

'mae'로 정량적으로 평가하기 위해 evaluate() 함수에 x_test와 y_test을 입력하면, 모델 출력과 y_test를 컴파일 시에 지정한 metric에 의해 계산된 값을 반환합니다. 이를 출력하면 시험셋에 대한 모델의 정확도를 구할 수 있습니다.

x_test -= mean
x_test /= std

y_pred = model.predict(x_test)

print(y_pred)

loss, mae = model.evaluate(x_test, y_test)

print(mae)

[[2290.2954]
 [2328.6492]
 [2025.2286]
 [2318.131 ]
 [1711.9061]
 [1965.2771]
 [2331.7986]
 [2053.2273]
 [2146.2412]
 [2120.8948]
 [2130.2424]
 [2297.526 ]
 [2558.0447]
 [2985.967 ]
 [1863.6647]
 [2386.1267]
 [2351.2024]
 [2188.8013]
 [2034.1775]
 [1842.0299]
 [2797.1897]
 [1749.516 ]
 [2363.3367]
 [1971.8643]
 [2020.2286]]
1/1 [==============================] - 0s 107ms/step - loss: 16648.2812 - mae: 74.1553
74.15526580810547

모델의 결과를 'y_pred.csv' 파일로 저장합니다.

import numpy as np

np.savetxt('y_pred.csv', y_pred, fmt='%f')

목표

제출 따라하기

개념 배우기

코드 따라하기