点击上方“AI公园”，关注公众号，选择加“星标“或“置顶”

作者：Barış KaramanFollow

编译：ronghuaiyang

正文共：6867 字 16 图

预计阅读时间：20 分钟

导读

预测销量有很多的用处，这是一个时间序列的预测问题，我们可以使用传统的时序回归的方法，也可以使用机器学习，深度学习的方法，一起来了解一下。

前文回顾：

用机器学习来提升你的用户增长：第一步，了解你的目标

用机器学习来提升你的用户增长：第二步，客户分群

用机器学习来提升你的用户增长：第三步，预测客户的终生价值

用机器学习来提升你的用户增长：第四步，客户流失预测

用机器学习来提升你的用户增长：第五步，预测客户的下一个购买日

第六部分: 预测销量

在本节之前，几乎所有的预测模型都是基于客户层面的(例如客户流失预测、下一个购买日等)。但有时候，我们从全局的角度看一看，也是有用的。通过考虑我们在客户方面的所做的努力，我们该如何影响销售？

时间序列预测是机器学习的主要组成部分之一。文献中有许多方法可以实现这一目的，如自回归综合移动平均(ARIMA)、季节自回归综合移动平均(SARIMA)、向量自回归(VAR)等。

在这篇文章中，我们将关注长短时记忆(LSTM)方法，如果你想使用深度学习，这是一种非常流行的方法。我们将在我们的项目中使用Keras来实现LSTM。

最后，了解未来的销售情况对我们的业务有什么帮助？

首先，它是一个基准。如果我们的战略没有改变的话，我们可以把它作为我们要达到的业务水平来使用。此外，我们可以在这个基准上计算新行为导致的增量值。

其次，它可以用于规划。我们可以通过预测来计划我们的需求和供应行为。这有助于找到更多的投资方向。

最后但并非最不重要的是，它是规划预算和目标的优秀指南。

现在我们开始写代码并建立我们的第一个深度学习模型。

我们模型的实现有3个步骤：

• 数据整理

• 数据变换，使其稳定并定义监督信号

• 建立LSTM模型并评估

数据整理

在本例中，我们使用来自Kaggle竞赛中的数据集。它包含每个商店和物品的每日销售额。

像往常一样，我们导入所需的库，并从CSV导入我们的数据：

1. from datetime import datetime, timedelta,date

2. import pandas as pd

3. %matplotlib inline

4. import matplotlib.pyplot as plt

5. import numpy as np

6. from __future__ import division

7.  

8. import warnings

9. warnings.filterwarnings("ignore")

10.  

11. import plotly.plotly as py

12. import plotly.offline as pyoff

13. import plotly.graph_objs as go

14.  

15. #import Keras

16. import keras

17. from keras.layers import Dense

18. from keras.models import Sequential

19. from keras.optimizers import Adam 

20. from keras.callbacks import EarlyStopping

21. from keras.utils import np_utils

22. from keras.layers import LSTM

23. from sklearn.model_selection import KFold, cross_val_score, train_test_split

24.  

25. #initiate plotly

26. pyoff.init_notebook_mode()

27.  

28. #read the data in csv

29. df_sales = pd.read_csv('sales_data.csv')

30.  

31. #convert date field from string to datetime

32. df_sales['date'] = pd.to_datetime(df_sales['date'])

33.  

34. #show first 10 rows

35. df_sales.head(10)

我们的数据看起来如下：

我们的任务是预测每月的总销售额。我们需要按月汇总数据并汇总sales列。

1. #represent month in date field as its first day

2. df_sales['date'] = df_sales['date'].dt.year.astype('str') + '-' + df_sales['date'].dt.month.astype('str') + '-01'

3. df_sales['date'] = pd.to_datetime(df_sales['date'])

4.  

5. #groupby date and sum the sales

6. df_sales = df_sales.groupby('date').sales.sum().reset_index()

在应用了上面的代码后，df_sales现在显示的是我们需要的总销售额：

数据变换

为了使我们的预测模型更容易和更准确，我们将进行以下变换：

• 如果数据不平稳，我们将把数据转换成平稳的

• 转换成有监督的适合LSTM模型的时间序列特征集合

• 按比例缩放数据

首先，我们如何检查数据是否是稳定的？我们把它画出来看看：

1. #plot monthly sales

