1. MLP DNN 모델(다:1)
1부터 10까지의 데이터를 준비한다.
#1. 데이터
import numpy as np
dataset = np.array([1,2,3,4,5,6,7,8,9,10])
함수를 사용해서 4개씩 잘라서 x를 만들고, 그 다음 수 1개의 숫자를 y로 만들자
def split_xy1(dataset, time_steps):
x, y = list(), list()
for i in range(len(dataset)):
end_number = i + time_steps
if end_number > len(dataset) - 1:
break
tmp_x, tmp_y = dataset[i:end_number], dataset[end_number]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy1(dataset, 4)
print(x, "\n", y)
print(x.shape)
print(y.shape)실행결과
[[1 2 3 4]
[2 3 4 5]
[3 4 5 6]
[4 5 6 7]
[5 6 7 8]
[6 7 8 9]]
[ 5 6 7 8 9 10]
(6, 4)
(6,)
연속된 데이터 1,2,3,4로 5를 예측하는 형식이므로 RNN으로 구현하기에 좋은 데이터 형태이다. 그런데 생각을 조금 더 전환해보면 이 데이터의 shape(6,4)는 DNN에서도 충분히 적용할 수 있는 데이터 형식이다.
우리는 RNN 이전에 간단한 Dense 모델을 이용했었다. 그때 입력되는 shape는 (?,컬럼)이었고 input_shape=(컬럼,)이거나 input_dim=컬럼을 사용했다.
이처럼 shape만 맞다면 어떤 모델(Dense 모델 또는 RNN모델)이든지 바꿔가며 사용할 수 있다.
따라서 RNN모델을 만들기 전에 DNN 모델을 먼저 만들고 시작해보자.
#2. 모델 구성
from keras.models import Sequential
from keras.layers import Dense
Sequential 모델로 구성을 하고, 현재 우리가 나눈 데이터를 우선 Dense 모델로 학인하자
model = Sequential()
model.add(Dense(64, input_shape=(4, )))
# model.add(Dense(64, input_dim=4))
model.add(Dense(1))input_shape=4와 input_dim=4는 같은 방식이다.
이제 훈련시키자
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=1000)평가를 예측하자. evaluate의 경우 우리가 데이터를 train과 test로 나누지 않은 상황이므로 x와 y를 넣어서 훈련도만 평가하고, 대신 새로운 값(앞으로 x_pred)으로 predict하자.
#4. 평가, 예측
mse = model.evaluate(x, y)
print("mse :", mse)
x_pred = np.array([7,8,9,10])
x_pred = x_pred.reshape(1, x_pred.shape[0])
print(x_pred.shape)
mse : 0.0005433722981251776
(1, 4)
훈련 데이터는 0.005으로 괜찮은 편이다. x_pred는 모델에 적용할 수 있도록(1,4)로 shape를 맞췄다. 새로운 데이터 x_pred[7,8,9,10]으로 예측해보자.
y_pred = model.predict(x_pred)
print(y_pred)[[11.038393]]
11.03라는 괜찮은 값이 나왔다.
전체소스
#1. 데이터
import numpy as np
dataset = np.array([1,2,3,4,5,6,7,8,9,10])
def split_xy1(dataset, time_steps):
x, y = list(), list()
for i in range(len(dataset)):
end_number = i + time_steps
if end_number > len(dataset) - 1:
break
tmp_x, tmp_y = dataset[i:end_number], dataset[end_number]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy1(dataset, 4)
print(x, "\n", y)
print(x.shape)
print(y.shape)
from keras.models import Sequential
from keras.layers import Dense
#2. 모델 구성
model = Sequential()
model.add(Dense(64, input_shape=(4, )))
model.add(Dense(1))
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=1000)
#4. 평가, 예측
mse = model.evaluate(x, y)
print("mse :", mse)
x_pred = np.array([7,8,9,10])
x_pred = x_pred.reshape(1, x_pred.shape[0])
print(x_pred.shape)
y_pred = model.predict(x_pred)
print(y_pred)이 예제를 통해 RNN을 DNN으로 변환이 가능하다는 것을 알았다. 다음에 이 DNN 예제를 이용하여 RNN 모델을 만들자.
2. MLP RNN 모델(다:1)
이전 DNN 모델을 이용해서 RNN 모델을 구현하자.
RNN으로 변경하기 위해서는 input_shape 부분을 바꾸는 것이 가장 중요하다.
우선 데이터부터 가져오자.
#1. 데이터
import numpy as np
dataset = np.array([1,2,3,4,5,6,7,8,9,10])
def split_xy1(dataset, time_steps):
x, y = list(), list()
for i in range(len(dataset)):
end_number = i + time_steps
if end_number > len(dataset) - 1:
break
tmp_x, tmp_y = dataset[i:end_number], dataset[end_number]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy1(dataset, 4)
print(x, "\n", y)
print(x.shape)
print(y.shape)
[[1 2 3 4]
[2 3 4 5]
[3 4 5 6]
[4 5 6 7]
[5 6 7 8]
[6 7 8 9]]
[ 5 6 7 8 9 10]
현재 x와 y의shape
(6, 4)
(6,)
y는 괜찮지만 x를 RNN에 맞는 데이터로 변경하려면 2차원에서 3차원으로 바꿔야한다.
RNN의 shape는
(samples, time_step, feature)
행, 열, 특성
행, 열, 몇 개씩 자르는지
전체 데이터 수 , 컬럼, 특성
전체 데이터 수 , 컬럼, 몇 개씩 자르는지
RNN은 3차원이라는 점과 input_shpae=(?,?)는 2차원으로 들어간다는 것을 잊지 말고 기억하자.
input_shape가 왜 2차원인지에 대해서는 앞에서 설명했고 '행무시'라는 용어를 기억하면 된다. (6,4)의 2차원 데이터를 3차원으로 바꾸자.
x = x.reshape(x.shape[0], x.shape[1], 1)
print(x.shape)(6, 4, 1)
x의 shape를 (6,,4)에서 (6,4,1)로 변환했다.
이제 6행 4열의 데이터를 1개씩 잘라서 작업할 수 있는 구조로 만들었다.
RNN의 대표 모델인 LSTM으로 구성하자.
from keras.models import Sequential
from keras.layers import Dense, LSTM
#2. 모델구성
model = Sequential()
model.add(LSTM(64, input_shape=(4,1)))
model.add(Dense(1))LSTM을 import하고 input_shape를 (4,1)로 변경했다. 4개의 컬럼을 1개씩 잘라서 쓰는 LSTM을 구성하겠다는 의미이다.
나머지 훈련 및 평가, 예측은 동일하다.
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=1000)
#4. 평가, 예측
mse = model.evaluate(x, y)
print("mse :", mse)
x_pred = np.array([7,8,9,10])
x_pred = x_pred.reshape(1, x_pred.shape[0])
print(x_pred.shape)
y_pred = model.predict(x_pred)
print(y_pred)을 실행하면 ValueError가 발생한다. shape가 잘못되었다.
x_pred의 shape는 현재 (1,4) 하지만 모델에서 제대로 돌아가려면 (1,4,1)이 되어야 한다.
x_pred = x_pred.reshape(1, x_pred.shape[0], 1)
print(x_pred.shape)(1,4,1)
mse : 2.4401631435466697e-06
(1, 4, 1)
[[10.868662]]
연속된 데이터에서 가장 좋다던 LSTM에서 예측값이 오히려 DNN보다 못 미치고 있다
mse가 2.4 정도이고 11정도 나와야 되는 예측 값은 10.86이다.
전체 소스
#1. 데이터
import numpy as np
dataset = np.array([1,2,3,4,5,6,7,8,9,10])
def split_xy1(dataset, time_steps):
x, y = list(), list()
for i in range(len(dataset)):
end_number = i + time_steps
if end_number > len(dataset) - 1:
break
tmp_x, tmp_y = dataset[i:end_number], dataset[end_number]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy1(dataset, 4)
print(x, "\n", y)
print(x.shape)
print(y.shape)
from keras.models import Sequential
from keras.layers import Dense, LSTM
#2. 모델구성
model = Sequential()
model.add(LSTM(64, input_shape=(4,1)))
model.add(Dense(1))
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=1000)
#4. 평가, 예측
mse = model.evaluate(x, y)
print("mse :", mse)
x_pred = np.array([7,8,9,10])
x_pred = x_pred.reshape(1, x_pred.shape[0], 1)
print(x_pred.shape)
y_pred = model.predict(x_pred)
print(y_pred)우선 이 데이터들은 연속된 데이터로 모델을 교육시키기 위해 1부터 30까지의 숫자만을 사용했다. 그리고 하이퍼파라미터 튜닝 역시 아직 약하다. 교육용 데이터셋이라 이런 결과가 나왔지만. 튜닝으로 훨씬 더 좋은 예측값으로 바꿀 수 있다.
하이퍼파라미터 튜닝을 해서 예측값을 더 좋게 만들어 보자.
3. MLP RNN 모델(다:다)
#1. 데이터
import numpy as np
dataset = np.array([1,2,3,4,5,6,7,8,9,10])
자를 때 x는 4개씩 y는 2개씩 잘라서 사용하자.
함수는 split_xy2를 사용하며, 데이터 입력을 (?, 4, 1)로 하고 출력을 (2,)으로 하자.
def split_xy2(dataset, time_steps, y_column):
x, y = list(), list()
for i in range(len(dataset)):
x_end_number = i + time_steps
y_end_number = x_end_number + y_column
if y_end_number > len(dataset):
break
tmp_x = dataset[i:x_end_number]
tmp_y = dataset[x_end_number : y_end_number]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy2(dataset, 4, 2)
print(x, "\n", y)
print(x.shape)
print(y.shape)
x = x.reshape(x.shape[0], x.shape[1], 1)
print(x.shape)
[[1 2 3 4]
[2 3 4 5]
[3 4 5 6]
[4 5 6 7]
[5 6 7 8]]
[[ 5 6]
[ 6 7]
[ 7 8]
[ 8 9]
[ 9 10]]
(5, 4)
(5, 2)
(5, 4, 1)
split_xy2 함수를 사용하여 x는 4개씩, y는 2개씩 잘랐다.
현재 데이터 구조
| x | y | ||||
| 1 | 2 | 3 | 4 | 5 | 6 |
| 2 | 3 | 4 | 5 | 6 | 7 |
| 3 | 4 | 5 | 6 | 7 | 8 |
| 4 | 5 | 6 | 7 | 8 | 9 |
| 5 | 6 | 7 | 8 | 9 | 10 |
x의 shape는 (5,4) y의 shape는(5,2) x값을 LSTM의 shape에 맞추기 위해 reshape를 하고 실행했다.
(5,4,1)
x값도 정상적으로 잘 잘렸고 5는 행이므로 '행 무시'를 해도 되고 4는 가장 중요한 컬럼, 1은 '몇 개씩 자르는 지' 이다. 사실 차원으로 읽으면 (면, 행,열)로 읽어야하지만, keras api상으로 마지막 것은 열이 아니라 feature이다.
이제 RNN모델을 만들 수 있는 shape를 구했다.
from keras.models import Sequential
from keras.layers import Dense, LSTM
#2. 모델 구성
model = Sequential()
model.add(LSTM(64, input_shape=(4, 1)))
model.add(Dense(2))
y의 값이 2개이니 마지막 아웃풋 레이어는 Dense(2)가 된다.
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=300, batch_size=1)
#4. 평가, 예측
mse = model.evaluate(x, y, batch_size=1)
print("mse :", mse)
x_pred = np.array([6, 7,8,9])
x_pred = x_pred.reshape(1, x_pred.shape[0], 1)
#print(x_pred.shape)
y_pred = model.predict(x_pred, batch_size=1)
print(y_pred)mse : 0.007457922212779522 [[ 9.718463 10.460049]]
mse는 0.007로 괜찮게 나왔지만 10과 11을 예상한 데이터는 9.7, 10.4가 나왔다. 튜닝을 통해 예측값을 좀 더 정확히 맞추자.
전체소스
#1. 데이터
import numpy as np
dataset = np.array([1,2,3,4,5,6,7,8,9,10])
def split_xy2(dataset, time_steps, y_column):
x, y = list(), list()
for i in range(len(dataset)):
x_end_number = i + time_steps
y_end_number = x_end_number + y_column
if y_end_number > len(dataset):
break
tmp_x = dataset[i:x_end_number]
tmp_y = dataset[x_end_number : y_end_number]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy2(dataset, 4, 2)
print(x, "\n", y)
print(x.shape)
print(y.shape)
x = x.reshape(x.shape[0], x.shape[1], 1)
print(x.shape)
from keras.models import Sequential
from keras.layers import Dense, LSTM
#2. 모델 구성
model = Sequential()
model.add(LSTM(64, input_shape=(4, 1)))
model.add(Dense(2))
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=300, batch_size=1)
#4. 평가, 예측
mse = model.evaluate(x, y, batch_size=1)
print("mse :", mse)
x_pred = np.array([6, 7,8,9])
x_pred = x_pred.reshape(1, x_pred.shape[0], 1)
#print(x_pred.shape)
y_pred = model.predict(x_pred, batch_size=1)
print(y_pred)
4. MLP RNN 모델(다입력 다:1)
#1. 데이터
import numpy as np
dataset = np.array([[1,2,3,4,5,6,7,8,9,10],[11,12,13,14,15,16,17,18,19,20],[21,22,23,24,25,26,27,28,29,30]])
print("dataset.shape ", dataset.shape)
dataset.shape (3, 10)
데이터 구조는 3행 10열이며 모델에서 훈련할 수 있도록 10행 3열의 데이터로 변경하자.
dataset = np.transpose(dataset)
print(dataset)
print("dataset.shape :", dataset.shape)
[[ 1 11 21]
[ 2 12 22]
[ 3 13 23]
[ 4 14 24]
[ 5 15 25]
[ 6 16 26]
[ 7 17 27]
[ 8 18 28]
[ 9 19 29]
[10 20 30]]
dataset.shape : (10, 3)
x는 3개씩 y는 1개씩 자르자.
def split_xy3(dataset, time_steps, y_column):
x, y = list(), list()
for i in range(len(dataset)):
x_end_number = i + time_steps
y_end_number = x_end_number + y_column - 1
if y_end_number > len(dataset):
break
tmp_x = dataset[i:x_end_number, :-1]
tmp_y = dataset[x_end_number-1 : y_end_number, -1]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy3(dataset, 3, 1)
print(x, "\n", y)
print(x.shape)
print(y.shape)
dataset.shape : (10, 3)
원하는 결과
| x | y | |
| 1 | 11 | 21 |
| 2 | 12 | 22 |
| 3 | 13 | 23 |
| 4 | 14 | 24 |
| 5 | 15 | 25 |
| 6 | 16 | 26 |
| 7 | 17 | 27 |
| 8 | 18 | 28 |
| 9 | 19 | 29 |
| 10 | 20 | 30 |
실행결과 x는 (8,3,2), y는 (8,1)의 shape가 되었다. 모델의 아웃풋에 사용할 수 있도록 y값을 벡터 형태로 변경하자.
y = y.reshape(y.shape[0])
print(y.shape)실행 결과
(8,)
출력값은 8개짜리 벡터의 1차원 모습이다.
#2. 모델 구성
from keras.models import Sequential
from keras.layers import Dense, LSTM
model = Sequential()
model.add(LSTM(64, input_shape=(3, 2)))
model.add(Dense(1))
x의 shape가 (8,3,2) 이므로 '행 무시'하고 (None, 3,2)로 input_shape=(3,2)가 된다.
최종 아웃풋은 8개짜리의 1차원 벡터이므로 Dense(1)이다.
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=300, batch_size=1)
#4. 평가, 예측
mse = model.evaluate(x, y, batch_size=1)
print("mse :", mse)
x_pred shape도 x와 동일해야 한다. x_pred 데이터로 [9,10,11],[19,20,21]을 사용하자.
rpedict 할 수 있도록 shape를 맞추자
x_pred = np.array([[9,10,11],[19,20,21]])
x_pred = np.transpose(x_pred)
x_pred = x_pred.reshape(1, x_pred.shape[0], x_pred.shape[1])
#print(x_pred.shape)
y_pred = model.predict(x_pred, batch_size=1)
print(y_pred)실행 결과 (1,3,2)로 1(행)을 뺀 input_shape=(3,2)가 되므로 이 모델에 적용하기 접합하다.
(1,3,2)
실행 결과
mse : 0.0052490634843707085 [[30.121372]]
예상했던 31이 되어야 하는데 오차가 있다. 이 모델 자체에 약간의 문제가 있다.
이 모델은 RN모델이다. 연속적인 데이터를 계산하는 모델이다. 그런데 입력은 (8,3,2)였다. 얼핏 연속적인 데이터라고 볼 수 있으나 엄밀하게 연속적인 데이터가 아니다.
| x | y | ||
| 1 11 | 2 12 | 3 13 | 23 |
| 2 12 | 3 13 | 4 14 | 24 |
| 3 13 | 4 14 | 5 15 | 25 |
| 4 14 | 5 15 | 6 16 | 26 |
| 5 15 | 6 16 | 7 17 | 27 |
| 6 16 | 7 17 | 8 18 | 28 |
| 7 17 | 8 18 | 9 19 | 29 |
| 8 18 | 9 19 | 10 20 | 30 |
1행을 연산할 때 우리가 이 모델을 처음에 만들었던 방식으로 1,2,3이 연산한 것과 11,12,13이 연산한 것을 계산해서 23이 나오는 형태였다. 하지만 자르고 나니 1,11,2,12,3,13이 연산되어야 23이 나온다. 순서가 섞인 것이다.
모델이 돌아가니 이상이 없다고 판단하기 쉽다. 하지만 이런 수치의 오류가 발생하면 찾기가 힘들다. 모델이 돌아간다고 안심하지 말고, 적은 데이터든 큰 데이터든 간에 실제 데이터가 어떻게 들어가 있는지 확인하는 작업이 필요하다.
전체소스
#1. 데이터
import numpy as np
dataset = np.array([[1,2,3,4,5,6,7,8,9,10],[11,12,13,14,15,16,17,18,19,20],[21,22,23,24,25,26,27,28,29,30]])
print("dataset.shape ", dataset.shape)
dataset = np.transpose(dataset)
print(dataset)
print("dataset.shape :", dataset.shape)
def split_xy3(dataset, time_steps, y_column):
x, y = list(), list()
for i in range(len(dataset)):
x_end_number = i + time_steps
y_end_number = x_end_number + y_column - 1
if y_end_number > len(dataset):
break
tmp_x = dataset[i:x_end_number, :-1]
tmp_y = dataset[x_end_number-1 : y_end_number, -1]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy3(dataset, 3, 1)
print(x, "\n", y)
print(x.shape)
print(y.shape)
y = y.reshape(y.shape[0])
print(y.shape)
from keras.models import Sequential
from keras.layers import Dense, LSTM
#2. 모델 구성
model = Sequential()
model.add(LSTM(64, input_shape=(3, 2)))
model.add(Dense(1))
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=300, batch_size=1)
#4. 평가, 예측
mse = model.evaluate(x, y, batch_size=1)
print("mse :", mse)
x_pred = np.array([[9,10,11],[19,20,21]])
x_pred = np.transpose(x_pred)
x_pred = x_pred.reshape(1, x_pred.shape[0], x_pred.shape[1])
#print(x_pred.shape)
y_pred = model.predict(x_pred, batch_size=1)
print(y_pred)
5. MLP DNN 모델(다입력 다:1)
위 모델을 DNN모델로 변경해서 확인하자.
#1. 데이터
import numpy as np
dataset = np.array([[1,2,3,4,5,6,7,8,9,10],[11,12,13,14,15,16,17,18,19,20],[21,22,23,24,25,26,27,28,29,30]])
print("dataset.shape ", dataset.shape)
dataset = np.transpose(dataset)
print(dataset)
print("dataset.shape :", dataset.shape)
10행 3열의 데이터이다. x와 y로 분리하자.
def split_xy3(dataset, time_steps, y_column):
x, y = list(), list()
for i in range(len(dataset)):
x_end_number = i + time_steps
y_end_number = x_end_number + y_column - 1
if y_end_number > len(dataset):
break
tmp_x = dataset[i:x_end_number, :-1]
tmp_y = dataset[x_end_number-1 : y_end_number, -1]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy3(dataset, 3, 1)
print(x, "\n", y)
print(x.shape)
print(y.shape)
y = y.reshape(y.shape[0])
print(y.shape)
x의 shape는 (8,3,2), y의 shape는 (8,)로 분리되었다.
이제 DNN 모델에 입력하려고 하는데 문제가 있다. DNN 모델은 2차원까지의 shape를 입력받을 수 있다.
(None, 컬럼) 형식으로 input_shape=(?,)로 받아 들여야 한다. 그래서 (8,3,2)로 구성된 shape를 (?,?)로 변경해야 한다.
reshape로 할 경우 (8,3,2)를 우선 '행 무시'이므로 첫 번째 행에 8을 그대로 입력한다. 그러면 (8,?)가 된다.
reshape할 때 항상 주의할 것은 전체 shape를 곱한 값은 reshape한 뒤의 값과 동일해야 한다 (8,3,2)의 전체의 곱은 48이고, 3차원이다. 이것을 2차원으로 줄인다면 8 * ? = 48 이 되어야 한다 ?는 6이다.
그런데 6은 어떤 값일까? (8,3,2)에서 3과 2를 곱한 값이다. 결국 reshape를 할 때 전체 데이터의 shape이 곱은 동일해야 한다.
(8,3,2) = (8,3*2) = (8,6)이 되는 것이다.
x = x.reshape(x.shape[0], x.shape[1] * x.shape[2])
print(y.shape)실행 결과
(8,6)
이제 DNN에 입력할 수 있는 shape가 나왔다. RNN으로 입력할 (8,3,2) 데이터를 DNN에 입력 가능한 (8,6)으로 변경하였다.
#2. 모델 구성
from keras.models import Sequential
from keras.layers import Dense, LSTM
model = Sequential()
#model.add(LSTM(64, input_shape=(3, 2)))
model.add(Dense(64, input_shape=(6, )))
model.add(Dense(1))
LSTM의 input_shape=(3,2)가 Dense에서 input_shape=(6,)로 바뀐 것을 주의하자. 훈련과 평가 예측은 동일하고 x_pred만 조금 변경되었다.
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=300, batch_size=1)
#4. 평가, 예측
mse = model.evaluate(x, y, batch_size=1)
print("mse :", mse)
x_pred = np.array([[9,10,11],[19,20,21]])
print(x_pred.shape)
실행결과
(2,3)
현재 x_pred의 shape는 (2,3)이다. 이것을 DNN모델에 입력할 수 있도록 (1,6) 형태로 변경하자. x_pred_shape[0]은 3이고, x_pred.shape[1]은 2이므로 이 둘을 곱하면 6이다.
x_pred = x_pred.reshape(1, x_pred.shape[0] * x_pred.shape[1])
print(x_pred.shape)
실행결과 (1,6)으로 잘 변경되었다.
y_pred = model.predict(x_pred, batch_size=1)
print(y_pred)
mse : 7.73070496506989e-12 (1, 6) [[31.000002]]
mse는 좋은 수치이나. x_pred는 형편없는 수치가 나왔다. 하이퍼파라미터를 튜닝하여 더 좋은 모델로 변경하자.
전체소스
#1. 데이터
import numpy as np
dataset = np.array([[1,2,3,4,5,6,7,8,9,10],[11,12,13,14,15,16,17,18,19,20],[21,22,23,24,25,26,27,28,29,30]])
print("dataset.shape ", dataset.shape)
dataset = np.transpose(dataset)
print(dataset)
print("dataset.shape :", dataset.shape)
def split_xy3(dataset, time_steps, y_column):
x, y = list(), list()
for i in range(len(dataset)):
x_end_number = i + time_steps
y_end_number = x_end_number + y_column - 1
if y_end_number > len(dataset):
break
tmp_x = dataset[i:x_end_number, :-1]
tmp_y = dataset[x_end_number-1 : y_end_number, -1]
x.append(tmp_x)
y.append(tmp_y)
return np.array(x), np.array(y)
x, y = split_xy3(dataset, 3, 1)
print(x, "\n", y)
print(x.shape)
print(y.shape)
y = y.reshape(y.shape[0])
print(y.shape)
x = x.reshape(x.shape[0], x.shape[1] * x.shape[2])
print(y.shape)
#2. 모델 구성
from keras.models import Sequential
from keras.layers import Dense, LSTM
model = Sequential()
#model.add(LSTM(64, input_shape=(3, 2)))
model.add(Dense(64, input_shape=(6, )))
model.add(Dense(1))
#3. 훈련
model.compile(optimizer='adam', loss='mse')
model.fit(x, y, epochs=300, batch_size=1)
#4. 평가, 예측
mse = model.evaluate(x, y, batch_size=1)
print("mse :", mse)
x_pred = np.array([[9,10,11],[19,20,21]])
x_pred = np.transpose(x_pred)
x_pred = x_pred.reshape(1, x_pred.shape[0] * x_pred.shape[1])
print(x_pred.shape)
y_pred = model.predict(x_pred, batch_size=1)
print(y_pred)
'AI > DeepLearning' 카테고리의 다른 글
| RNN 모델 정리 2 (0) | 2020.10.10 |
|---|---|
| RNN용 데이터 자르기 (0) | 2020.10.06 |
| 케라스 모델의 파라미터들과 기타 기법들 (0) | 2020.10.06 |
| 시계열 모델 1 RNN (0) | 2020.10.05 |
| 회귀 모델 정리 - 앙상블 및 기타 모델 (0) | 2020.07.13 |