Sales Forecast Prediction - Python - GeeksforGeeks (2023)

Forecast prediction is predicting a future value using past values and many other factors. In this tutorial, we will create a sales forecasting model using the Keras functional API.

Sales forecasting

It is determining present-day or future sales using data like past sales, seasonality, festivities, economic conditions, etc.

So, this model will predict sales on a certain day after being provided with a certain set of inputs.

In this model 8 parameters were used as input:

  1. past seven day sales
  2. day of the week
  3. date – the date was transformed into 3 different inputs
  4. season
  5. Festival or not
  6. sales on the same day in the previous year

How does it work?

First, all inputs are preprocessed to be understandable by the machine. This is a linear regression model based on supervised learning, so the output will be provided along with the input. Then inputs are then fed to the model along with desired output. The model will plot(learn) a relation(function) between the input and output. This function or relation is then used to predict the output for a specific set of inputs. In this case, input parameters like date and previous sales are labeled as input, and the amount of sales is marked as output. The model will predict a number between 0 and 1 as a sigmoid function is used in the last layer. This output can be multiplied by a specific number(in this case, maximum sales), this will be our corresponding sales amount for a certain day. This output is then provided as input to calculate sales data for the next day. This cycle of steps will be continued until a certain date arrives.

Required packages and Installation

  1. numpy
  2. pandas
  3. keras
  4. tensorflow
  5. csv
  6. matplotlib.pyplot


import pandas as pd # to extract data from dataset(.csv file)

import csv #used to read and write to csv files

import numpy as np #used to convert input into numpy arrays to be fed to the model

import matplotlib.pyplot as plt #to plot/visualize sales data and sales forecasting

import tensorflow as tf # acts as the framework upon which this model is built

from tensorflow import keras #defines layers and functions in the model

#here the csv file has been copied into three lists to allow better availability

list_row,date,traffic = get_data('/home/abh/Documents/Python/Untitled Folder/Sales_dataset')

The use of external libraries has been kept to a minimum to provide a simpler interface, you can replace the functions used in this tutorial with those already existing in established libraries.

Original data set for sales data for 5 years:

Sales Forecast Prediction - Python - GeeksforGeeks (1)

Sales data from Jan 2015 to Dec 2019

As you can see, the sales data seems to be following a similar kind of pattern for each year and the peak sales value seems to be increasing with time over the 5-year time frame.

In this 5-year time frame, the first 4 years will be used to train the model and the last year will be used as a test set.

Now, a few helper functions were used for processing the dataset and creating inputs of the required shape and size. They are as follows:

  1. get_data – used to load the data set using a path to its location.
  2. date_to_day – provides a day to each day. For example — 2/2/16 is Saturday and 9/5/15 is Monday.
  3. date_to_enc – Encodes data into one-hot vectors, this provides a better learning opportunity for the model.

All the properties of these functions and a few other functions cannot be explained here as it would take too much time. Please visit this link if you want to look at the entire code.


Initially, the data set had only two columns: date and traffic(sales).

After the addition of different columns and processing/normalization of values, the data contained all these values.

  1. Date
  2. Traffic
  3. Holiday or not
  4. Day

All these parameters have to be converted into a form that the machine can understand, which will be done using this function below.

Instead of keeping date, month, and year as a single entity, it was broken into three different inputs. The reason is that the year parameter in these inputs will be the same most of the time, this will cause the model to become complacent i.e it will begin to overfit to the current dataset. To increase the variability between different various inputs dates, days and months were labeled separately. The following function conversion() will create six lists and append appropriate input to them. This is how years 2015 to 2019 will look as an encoding: is