2. plot_data = [

3.     go.Scatter(

4.         x=df_sales['date'],

5.         y=df_sales['sales'],

6.     )

7. ]

8.  

9. plot_layout = go.Layout(

10.         title='Montly Sales'

11.     )

12. fig = go.Figure(data=plot_data, layout=plot_layout)

13. pyoff.iplot(fig)

每月的销售额图：

月销售额——不稳定

很明显，它不是稳定的，在过去几个月里有上升的趋势。一种方法是获得当前月的销售与前一个月的差异，并在此基础上建立模型：

1. #create a new dataframe to model the difference

2. df_diff = df_sales.copy()

3.  

4. #add previous sales to the next row

5. df_diff['prev_sales'] = df_diff['sales'].shift(1)

6.  

7. #drop the null values and calculate the difference

8. df_diff = df_diff.dropna()

9. df_diff['diff'] = (df_diff['sales'] - df_diff['prev_sales'])

10. df_diff.head(10)

现在，我们有了所需要的dataframe来建模这个差别：

我们把这个差别画出来，然后看看是否稳定：

1. #plot sales diff

2. plot_data = [

3.     go.Scatter(

4.         x=df_diff['date'],

5.         y=df_diff['diff'],

6.     )

7. ]plot_layout = go.Layout(

8.         title='Montly Sales Diff'

9.     )

10. fig = go.Figure(data=plot_data, layout=plot_layout)

11. pyoff.iplot(fig)

月销售额的差别 —— 稳定

完美！现在我们可以开始构建我们的特征集了。我们需要使用以前的月销售数据来预测下一个月。每个模型的回溯区间可能不同。对于这个例子，我们的值是12。

所以我们需要做的是创建从lag_1到lag_12的列，并使用**shift()**方法赋值：

1. #create dataframe for transformation from time series to supervised

2. df_supervised = df_diff.drop(['prev_sales'],axis=1)

3.  

4. #adding lags

5. for inc in range(1,13):

6.     field_name = 'lag_' + str(inc)

7.     df_supervised[field_name] = df_supervised['diff'].shift(inc)

8.  

9. #drop null values

10. df_supervised = df_supervised.dropna().reset_index(drop=True)

看看我们这个叫做df_supervised的新dataframe：

我们现在有了特征集。让我们更好奇地问这个问题：

我们的特征对于预测有多少用？

Adjusted R-squared就是答案。它告诉我们，我们的特征在多大程度上解释了标签的变化(在我们的示例中，差从lag_1到lag_12)。

让我们来看一个例子：

1. # Import statsmodels.formula.api

2. import statsmodels.formula.api as smf

3.  

4. # Define the regression formula

5. model = smf.ols(formula='diff ~ lag_1', data=df_supervised)

6.  

7. # Fit the regression

8. model_fit = model.fit()

9.  

10. # Extract the adjusted r-squared

11. regression_adj_rsq = model_fit.rsquared_adj

12. print(regression_adj_rsq)

上面的代码做了什么事情？

我们拟合了一个线性回归模型(OLS - Ordinary Least Squares)，并计算了Adjusted R-squared。对于上面的例子，我们使用lag_1列来查看它在多大程度上解释了列diff中的变化。该代码的输出为：

lag_1解释了3%的变化。让我们看看其他的：

再增加四个特征，得分从3%提高到44%。

如果我们使用整个特征集，得分是多少：

结果非常好，分数是98%。现在，我们可以在对数据缩放之后自信地构建我们的模型。但是在缩放之前还有一个步骤。我们应该把数据分成训练集和测试集。作为测试集，我们选择了最近6个月的销售额。

1. #import MinMaxScaler and create a new dataframe for LSTM model

2. from sklearn.preprocessing import MinMaxScaler

3. df_model = df_supervised.drop(['sales','date'],axis=1)

4.  

5. #split train and test set

6. train_set, test_set = df_model[0:-6].values, df_model[-6:].values

我们使用MinMaxScaler，它对每个特征缩放到-1和1之间：

1. #apply Min Max Scaler

2. scaler = MinMaxScaler(feature_range=(-1, 1))

3. scaler = scaler.fit(train_set)

4.  

5. # reshape training set

6. train_set = train_set.reshape(train_set.shape[0], train_set.shape[1])

7. train_set_scaled = scaler.transform(train_set)

8.  

