Блог

Я использую алгоритм глубокого обучения для прогнозирования цен на криптовалютных рынках. Этот код только предсказывает даты, которые уже есть в наборах данных. Код использует время unix в качестве ввода даты. Как я могу получить будущие прогнозы?

Мой набор данных с 1 августа 2015 года по 1 августа 2020 года. Я хочу предсказать 1 августа 2020 года — 1 сентября 2020 года; но он прогнозирует до 1 августа 2020 года последним.

Вкратце, я хочу предсказать даты, которые еще не включены в мой набор данных.

 def train_test_split(df, test_size=0.2):
    split_row = len(df) - int(test_size * len(df))
    train_data = df.iloc[:split_row]
    test_data = df.iloc[split_row:]
    return train_data, test_data
train, test = train_test_split(hist, test_size=0.2)

def line_plot(line1, line2, label1=None, label2=None, title=Crypto, lw=2):
    fig, ax = plt.subplots(1, figsize=(13, 7))
    ax.plot(line1, label=label1, linewidth=lw)
    ax.plot(line2, label=label2, linewidth=lw)
    ax.set_ylabel('price [USD]', fontsize=14)
    #ax.set_xlabel('Time [day]', fontsize=14)
    ax.set_title(title, fontsize=16)
    ax.legend(loc='best', fontsize=16)
line_plot(train[target_col], test[target_col], 'training', 'test', title='')

def normalise_zero_base(df):
    return df / df.iloc[0] - 1

def normalise_min_max(df):
    return (df - df.min()) / (df.max() - df.min())

def extract_window_data(df, window_len=5, zero_base=True):
    window_data = []
    for idx in range(len(df) - window_len):
        tmp = df[idx: (idx   window_len)].copy()
        if zero_base:
            tmp = normalise_zero_base(tmp)
        window_data.append(tmp.values)
    return np.array(window_data)

def prepare_data(df, target_col, window_len=10, zero_base=True, test_size=0.2):
    train_data, test_data = train_test_split(df, test_size=test_size)
    X_train = extract_window_data(train_data, window_len, zero_base)
    X_test = extract_window_data(test_data, window_len, zero_base)
    y_train = train_data[target_col][window_len:].values
    y_test = test_data[target_col][window_len:].values
    if zero_base:
        y_train = y_train / train_data[target_col][:-window_len].values - 1
        y_test = y_test / test_data[target_col][:-window_len].values - 1

    return train_data, test_data, X_train, X_test, y_train, y_test

def build_lstm_model(input_data, output_size, neurons=100, activ_func='linear', dropout=0.2, loss='mse', optimizer='adam'):
    model = Sequential()
    model.add(LSTM(neurons, input_shape=(input_data.shape[1], input_data.shape[2])))
    model.add(Dropout(dropout))
    model.add(Dense(units=output_size))
    model.add(Activation(activ_func))
    model.compile(loss=loss, optimizer=optimizer)
    return model

np.random.seed(42)
window_len = 5
test_size = 0.2
zero_base = True
lstm_neurons = 100
epochs = 100
batch_size = 32
loss = 'mse'
dropout = 0.2
optimizer = 'adam'

train, test, X_train, X_test, y_train, y_test = prepare_data(
    hist, target_col, window_len=window_len, zero_base=zero_base, test_size=test_size)
model = build_lstm_model(
    X_train, output_size=1, neurons=lstm_neurons, dropout=dropout, loss=loss,
    optimizer=optimizer)
history = model.fit(
    X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1, shuffle=True)

targets = test[target_col][window_len:]
preds = model.predict(X_test).squeeze()
mean_absolute_error(preds, y_test)
# 0.027955859325876943

preds = test[target_col].values[:-window_len] * (preds   1)
preds = pd.Series(index=targets.index, data=preds)
line_plot(targets, preds, 'actual', 'prediction', lw=3)
 

Фото примера набора данных

Фото результатов обучения

Фотография вывода прогноза

Итак, вы используете 10 временных шагов для прогнозирования следующего временного шага. Если вы хотите предсказать будущую цену с помощью вашей обученной модели, вы должны использовать свои прогнозы в качестве входных данных.

Следующий рисунок позволяет лучше понять, как это работает. * Указывает на прогнозируемое значение, в отличие от реальных значений. Итак 1 ... 8 9 10 , ваши 10 последних реальных значений. -> Указывает на вашу функцию модели.

 input -> output*

1 ... 8 9 10 -> 11*

2 ... 9 10 11* -> 12*

3 ... 10 11* 12* -> 13*

...

n-9* ... n-2* n-1* n* -> n 1*