{2015: array([1., 0., 0., 0., 0.], dtype=float32), 2016: array([0., 1., 0., 0., 0.], dtype=float32), 2017: array([0., 0., 1., 0., 0.], dtype=float32), 2018: array([0., 0., 0., 1., 0.], dtype=float32), 2019: array([0., 0., 0., 0., 1.], dtype=float32)

Each of them is a NumPy array of length 5 with 1s and 0s denoting its value


def conversion(week,days,months,years,list_row):

#lists have been defined to hold different inputs

inp_day = []

inp_mon = []

inp_year = []



out = []

#converts the days of a week(monday,sunday,etc.) into one hot vectors and stores them as a dictionary

week1 = number_to_one_hot(week)

#list_row contains primary inputs

for row in list_row:

#Filter out date from list_row

d = row[0]

#the date was split into three values date, month and year.


if d_split[2]==str(year_all[0]):

#prevents use of the first year data to ensure each input contains previous year data as well.


#encode the three parameters of date into one hot vectors using date_to_enc function.

(Video) Build a Stock Trend Prediction Web App in Python | GeeksforGeeks

d1,m1,y1 = date_to_enc(d,days,months,years) #days, months and years and dictionaries containing the one hot encoding of each date,month and year.

inp_day.append(d1) #append date into date input

inp_mon.append(m1) #append month into month input

inp_year.append(y1) #append year into year input

week2 = week1[row[3]] #the day column from list_is converted into its one-hot representation and saved into week2 variable

inp_week.append(week2)# it is now appended into week input.

inp_hol.append([row[2]])#specifies whether the day is a holiday or not

t1 = row[1] #row[1] contains the traffic/sales value for a specific date

out.append(t1) #append t1(traffic value) into a list out

return inp_day,inp_mon,inp_year,inp_week,inp_hol,out #all the processed inputs are returned

inp_day,inp_mon,inp_year,inp_week,inp_hol,out = conversion(week,days,months,years,list_train)

#all of the inputs must be converted into numpy arrays to be fed into the model

inp_day = np.array(inp_day)

inp_mon = np.array(inp_mon)

inp_year = np.array(inp_year)

inp_week = np.array(inp_week)

inp_hol = np.array(inp_hol)

We will now process some other inputs that were remaining, the reason behind using all these parameters is to increase the efficiency of the model, you can experiment with removing or adding some inputs.

Sales data of the past seven days were passed as an input to create a trend in sales data, this will the predicted value will not be completely random similarly, sales data of the same day in the previous year was also provided.

The following function(other_inputs) processes three inputs:

  • sales data of past seven days
  • sales data on the same date in the previous year
  • seasonality – seasonality was added to mark trends like summer sales, etc.


def other_inputs(season,list_row):

#lists to hold all the inputs




count=0 #count variable will be used to keep track of the index of current row in order to access the traffic values of past seven days.

for row in list_row:

ind = count


d = row[0] #date was copied to variable d


if d_split[2]==str(year_all[0]):

#preventing use of the first year in the data


sess = cur_season(season,d) #assigning a season to to the current date

inp_sess.append(sess) #appending sess variable to an input list

t7=[] #temporary list to hold seven sales value

t_prev=[] #temporary list to hold the previous year sales value

t_prev.append(list_row[ind-365][1]) #accessing the sales value from one year back and appending them

for j in range(0,7):

t7.append(list_row[ind-j-1][1]) #appending the last seven days sales value



return inp7,inp_prev,inp_sess

inp7,inp_prev,inp_sess = other_inputs(season,list_train)

inp7 = np.array(inp7)

inp7= inp7.reshape(inp7.shape[0],inp7.shape[1],1)

inp_prev = np.array(inp_prev)

inp_sess = np.array(inp_sess)

The reason behind so many inputs is that if all of these were combined into a single array, it would have different rows or columns of different lengths. Such an array cannot be fed as an input.

Linearly arranging all the values in a single array lead to the model having a high loss.

A linear arrangement will cause the model to generalize, as the difference between successive inputs would not be too different, which will lead to limited learning, decreasing the accuracy of the model.

Defining the Model

Eight separate inputs are processed and concatenated into a single layer and passed to the model.

The finalized inputs are as follows:

  1. Date
  2. Month
  3. Year
  4. Day
  5. Previous seven days sales
  6. sales in the previous year
  7. Season
  8. Holiday or not

Here in most layers, I have used 5 units as the output shape, you can further experiment with it to increase the efficiency of the model.

(Video) Python ML #08: Sales Forecast Tutorial with Linear Regression Model #machinelearning #coding #python


from tensorflow.keras.models import Model

from tensorflow.keras.layers import Input, Dense,LSTM,Flatten

from tensorflow.keras.layers import concatenate

#an Input variable is made from every input array

input_day = Input(shape=(inp_day.shape[1],),name = 'input_day')

input_mon = Input(shape=(inp_mon.shape[1],),name = 'input_mon')

input_year = Input(shape=(inp_year.shape[1],),name = 'input_year')

input_week = Input(shape=(inp_week.shape[1],),name = 'input_week')

input_hol = Input(shape=(inp_hol.shape[1],),name = 'input_hol')

input_day7 = Input(shape=(inp7.shape[1],inp7.shape[2]),name = 'input_day7')

input_day_prev = Input(shape=(inp_prev.shape[1],),name = 'input_day_prev')

input_day_sess = Input(shape=(inp_sess.shape[1],),name = 'input_day_sess')

# The model is quite straight-forward, all inputs were inserted into a dense layer with 5 units and 'relu' as activation function

x1 = Dense(5, activation='relu')(input_day)

x2 = Dense(5, activation='relu')(input_mon)

x3 = Dense(5, activation='relu')(input_year)

x4 = Dense(5, activation='relu')(input_week)

x5 = Dense(5, activation='relu')(input_hol)

x_6 = Dense(5, activation='relu')(input_day7)

x__6 = LSTM(5,return_sequences=True)(x_6) # LSTM is used to remember the importance of each day from the seven days data

x6 = Flatten()(x__10) # done to make the shape compatible to other inputs as LSTM outputs a three dimensional tensor

x7 = Dense(5, activation='relu')(input_day_prev)

x8 = Dense(5, activation='relu')(input_day_sess)

c = concatenate([x1,x2,x3,x4,x5,x6,x7,x8]) # all inputs are concatenated into one

layer1 = Dense(64,activation='relu')(c)

outputs = Dense(1, activation='sigmoid')(layer1) # a single output is produced with value ranging between 0-1.

# now the model is initialized and created as well

model = Model(inputs=[input_day,input_mon,input_year,input_week,input_hol,input_day7,input_day_prev,input_day_sess], outputs=outputs)

model.summary() # used to draw a summary(diagram) of the model

Model Summary:

Sales Forecast Prediction - Python - GeeksforGeeks (2)Sales Forecast Prediction - Python - GeeksforGeeks (3)

Compiling the model using RMSprop:

RMSprop is great at dealing with random distributions, hence its use here.


from tensorflow.keras.optimizers import RMSprop


optimizer = 'adam',

metrics = ['acc'] #while accuracy is used as a metrics here it will remain zero as this is no classification model

) # linear regression models are best gauged by their loss value