9. # reshape test set

10. test_set = test_set.reshape(test_set.shape[0], test_set.shape[1])

11. test_set_scaled = scaler.transform(test_set)

构建LSTM模型

一切都准备好了，来建立我们的第一个深度学习模型。让我们从缩放后的数据集创建特征和标签：

1. X_train, y_train = train_set_scaled[:, 1:], train_set_scaled[:, 0:1]

2. X_train = X_train.reshape(X_train.shape[0], 1, X_train.shape[1])

3.  

4. X_test, y_test = test_set_scaled[:, 1:], test_set_scaled[:, 0:1]

5. X_test = X_test.reshape(X_test.shape[0], 1, X_test.shape[1])

我们拟合一下LSTM模型：

1. model = Sequential()

2. model.add(LSTM(4, batch_input_shape=(1, X_train.shape[1], X_train.shape[2]), stateful=True))

3. model.add(Dense(1))

4. model.compile(loss='mean_squared_error', optimizer='adam')

5. model.fit(X_train, y_train, nb_epoch=100, batch_size=1, verbose=1, shuffle=False)

上面的代码块打印出了模型是如何更新的，在每个epoch中误差是如何减少的：

我们来做一下预测，看看结果怎么样：

1. y_pred = model.predict(X_test,batch_size=1)

2. #for multistep prediction, you need to replace X_test values with the predictions coming from t-1

结果看起来很相似，但它并不能告诉我们多少信息，因为这些是差异的缩放后的数据。我们怎样才能看到实际的销售预测呢?

首先，我们需要做缩放的逆变换：

1. #reshape y_pred

2. y_pred = y_pred.reshape(y_pred.shape[0], 1, y_pred.shape[1])

3.  

4. #rebuild test set for inverse transform

5. pred_test_set = []

6. for index in range(0,len(y_pred)):

7.     print np.concatenate([y_pred[index],X_test[index]],axis=1)

8.     pred_test_set.append(np.concatenate([y_pred[index],X_test[index]],axis=1))

9.     

10. #reshape pred_test_set

11. pred_test_set = np.array(pred_test_set)

12. pred_test_set = pred_test_set.reshape(pred_test_set.shape[0], pred_test_set.shape[2])

13.  

14. #inverse transform

15. pred_test_set_inverted = scaler.inverse_transform(pred_test_set)

其次，我们需要构建具有日期和预测的dataframe。转换后的预测显示出了这种差异。我们计算预测的销售数字：

1. #create dataframe that shows the predicted sales

2. result_list = []

3. sales_dates = list(df_sales[-7:].date)

4. act_sales = list(df_sales[-7:].sales)

5. for index in range(0,len(pred_test_set_inverted)):

6.     result_dict = {}

7.     result_dict['pred_value'] = int(pred_test_set_inverted[index][0] + act_sales[index])

8.     result_dict['date'] = sales_dates[index+1]

9.     result_list.append(result_dict)

10. df_result = pd.DataFrame(result_list)

11.  

12. #for multistep prediction, replace act_sales with the predicted sales

输出：

太棒了！我们预测了未来六个月的销售数字。让我们在图中检查一下，看看我们的模型有多好：

1. #merge with actual sales dataframe

2. df_sales_pred = pd.merge(df_sales,df_result,on='date',how='left')

3.  

4. #plot actual and predicted

5. plot_data = [

6.     go.Scatter(

7.         x=df_sales_pred['date'],

8.         y=df_sales_pred['sales'],

9.         name='actual'

10.     ),

11.         go.Scatter(

12.         x=df_sales_pred['date'],

13.         y=df_sales_pred['pred_value'],

14.         name='predicted'

15.     )

16.     

17. ]

18.  

19. plot_layout = go.Layout(

20.         title='Sales Prediction'

21.     )

22. fig = go.Figure(data=plot_data, layout=plot_layout)

23. pyoff.iplot(fig)

实际值 vs 预测值：

对于一个简单的模型来说看起来很不错。

我们可以对这个模型做的一个改进是增加假期、休息时间和其他季节性影响。它们可以作为一个新特征简单地添加进去。

通过使用这个模型，我们有了基本的销售预测。但是我们如何预测促销对销售的影响呢？我们将在第7部分对此进行研究。

—END—

英文原文：https://towardsdatascience.com/predicting-sales-611cb5a252de