Predicting Unique Website Visitors With a Tensorflow Time Series Model
This project will use Tensorflow to create a time series model capable of making predictions on unique website visitor data. Data source:
https://www.kaggle.com/bobnau/daily-website-visitors
import pandas as pd
import numpy as np
import seaborn as sns
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
from datetime import datetime
df = pd.read_csv('daily-website-visitors.csv')
df = df[['Date', 'Unique.Visits']]
df = df.rename(columns={'Unique.Visits': 'unique_visits', 'Date': 'date'})
df['date'] = pd.to_datetime(df.date)
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2167 entries, 0 to 2166
Data columns (total 2 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 date 2167 non-null datetime64[ns]
1 unique_visits 2167 non-null object
dtypes: datetime64[ns](1), object(1)
memory usage: 34.0+ KB
df.head()
Let's get the ball rolling with making sure the data is clean and usable. We know we're working with dates, so it's always a good idea to make sure these are in datetime format. We also see commas in the unique_visits numbers, which need to be removed before changing the data type to int from object.
df = df.replace(',', '', regex=True)
df['unique_visits'] = df['unique_visits'].astype(int)
Tensorflow and Keras both love arrays, so it is a good idea to turn the data into np.arrays now, as we will need to do so later on anyways in order to feed data into our network model.
# Converting full df to array
all_visits = np.array(df['unique_visits'])
all_dates = np.array(df['date'])
Training and Validation Splits, Finding Baseline
Now we have our data cleaned and in the right format for analysis, let's get the Training and Validation splits set up. I chose to use data up to the 1st of Jan 2019 as training, and data post this date as validation. This is how I landed on index value 1571 as the cut-off position.
# Train and Validation Split
split_time = 1571
visits_train = all_visits[:split_time]
visits_test = all_visits[split_time:]
dates_train = all_dates[:split_time]
dates_test = all_dates[split_time:]
Let's have a look at the Naïve Forecast, where we take the previous period and use it to forecast the period ahead. We'll use the resulting Mean Absolute Error as our baseline accuracy to beat.
naive_forecast = all_visits[split_time - 1:-1]
def plot_series(time, series, format="-", start=0, end=None, color='blue'):
plt.plot(time[start:end], series[start:end], format, color=color)
plt.xlabel("Time")
plt.ylabel("Value")
plt.grid(True)
# Display plot of naive forecast
plt.figure(figsize=(10, 6))
plot_series(dates_test, visits_test, start=0, end=150)
plot_series(dates_test, naive_forecast, start=1, end=151, color='red')
plt.show()
# Finding our baseline accuracy with MAE - results in an MAE of 515
print("Baseline accuracy is: ", keras.metrics.mean_absolute_error(visits_test, naive_forecast).numpy())
Baseline accuracy is: 515
# Data Preparation - creating windowed tf.dataset.Datasets
dataset = tf.data.Dataset.from_tensor_slices(visits_train)
dataset = dataset.window(21, shift=1, drop_remainder=True)
dataset = dataset.flat_map(lambda window: window.batch(21))
dataset = dataset.map(lambda window: (window[:-1], window[-1:]))
dataset = dataset.shuffle(buffer_size=10)
dataset = dataset.batch(1).prefetch(1)
Tensorflow Model Design
tf.keras.backend.clear_session()
model = tf.keras.models.Sequential()
layer0 = model.add(tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1), input_shape=[None]))
layer1 = model.add(tf.keras.layers.Conv1D(filters=16, kernel_size=5, strides=1, padding='causal', activation='relu'))
layer2 = model.add(tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(30, return_sequences=True)))
layer2 = model.add(tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(30)))
layer4 = model.add(tf.keras.layers.Dense(1))
layer5 = model.add(tf.keras.layers.Lambda(lambda x: x * 1000))
Setting a checkpoint callback to save the best model weights (lowest MAE):
# Model Callbacks
checkpoint_filepath = '/work/model_checkpoint'
model_checkpoint = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_filepath,
save_weights_only=True,
monitor='mae',
mode='min',
save_best_only=True
)
## SGD Optimizer - provided fairly bad results with losses around ~2000
# model.compile(loss="mae", optimizer=tf.keras.optimizers.SGD(lr=1e-8, momentum=0.9))
## Adam Optimizer - significantly better results, losses in the high 100's
# model.compile(metrics=["mae"], optimizer=optimizer, loss=tf.keras.losses.Huber())
## RMSprop - best optimizer yet - low 700s
# model.compile(optimizer=tf.keras.optimizers.RMSprop(lr=0.001), loss='mae')
# optimizer = tf.keras.optimizers.Adam(
# learning_rate=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, amsgrad=False,
# name='Adam')
reduce_lr_loss = tf.keras.callbacks.ReduceLROnPlateau(monitor='mae', factor=0.0001, patience=6, verbose=1, min_delta=0.001, mode='min')
earlyStopping = tf.keras.callbacks.EarlyStopping(monitor='mae', patience=10, verbose=0, mode='min')
model.compile(optimizer=tf.keras.optimizers.RMSprop(lr=0.0001), metrics=['mae'],
loss=tf.keras.losses.MeanAbsolutePercentageError())
model.fit(dataset, epochs=100, verbose=1, callbacks=[model_checkpoint, reduce_lr_loss, earlyStopping])
Epoch 1/100
1551/1551 [==============================] - 46s 25ms/step - loss: 34.7660 - mae: 937.5386
Epoch 2/100
1551/1551 [==============================] - 39s 25ms/step - loss: 17.8047 - mae: 417.2024
Epoch 3/100
1551/1551 [==============================] - 39s 25ms/step - loss: 14.5034 - mae: 342.0269
Epoch 4/100
1551/1551 [==============================] - 39s 25ms/step - loss: 12.1551 - mae: 286.9319
Epoch 5/100
1551/1551 [==============================] - 39s 25ms/step - loss: 12.5660 - mae: 299.0293
Epoch 6/100
1551/1551 [==============================] - 39s 25ms/step - loss: 11.6614 - mae: 287.8062
Epoch 7/100
1551/1551 [==============================] - 39s 25ms/step - loss: 12.0576 - mae: 292.5411
Epoch 8/100
1551/1551 [==============================] - 39s 25ms/step - loss: 10.9524 - mae: 271.2036
Epoch 9/100
1551/1551 [==============================] - 40s 26ms/step - loss: 10.0189 - mae: 251.0590
Epoch 10/100
1551/1551 [==============================] - 64s 41ms/step - loss: 9.8853 - mae: 247.1069
Epoch 11/100
236/1551 [===>..........................] - ETA: 39s - loss: 10.4503 - mae: 236.1027Execution Error
KeyboardInterrupt:
# Loading the weights of a model trained on my local machine.
model.load_weights(checkpoint_filepath)
Predictions
def get_preds(model, val_data):
series = tf.expand_dims(val_data, axis=-1)
tf_val_data = tf.data.Dataset.from_tensor_slices(series)
tf_val_data = tf_val_data.window(21, shift=1, drop_remainder=False)
tf_val_data = tf_val_data.flat_map(lambda x: x.batch(21))
tf_val_data = tf_val_data.batch(1).prefetch(1)
forecast = model.predict(tf_val_data)
# forecast = forecast * 10
forecast = np.abs(forecast)
return forecast
preds = get_preds(model, visits_test)
print(preds[:10])
print(visits_test[:10])
[[4320.231 ]
[4126.498 ]
[3577.1511]
[2711.655 ]
[2030.4172]
[3809.4297]
[4303.554 ]
[4363.565 ]
[4129.9946]
[3448.4712]]
[2361 2793 2373 1609 2046 3100 3182 3245 2836 2476]
tf.keras.metrics.mean_absolute_error(visits_test, preds)
plt.figure(figsize=(20, 10))
plot_series(all_dates, all_visits)
plot_series(dates_test, preds, color='red')
plt.show()
plt.figure(figsize=(20, 10))
plot_series(dates_test, visits_test)
plot_series(dates_test, preds, color='red')
plt.show()