Fitting the model on the dataset:

The model will now be fed with the input and output data, this is the final step and now our model will be able to predict sales data.


(Video) sales forecasting python

history =

x = [inp_day,inp_mon,inp_year,inp_week,inp_hol,inp7,inp_prev,inp_sess],

y = out,



epochs = 15,


shuffle =False


#all the inputs were fed into the model and the training was completed


Sales Forecast Prediction - Python - GeeksforGeeks (4)

Now, to test the model, input() takes input and transform it into the appropriate form:


def input(date):

d1,d2,d3 = date_to_enc(date,days,months,years) #separate date into three parameters


d1 = np.array([d1])

d2 = np.array([d2])

d3 = np.array([d3])

week1 = number_to_one_hot(week) #defining one hot vector to encode days of a week

week2 = week1[day[date]]


//appeding a column for holiday(0-not holiday, 1- holiday)

if date in holiday:





#print("no holiday")

h = np.array([h])

sess = cur_season(season,date) #getting seasonality data from cur_season function

sess = np.array([sess])

return d1,d2,d3,week2,h,sess

Predicting sales data is not what we are here for right, so let’s get on with the forecasting job.

Sales Forecasting

Defining forecast_testing function to forecast the sales data from one year back from provided date:

This function works as follows:

  • A date is required as input to forecast the sales data from one year back till the mentioned date
  • Then, we access the previous year’s sales data on the same day and sales data of 7 days before it.
  • Then, using these as input a new value is predicted, then in the seven days value the first day is removed and the predicted output is added as input for the next prediction

