코인 가격 예측 스터디노트 - 3. RNN(LSTM) 모델링

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
ratios = ["BTC-USD", "LTC-USD", "ETH-USD"]
for ratio in ratios:
    dataset = f'training_datas/{ratio}.csv'
    df = pd.read_csv(dataset, names=['time','low','high','open','close','volume'])

    df.rename(columns={"close": f"{ratio}_close", "volume" : f"{ratio}_volume"}, inplace=True)


    # 일단 time을 index로 두고, 컬럼은 종가와 거래량만 남김
    df.set_index("time", inplace=True)
    df = df[[f"{ratio}_close", f"{ratio}_volume"]]
    # 그리고 이것들을 join한다 -> 여러 코인 데이터를 하나의 df에 join
    if len(main_df)==0:
        main_df = df
    else:
        main_df = main_df.join(df)

main_df.fillna(method="ffill",inplace=True)
main_df.dropna(inplace=True)
print(main_df.head())


## target값,즉 등락을 표시하기 위한 함수
def classify(current, future): #현재와 미래 가격을 인자로 받아서
    if float(future) > float(current):
        return 1 # 오르면 1
    else:
        return 0 # 떨어지면 0

#여기서 미래의 가격이란 3분 후의 가격
main_df['future'] = main_df[f'{RATIO_TO_PREDICT}_close'].shift(-FUTURE_PERIOD_PREDICT)
#그래서 위의 classfy 함수를 돌려 target value를 구한다
main_df['target'] = list(map(classify, main_df[f'{RATIO_TO_PREDICT}_close'], main_df['future']))


# test train split
#시간순으로 마지막 5%에 해당하는 데이터를 테스트 데이터로 쓴다
times = sorted(main_df.index.values) # get the times
last_5pct = sorted(main_df.index.values)[-int(0.05*len(times))]

# validation_main_df는 마지막 5% 이내 시간
validation_main_df = main_df[(main_df.index >= last_5pct)]
# main_df는 앞의 95% 시간에 해당하는 데이터가 들어감
main_df = main_df[(main_df.index < last_5pct)]

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
def preprocess_df(df):
    df = df.drop("future", axis=1) #필요없는 컬럼은 제거 (왜 위에서 안 지웠지?)

    #코인마다 가격이 닫르므로 스케일링을 해주어야 합니다.
    #여기서는 percent chnage를 하고 다시 sklearn.preprocessing.scale를 썼는디
    #구체적으로 어떤식으로 스케일링을 하는지는 찾아보지 않았습니다.
    for col in df.columns:
        if col != "target":
            df[col] = df[col].pct_change() #퍼센트 체인지
            df.dropna(inplace=True)
            df[col] = preprocessing.scale(df[col].values)

    # sentdex가 na는 잘 생긴다고 안전빵으로 dropna 한다고 했습니다.
    df.dropna(inplace=True)

    #자 이제 한 묶음으로 때려넣을 데이터를 묶습니다.
    sequential_data = []
    #deque는 배열에 새로운 데이터가 들어와도 length를 유지해주는 친구입니다.
    #배열이 꽉 찼는데 새로 뭐가 들어오면 맨 뒤에는 팅겨나가는 방식으로
    #크기를 유지합니다. 여기서는 SEQ_LEN, 즉 60개가 배열 크기가 됩니다.
    prev_days = deque(maxlen=SEQ_LEN)


    for i in  df.values:
        prev_days.append([n for n in i[:-1]]) #타겟 빼놓고 나머지를 pre_days에 어펜드
        if len(prev_days) == SEQ_LEN: #pre_days에 60개가 꽉차면
            sequential_data.append([np.array(prev_days),i[-1]]) #sequential_data에 target과 함께 어펜드
    random.shuffle(sequential_data)


    ## blancing
    # target이 1이면 사라, 0이면 팔아라,의 신호인데
    # 데이터 불균형이 있을 수 있으므로 그것을 맞추는 작업
    buys = []
    sells = []

    for seq, target in sequential_data:
        #타겟이 0이면 팔아라에 넣고
        if target == 0:
            sells.append([seq, target])
        #타겟이 1이면 사라에 넣는다
        elif target == 1:
            buys.append([seq, target])

    random.shuffle(buys)
    random.shuffle(sells)

    # 두 데이터의 숫자를 맞춰주려고 함(둘 중 숫자가 작은 것으로)
    lower = min(len(buys), len(sells))

    #위에서 미리 셔플해놨으므로 그냥 슬라이싱 하면 됨.
    buys = buys[:lower]
    sells = sells[:lower]

    # 둘을 합쳐서 학습 데이터에 넣고
    sequential_data = buys+sells
    random.shuffle(sequential_data)

    # test train split
    X = []
    y = []

    for seq, target in sequential_data:
        X.append(seq)
        y.append(target)

    return np.array(X), y

1
2
train_x, train_y = preprocess_df(main_df)
validation_x, validation_y = preprocess_df(validation_main_df)

1
2
3
4
5
6
7
8
import time
EPOCHS = 10
BATCH_SIZE=64

#요거는 로그를 저장할 때 쓸 이름입니다.
#하이퍼 파라미터를 이름에 들어가게 하는 건 좋은 방법인 것 같아요.
#시간도 집어넣어서 겹치는 일이 없도록 합니다.
NAME = f"{SEQ_LEN}-SEQ-{FUTURE_PERIOD_PREDICT}-PRED-{int(time.time())}"

1
2
3
4
5
6
import tensorflow as tf
from keras.models import Sequential
from keras.layers import Dense, Dropout, LSTM, CuDNNLSTM, BatchNormalization
from keras.callbacks import TensorBoard
from keras.callbacks import ModelCheckpoint, ModelCheckpoint
from keras.optimizers import Adam

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
model = Sequential()

model.add(CuDNNLSTM(128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2)) #오버피팅을 막고자 일부를 버림
model.add(BatchNormalization())

model.add(CuDNNLSTM(128, return_sequences=True))
model.add(Dropout(0.1))
model.add(BatchNormalization())

model.add(CuDNNLSTM(128))
model.add(Dropout(0.2))
model.add(BatchNormalization())

model.add(Dense(32, activation = 'relu'))
model.add(Dropout(0.2))

model.add(Dense(2, activation='softmax'))

opt = Adam(lr=0.001, decay=1e-6)

# Compile model
model.compile(
    loss='sparse_categorical_crossentropy',
    optimizer=opt,
    metrics=['accuracy']
)

1
2
logs 폴더에 로그를 저장합니다.
tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))

1
2
3
4
filepath = "RNN_Final-{epoch:02d}-{val_acc:.3f}"  
# val_acc가 가장 높을 때의 모델을 자동으로 저장하도록 합니다. (사실 자세히 모름)
checkpoint = ModelCheckpoint("models/{}.model".format(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')) # saves only the best ones

1
2
3
4
5
6
7
8
# Train model
history = model.fit(
    train_x, train_y,
    batch_size=BATCH_SIZE,
    epochs=EPOCHS,
    validation_data=(validation_x, validation_y),
    callbacks=[tensorboard, checkpoint],
)

1
2
3
4
5
6
# Score model
score = model.evaluate(validation_x, validation_y, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
# Save model
model.save("models/{}".format(NAME))

1
2
Test loss: 0.6774762500753057
Test accuracy: 0.5704663213670562