LSTM(Python 코드)을 이용한 매출 예측

우리는 브랜드 매출 예측, 제품 매출 예측 등 예측이 필요한 시나리오를 자주 접하게 됩니다.

오늘 저는 엔드투엔드 시계열 예측을 위해 LSTM을 사용하는 방법에 대한 완전한 코드와 자세한 설명을 여러분과 공유하고 싶습니다.

먼저 두 가지 주제를 이해해 보겠습니다.

• 시계열 분석이란 무엇입니까?
• LSTM이란 무엇인가요?
  

시계열 분석: 시계열은 시간 순서에 따른 일련의 데이터를 나타냅니다. 초, 분, 시간, 일, 주, 월, 년이 될 수 있습니다. 향후 데이터는 이전 값에 따라 달라집니다.

실제 사례에서는 주로 두 가지 유형의 시계열 분석을 사용합니다.

• 단변량 시계열
  
• 다변량 시계열
  

단변량 시계열 데이터의 경우 단일 열을 사용하여 예측합니다.

보시다시피 열이 하나뿐이므로 향후 미래 값은 이전 값에만 의존합니다.

그러나 다변량 시계열 데이터의 경우 다양한 유형의 특성 값이 있으며 이러한 특성에 따라 대상 데이터가 달라집니다.

그림에서 볼 수 있듯이 다변량 변수에는 목표 값을 예측하는 여러 열이 있습니다. (위 그림의 "count"는 목표 값입니다.)

위 데이터에서 count는 이전 값뿐만 아니라 다른 특성에 따라 달라집니다. 따라서 다가오는 카운트 값을 예측하려면 대상 열을 포함한 모든 열을 고려하여 대상 값을 예측해야 합니다.

다변수 시계열 분석을 수행할 때 기억해야 할 한 가지는 여러 특성을 사용하여 현재 목표를 예측해야 한다는 것입니다. 예를 통해 이해해 보겠습니다.

학습 시 5개의 열을 사용하면 [feature1, feature2, feature3, feature4, target] 모델을 훈련하려면 다가오는 예측일에 대해 4개의 열 [feature1, feature2, feature3, feature4]을 제공해야 합니다.

LSTM

이 기사에서는 LSTM에 대해 자세히 논의하지 않을 것입니다. 그래서 LSTM에 대해 잘 모르신다면 이전 글을 참고하시면 됩니다.

LSTM은 기본적으로 장기적인 종속성을 처리할 수 있는 순환 신경망입니다.

영화를 보고 있다고 가정해 보세요. 따라서 영화에서 어떤 일이 일어나면 이전에 무슨 일이 일어났는지 이미 알고 있고 과거에 일어난 일로 인해 새로운 일이 일어나고 있다는 것을 이해합니다. RNN은 동일한 방식으로 작동하며 과거 정보를 기억하고 이를 사용하여 현재 입력을 처리합니다. RNN의 문제점은 그래디언트 소멸로 인해 장기적인 종속성을 기억할 수 없다는 것입니다. 따라서 lstm은 장기적인 종속성 문제를 방지하도록 설계되었습니다.

이제 시계열 예측과 LSTM 이론 부분에 대해 논의했습니다. 코딩을 시작해 보겠습니다.

먼저 예측에 필요한 라이브러리를 가져옵니다.

import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM
from tensorflow.keras.layers import Dense, Dropout
from sklearn.preprocessing import MinMaxScaler
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import GridSearchCV

데이터 로드 및 출력 확인:

df=pd.read_csv("train.csv",parse_dates=["Date"],index_col=[0])
df.head()

df.tail()

이제 잠시 데이터를 살펴보겠습니다. csv 파일에는 다음이 포함되어 있습니다. 2001년 1월 25일부터 2021년 9월 29일까지의 Google 주식 데이터는 일 빈도를 기준으로 합니다.

[원하시면 빈도를 "B"(근무일) 또는 "D"로 변환하실 수 있습니다. 날짜를 사용하지 않을 것이므로 그대로 유지하고 있습니다. ]

여기에서는 "Open" 열의 미래 가치를 예측하려고 하므로 여기서는 "Open"이 대상 열입니다.

데이터의 모양을 살펴보겠습니다.

df.shape
(5203,5)

이제 열차-테스트 분할을 해보겠습니다. 여기서는 데이터가 시계열적으로 순차적이어야 하므로 데이터를 섞을 수 없습니다.

test_split=round(len(df)*0.20)
df_for_training=df[:-1041]
df_for_testing=df[-1041:]
print(df_for_training.shape)
print(df_for_testing.shape)
(4162, 5)
(1041, 5)

데이터 범위가 매우 크고 동일한 범위에서 스케일링되지 않음을 알 수 있으므로 예측 오류를 피하기 위해 먼저 MinMaxScaler를 사용하여 데이터 스케일을 조정해 보겠습니다. (StandardScaler를 사용할 수도 있습니다)