For eg: we require forecasting of one year till 31/12/2019

  • First, the date of 31/12/2018 (one year back) is recorded, and also seven-day sales from (25/12/2018 – 31/12/2018)
  • Then the sales data of one year back i.e 31/12/2017 is collected
  • Using these as inputs with other ones, the first sales data(i.e 1/1/2019) is predicted
  • Then 24/12/2018 sales data is removed and 1/1/2019 predicted sales are added. This cycle is repeated until the sales data for 31/12/2019 is predicted.

So, previous outputs are used as inputs.


def forecast_testing(date):

maxj = max(traffic) # determines the maximum sales value in order to normalize or return the data to its original form




for i in list_row:

count =count+1

if i[0]==date: #identify the index of the data in list

ind = count



t_prev.append(list_row[ind-365][1]) #previous year data

# for the first input, sales data of last seven days will be taken from training data

for j in range(0,7):


result=[] # list to store the output and values


for i in list_date[ind-364:ind+2]:

d1,d2,d3,week2,h,sess = input(i) # using input function to process input values into numpy arrays

t_7 = np.array([t7]) # converting the data into a numpy array

t_7 = t_7.reshape(1,7,1)

# extracting and processing the previous year sales value



t_prev = np.array([t_prev])

#predicting value for output

y_out = model.predict([d1,d2,d3,week2,h,t_7,t_prev,sess])

#output and multiply the max value to the output value to increase its range from 0-1


t7.pop(0) #delete the first value from the last seven days value

t7.append(y_out[0][0]) # append the output as input for the seven days data

result.append(y_out[0][0]*maxj) # append the output value to the result list


return result

(Video) Group NO 23 Sales forecasting project demo

Run the forecast test function and a list containing all the sales data for that one year are returned

Result = forecast_testing(’31/12/2019′, date)

Graphs for both the forecast and actual values to test the performance of the model






leg = plt.legend()

Sales Forecast Prediction - Python - GeeksforGeeks (5)

Sales Forecast Prediction - Python - GeeksforGeeks (6)

Actual Values from 1/1/2019 to 31/12/2019

Sales Forecast Prediction - Python - GeeksforGeeks (7)

Comparison between prediction and actual values

As you can see, the predicted and actual values are quite close to each other, this proves the efficiency of our model. If there are any errors or possibilities of improvements in the above article, please feel free to mention them in the comment section.

My Personal Notesarrow_drop_up

(Video) Sales Forecasting Machine Learning - Testing Deployed Model And Outro


1. Ecommerce Food Products Sales Forecasting | System | Using | Python | Online Shopping | Project
(420 softwares)
2. Sales Forecasting Machine Learning : Intro and Loading of Dataset
(Learn Python)
3. Sales Forecasting Machine Learning Project using Python | Feature Engineering | DataHour
(Analytics Vidhya)
4. Time Series Forecasting With RNN(LSTM)| Complete Python Tutorial|
(Nachiketa Hebbar)
5. Machine Learning model with a web app for forecasting made using Python | DEMO
(undertaker 183)
6. sales prediction
(Dante Abidin)


Top Articles
Latest Posts
Article information

Author: Rev. Leonie Wyman

Last Updated: 07/27/2023

Views: 6403

Rating: 4.9 / 5 (59 voted)

Reviews: 90% of readers found this page helpful

Author information

Name: Rev. Leonie Wyman

Birthday: 1993-07-01

Address: Suite 763 6272 Lang Bypass, New Xochitlport, VT 72704-3308

Phone: +22014484519944

Job: Banking Officer

Hobby: Sailing, Gaming, Basketball, Calligraphy, Mycology, Astronomy, Juggling

Introduction: My name is Rev. Leonie Wyman, I am a colorful, tasty, splendid, fair, witty, gorgeous, splendid person who loves writing and wants to share my knowledge and understanding with you.