scaler = MinMaxScaler(feature_range=(0,1))
df_for_training_scaled = scaler.fit_transform(df_for_training)
df_for_testing_scaled=scaler.transform(df_for_testing)
df_for_training_scaled

데이터를 X와 Y로 분할합니다. 이것이 가장 중요한 부분입니다. 모든 단계를 올바르게 읽으십시오.

def createXY(dataset,n_past):
 dataX = []
 dataY = []
 for i in range(n_past, len(dataset)):
 dataX.append(dataset[i - n_past:i, 0:dataset.shape[1]])
 dataY.append(dataset[i,0])
 return np.array(dataX),np.array(dataY)
trainX,trainY=createXY(df_for_training_scaled,30)
testX,testY=createXY(df_for_testing_scaled,30)

위 코드에서 수행된 작업을 살펴보겠습니다.

N_past는 다음 목표 값을 예측할 때 과거를 살펴볼 단계 수입니다.

여기서 30을 사용한다는 것은 지난 30개의 값(타겟 열을 포함한 모든 특성)을 사용하여 31번째 타겟 값을 예측한다는 의미입니다.

因此，在trainX中我们会有所有的特征值，而在trainY中我们只有目标值。

让我们分解for循环的每一部分：

对于训练，dataset = df_for_training_scaled, n_past=30

当i= 30：

data_X.addend (df_for_training_scaled[i - n_past:i, 0:df_for_training.shape[1]])

从n_past开始的范围是30，所以第一次数据范围将是-[30 - 30,30,0:5] 相当于 [0:30,0:5]

因此在dataX列表中，df_for_training_scaled[0:30,0:5]数组将第一次出现。

现在, dataY.append(df_for_training_scaled[i,0])

i = 30，所以它将只取第30行开始的open(因为在预测中，我们只需要open列，所以列范围仅为0，表示open列)。

第一次在dataY列表中存储df_for_training_scaled[30,0]值。

所以包含5列的前30行存储在dataX中，只有open列的第31行存储在dataY中。然后我们将dataX和dataY列表转换为数组，它们以数组格式在LSTM中进行训练。

我们来看看形状。

print("trainX Shape-- ",trainX.shape)
print("trainY Shape-- ",trainY.shape)
(4132, 30, 5)
(4132,)
print("testX Shape-- ",testX.shape)
print("testY Shape-- ",testY.shape)
(1011, 30, 5)
(1011,)

4132 是 trainX 中可用的数组总数，每个数组共有 30 行和 5 列， 在每个数组的 trainY 中，我们都有下一个目标值来训练模型。

让我们看一下包含来自 trainX 的 (30,5) 数据的数组之一 和 trainX 数组的 trainY 值：

print("trainX[0]-- n",trainX[0])
print("trainY[0]-- ",trainY[0])

如果查看 trainX[1] 值，会发现到它与 trainX[0] 中的数据相同（第一列除外），因为我们将看到前 30 个来预测第 31 列，在第一次预测之后它会自动移动 到第 2 列并取下一个 30 值来预测下一个目标值。

让我们用一种简单的格式来解释这一切：

trainX — — →trainY
[0 : 30,0:5] → [30,0]
[1:31, 0:5] → [31,0]
[2:32,0:5] →[32,0]

像这样，每个数据都将保存在 trainX 和 trainY 中。

现在让我们训练模型，我使用 girdsearchCV 进行一些超参数调整以找到基础模型。

def build_model(optimizer):
 grid_model = Sequential()
 grid_model.add(LSTM(50,return_sequences=True,input_shape=(30,5)))
 grid_model.add(LSTM(50))
 grid_model.add(Dropout(0.2))
 grid_model.add(Dense(1))
grid_model.compile(loss = 'mse',optimizer = optimizer)
 return grid_modelgrid_model = KerasRegressor(build_fn=build_model,verbose=1,validation_data=(testX,testY))
parameters = {'batch_size' : [16,20],
 'epochs' : [8,10],
 'optimizer' : ['adam','Adadelta'] }
grid_search = GridSearchCV(estimator = grid_model,
 param_grid = parameters,
 cv = 2)

如果你想为你的模型做更多的超参数调整，也可以添加更多的层。但是如果数据集非常大建议增加 LSTM 模型中的时期和单位。

在第一个 LSTM 层中看到输入形状为 (30,5)。它来自 trainX 形状。

(trainX.shape[1],trainX.shape[2]) → (30,5)

现在让我们将模型拟合到 trainX 和 trainY 数据中。

grid_search = grid_search.fit(trainX,trainY)

由于进行了超参数搜索，所以这将需要一些时间来运行。

你可以看到损失会像这样减少：

现在让我们检查模型的最佳参数。

grid_search.best_params_
{‘batch_size’: 20, ‘epochs’: 10, ‘optimizer’: ‘adam’}

将最佳模型保存在 my_model 变量中。

my_model=grid_search.best_estimator_.model

现在可以用测试数据集测试模型。

prediction=my_model.predict(testX)
print("predictionn", prediction)
print("nPrediction Shape-",prediction.shape)

testY 和 prediction 的长度是一样的。现在可以将 testY 与预测进行比较。

但是我们一开始就对数据进行了缩放，所以首先我们必须做一些逆缩放过程。

scaler.inverse_transform(prediction)

报错了，这是因为在缩放数据时，我们每行有 5 列，现在我们只有 1 列是目标列。

所以我们必须改变形状来使用 inverse_transform：

prediction_copies_array = np.repeat(prediction,5, axis=-1)

5 列值是相似的，它只是将单个预测列复制了 4 次。所以现在我们有 5 列相同的值 。

prediction_copies_array.shape
(1011,5)

这样就可以使用 inverse_transform 函数。

pred=scaler.inverse_transform(np.reshape(prediction_copies_array,(len(prediction),5)))[:,0]

但是逆变换后的第一列是我们需要的，所以我们在最后使用了 → [:,0]。

现在将这个 pred 值与 testY 进行比较，但是 testY 也是按比例缩放的，也需要使用与上述相同的代码进行逆变换。

original_copies_array = np.repeat(testY,5, axis=-1)
original=scaler.inverse_transform(np.reshape(original_copies_array,(len(testY),5)))[:,0]

现在让我们看一下预测值和原始值：

print("Pred Values-- " ,pred)
print("nOriginal Values-- " ,original)

最后绘制一个图来对比我们的 pred 和原始数据。

plt.plot(original, color = 'red', label = 'Real Stock Price')
plt.plot(pred, color = 'blue', label = 'Predicted Stock Price')
plt.title('Stock Price Prediction')
plt.xlabel('Time')
plt.ylabel('Google Stock Price')
plt.legend()
plt.show()

看样子还不错，到目前为止，我们训练了模型并用测试值检查了该模型。现在让我们预测一些未来值。

从主 df 数据集中获取我们在开始时加载的最后 30 个值[为什么是 30？因为这是我们想要的过去值的数量，来预测第 31 个值]

df_30_days_past=df.iloc[-30:,:]
df_30_days_past.tail()

可以看到有包括目标列（“Open”）在内的所有列。现在让我们预测未来的 30 个值。

在多元时间序列预测中，需要通过使用不同的特征来预测单列，所以在进行预测时我们需要使用特征值（目标列除外）来进行即将到来的预测。

这里我们需要“High”、“Low”、“Close”、“Adj Close”列的即将到来的 30 个值来对“Open”列进行预测。

df_30_days_future=pd.read_csv("test.csv",parse_dates=["Date"],index_col=[0])
df_30_days_future

剔除“Open”列后，使用模型进行预测之前还需要做以下的操作：

缩放数据，因为删除了‘Open’列，在缩放它之前，添加一个所有值都为“0”的Open列。

缩放后，将未来数据中的“Open”列值替换为“nan”

现在附加 30 天旧值和 30 天新值（其中最后 30 个“打开”值是 nan）

df_30_days_future["Open"]=0
df_30_days_future=df_30_days_future[["Open","High","Low","Close","Adj Close"]]
old_scaled_array=scaler.transform(df_30_days_past)
new_scaled_array=scaler.transform(df_30_days_future)
new_scaled_df=pd.DataFrame(new_scaled_array)
new_scaled_df.iloc[:,0]=np.nan
full_df=pd.concat([pd.DataFrame(old_scaled_array),new_scaled_df]).reset_index().drop(["index"],axis=1)

full_df 形状是 (60,5)，最后第一列有 30 个 nan 值。

要进行预测必须再次使用 for 循环，我们在拆分 trainX 和 trainY 中的数据时所做的。但是这次我们只有 X，没有 Y 值。

full_df_scaled_array=full_df.values
all_data=[]
time_step=30
for i in range(time_step,len(full_df_scaled_array)):
 data_x=[]
 data_x.append(
 full_df_scaled_array[i-time_step :i , 0:full_df_scaled_array.shape[1]])
 data_x=np.array(data_x)
 prediction=my_model.predict(data_x)
 all_data.append(prediction)
 full_df.iloc[i,0]=prediction

对于第一个预测，有之前的 30 个值，当 for 循环第一次运行时它会检查前 30 个值并预测第 31 个“Open”数据。

当第二个 for 循环将尝试运行时，它将跳过第一行并尝试获取下 30 个值 [1:31] 。这里会报错错误因为Open列最后一行是 “nan”，所以需要每次都用预测替换“nan”。

最后还需要对预测进行逆变换：

new_array=np.array(all_data)
new_array=new_array.reshape(-1,1)
prediction_copies_array = np.repeat(new_array,5, axis=-1)
y_pred_future_30_days = scaler.inverse_transform(np.reshape(prediction_copies_array,(len(new_array),5)))[:,0]
print(y_pred_future_30_days)

这样一个完整的流程就已经跑通了。

如果你想看完整的代码，可以在这里查看：

​​https://www.php.cn/link/dd95829de39fe21f384685c07a1628d8​​

위 내용은 LSTM(Python 코드)을 이용한 매출 예측의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!