Prediction of Parking lot Occupancy using Time Series Decomposition-Gated Recurrent Unit (TSD-GRU) Model
By Ivy Wu, Yiming Chen, Dingjie Hu, as part of a course project of ECE1724H: Bio-inspired Algorithms for Smart Mobility. Dr. Alaa Khamis, University of Toronto, 2023.
Abstract
As private car ownership rises and urban areas continue to expand, the challenge of finding available parking spaces is becoming more pronounced. One solution to alleviate peak hour congestion in certain parking areas is to dynamically adjust parking fees based on the time of day. This strategy not only eases overcrowding but also encourages the use of alternative nearby parking facilities. To effectively implement this dynamic pricing approach, accurate prediction of parking lot occupancy trends is crucial. In our project, we have embraced the TSD-GRU model for data training, which has outperformed conventional models like GRU, FCNN, LSTM, and BiLSTM in predicting parking occupancy with greater precision. This advanced forecasting allows parking lot operators to optimize their pricing strategies, adapting to future occupancy trends more effectively.
Introduction
As the global population continues to grow, numerous cities have grappled with the twin challenges of traffic congestion and the scarcity of parking spaces. According to an American Psychological Association article published in 2014 [1], these issues have not only given rise to various psychological phenomena, exemplified by the pervasive “road rage,” but have also instigated a succession of social conflicts, particularly the fierce competition for parking spaces, all of which have captured public attention. Motivated by the urgent need for more efficient and sustainable urban living, we focused on implementing prediction of dynamic pricing for parking lots at transportation facilities. This strategy is designed to inform people about parking costs beforehand, thereby reducing travel time and alleviating traffic congestion caused by drivers searching for suitable parking spots.
Our main challenge was the absence of data on past charges of parking lots during different time, which is crucial for accurately predicting price trending. In order to train the prediction model, the Group chose to analyze the dataset based on the past occupancy rate of selected parking lots. By predicting the occupancy of the parking lot, a dynamic price could be assigned accordingly. The Group trained an improved Gated recurrent unit (GRU) model inspired by meta-TSD-GRU model from Li’s team[2]. By applying time series decomposed (TSD) data in a gated recurrent unit (GRU) model, the outcome of the proposed model outperformed several other models such as FCNN, BiLSTM and LSTM, which are presented in the section on Performance Evaluation.
The objectives of the project are to alleviate traffic congestion and to help drivers efficiently find appropriate parking spots. The article is structured to first introduce the importance of dynamic parking lot pricing, followed by a literature review of relevant studies that influenced our methodology. We then delve into problem formulation and modeling, discussing the limitations of original dataset and detailing our proposed solutions. The performance of our model is evaluated against other baseline models with both quantitative and qualitative analysis in the next section, and finally the article concludes with a summary of our findings and recommendations for future improvements.
Literature Review
1. Prediction of Vacant Parking Spaces in Multiple Parking Lots: A DWT-ConvGRU-BRC Model
The study “Prediction of Vacant Parking Spaces in Multiple Parking Lots: A DWT-ConvGRU-BRC Model” by Gao et al. [3] (2023) provides a comprehensive review of methods for predicting parking space occupancy. The methods are categorized into wavelet analysis, statistical prediction models, machine learning (ML), deep learning (DL), and the influence of external factors. Wavelet analysis, as used in research by Li et al. [4] and Ji et al. [5], is effective for processing noisy data in parking space prediction. Statistical models like Markov models and queuing theory, referenced in works by Caliskan et al. [6] and others, are useful but have limitations due to fixed assumptions about traffic. The article emphasizes the advancements in ML and DL, including regression trees and neural networks, and the integration of these models with external factors like weather for improved accuracy, as shown in studies by Fokker et al.[7] and Zhang [8]. A significant contribution of this review is the introduction of the DWT-ConvGRU-BRC model, which combines wavelet transform and ConvGRU architecture. This model addresses the spatial correlation between parking lots and external factors, surpassing previous models such as DWT-Bi-LSTM and dConvLSTM-DCN.
This article expands the ideas for our research and guides us to further research from machine learning and deep learning. At the same time, inspired by this article, we also consider external factors in terms of the importance of enhancing parking space prediction. In summary, the research in this article provides insights into multiple lines of research for our research.
2. Prediction-based One-shot Dynamic Parking Pricing
The paper “Prediction-based One-shot Dynamic Parking Pricing” by Seoyoung Hong, H. Shin, Jeongwhan Choi, and Noseong Park addresses the critical urban challenge of parking spot shortages [9]. The paper introduces a significant technological advancement by employing neural ordinary differential equations (NODEs) in predicting parking occupancy rates. NODEs, a state-of-the-art deep learning technology, offer a continuous and bijective approach, making them suitable for modeling complex, dynamic systems like urban parking.
This aspect is crucial as people generally depend on the Karush-Kuhn-Tucker (KKT) conditions to resolve the derivative of the objective function. However, this approach can sometimes lead to convergence at saddle points, which are suboptimal solutions. In our solutions, we also include short-term histroy information and the target occupancy rates as our training reference and objectives. Different from their training models, we applied Time Series Decomposition to help the model find a pattern of prediction.
3. Short-term prediction of parking availability in an open parking lot
The article “Short-term Prediction of Parking Availability in an Open Parking Lot” by Vijay Paidi focuses on solving global car parking issues in high-demand empty spaces. The study provides the short-term prediction of available parking spaces by using a low volume of data. There are 21 days of data collected, 19 days of data used for training, and the rest of the data used for testing and evaluation. The paper primarily uses three prediction methods to do short-term prediction which are Long Short-Term Memory(LSTM), Seasonal Autoregressive Integrated Moving Average with Exogenous Variables (SARIMAX), and an Ensemble-Based method.
LSTM [10] in the article, with its intricate architecture featuring memory cells and multiple gates, is adept at capturing long-term dependencies in data. This makes it suitable for modeling complex patterns in parking lot occupancy rates, which is essential for dynamic pricing prediction. Our model Time Series Decomposition (TSD)-Gated Recurrent Unit (GRU) (TSD-GRU), on the other hand, a variation of the simpler Gated Recurrent Unit (GRU), integrates a time series decomposition method. This involves breaking down the input data into trend, seasonal, and residual components before feeding it into the GRU model. This explicit decomposition allows TSD-GRU to handle each aspect of the time series separately, potentially leading to a more nuanced understanding and prediction of parking lot occupancy rates.
Dataset
To give the reader a clearer idea of what the data looks like in Calgary and to help the reader understand what the data looks like in real life, this study chose to use a Cluster map to visualize the data. By using these formats, readers can get a clearer idea of what the data in this study would look like in real life.
Cluster Map of Different Parking Prices in Calgary
Different parking lots are classified according to the price zone which is given in the dataset. The cluster map is adopted to visualize it.
Exploratory Spatial Data Analysis (ESDA)
Data visualization is an essential way for people to see what data looks like in real life. In order to give the reader a clearer picture of what data looks like, the team chose to use the Cluster map, the edge map of Calgary, and building the footprints of Calgary City to visualize data. By using these formats, readers can get a clearer idea of what the data looks like when it is in real life.
Limitations of the dataset
Understanding the limitations of Calgary’s parking pricing and congestion data is crucial for grasping its application and potential. These data offer snapshots of specific moments, yet their static nature limits their direct use in forecasting future conditions. To develop a model capable of predicting future scenarios, we need data with more varied dimensions.
Particularly for parking lot occupancy rates, analyzing data from diverse time periods can significantly enhance our understanding of its fluctuations. Data on parking lot usage during weekdays versus weekends, across different seasons, and during special events, for example, can be instrumental. Analyzing these data helps identify factors that significantly affect parking demand, like weather conditions, local events, and even nearby traffic flow.
Furthermore, incorporating other data types, such as traffic flow, public transportation usage, and socioeconomic information, broadens our insight into the dynamic shifts in parking demand. This comprehensive approach is key to crafting predictive models.
The goal is to create a model that integrates various factors to predict the occupancy of a specific parking lot at a given future time, like a weekday morning. This predictive capability is not just about better managing parking resources in the city, which also equips drivers with more practical information, such as parking recommendations or tips to avoid peak traffic times.
Training Dataset Explanation
The sample training dataset is shown above. Explanation of the head of the training data is given:
TIME: 5min/step, from June 1 to June 30, 2018. The data was recorded at 5-minute intervals from June 1 to June 30, 2018.
OCCUPANCY: the number of cars in the parking lot. This represents the number of cars in a parking lot. It suggests that the dataset includes information on how many parking spaces are currently occupied at each 5-minute interval during the specified time range.
RATE: the ratio of parking occupancy. This represents the ratio of occupied parking spaces to the total number of parking spaces, providing a measure of how full the parking lots are at any given time.
INDICATOR: The effect term. This represents the value of the effect feature used in the analysis.
FS: The Cycle term after Fourier change. Notice that this data is not included in the original dataset. The data is obtained from RATE after applying the Fourier Transformation (referring to section: Proposed Solution) and suggests the cyclic pattern in the dataset.
Problem Formulation
Intuitively, parking lot occupancy tends to exhibit stability within specific time intervals, such as peak and off-peak hours, workdays and nights, as well as weekdays and weekends. Nevertheless, within a given context, the nature of parking facilities can introduce variations in occupancy rates. For instance, shopping centers may experience higher parking demand on occasions like Christmas compared to hospitals. Drawing inspiration from POP, a widely adopted parking recommendation and guidance system designed to mitigate parking space shortages and address traffic congestion, we have selected three key parameters to articulate our formulation.
The prediction formulation contains three key factors, periodic trend, cycle differences, and random effects, which are given by:
(1) Trend Feature
The “Trend” Feature is essential for modeling upcoming changes, including upward, downward, turning, and leveling trends. Predicting future trends relies on effectively assessing past changes near the current time. We employ a backtracking mechanism to define the trend vector, as depicted in the above Formula. The prediction interval 𝜆 denotes the size of the lookback window, allowing us to accurately estimate future trends by analyzing historical changes.
(2) The Cycle Feature leverages a standard Fourier series to emulate periodic changes. The general form of a Fourier series is given by the function:
However, implementing this function directly can be computationally expensive. To address this, we use a simplified representation with specific parameters: a given time 𝑡̂, a number of signals 𝑁, and a constant 𝑇 representing cycle length.
The simplified representation is expressed as:
The function could be further simplified with:
Consequently, addressing the fitting of periodicity involves framing it as a multiple linear regression task. This task is efficiently tackled by initializing 𝑤 with a normal distribution, adapting Batch Gradient Descent (BGD) for 𝑑(𝑡̂ ). To prevent information leakage during testing, solely historical data (i.e., the training set) is utilized for regression. The Fourier series then imparts periodic information solely dependent on time.
Finally, the vector of cycle features could be defined as follows:
(3) Effect Feature: The “Effect” feature plays a crucial role in analyzing parking occupancy, taking into account various factors that can influence occupancy rates, like holidays, weather conditions, and special events. This feature operates on the principle that a current higher occupancy compared to past trends likely indicates continued high occupancy levels. It is mathematically expressed as:
where, 𝑘(𝑡) measures the impact at a given time by comparing the expected occupancy 𝑑(𝑡) with the actual occupancy 𝑦(𝑡). The factor 𝛿(𝑡) is a binary variable that becomes one only if the impact 𝑘(𝑡) exceeds a certain threshold 𝐻; otherwise, it remains zero. This threshold 𝐻 can be adjusted based on experience or using optimization methods like grid search. Typically, a default threshold of 0 is used, allowing the model to consider all effect information.
In essence, this feature captures a wide range of influences, from deliberate policy changes (like raising parking fees) to unpredictable occurrences (such as traffic jams). It helps in understanding how much current occupancy differs from the usual patterns.
One challenge with our Time Series Decomposition (TSD) model is that it struggles to isolate the specific effects of individual external factors within this combined effect. Addressing this limitation in future updates, the model will incorporate additional features that draw from multiple data sources.
Problem Modeling
We chose the Gated Recurrent Unit (GRU) to be our based model in parking occupancy prediction. GRU’s architecture offers a more streamlined and efficient approach to processing sequential data, an essential aspect in predicting parking space availability. Unlike RNNs, which suffer from vanishing gradient problems, GRU mitigates this issue through its update and reset gates, leading to better retention of information over longer sequences. Compared to LSTMs, another variant of RNN, GRUs require fewer parameters, making them not only faster to train but also more efficient in terms of computational resources.
Our model is divided into two main parts.
(1) Time-Series Decomposition (TSD): This component is essential for shaping the time-series data concerning parking occupancy. TSD’s role is to break down the data into three fundamental elements: trend, cycle, and effect. These elements help in understanding the underlying patterns and variations in the data over time. (2) Gated Recurrent Unit (GRU): The GRU segment is responsible for constructing the network framework that processes the inputs defined by the trend, cycle, and effect features. This setup is crucial in handling the dynamics of the data.
The core of our model is a simple yet effective approach that integrates these three key features (trend, cycle, and effect) into a GRU. The purpose of this structure is to efficiently capture and interpret both the recurring patterns and the irregular fluctuations that are typical in time-series data. This dual-component system thus provides a comprehensive understanding and prediction capability for parking occupancy trends.
Proposed Solution
Fourier Preparation
The model is trained using Stochastic Gradient Descent (SGD) as the optimizer and Mean Squared Error (MSE) as the loss function. The training process runs for a defined number of epochs, and the loss is printed at every 100th epoch to monitor the training progress.
After training, the models’s prediction result would be added to the original dataset with the head for FS which is mentioned in the Training Data Explanation part. This workflow combines Fourier series for feature extraction with linear regression for time series prediction, which reflects on periodic time characterizations.
import pandas as pd
import numpy as np
import torch
import csv
# Load dataset
dataset_path = 'Fourier_test.csv'
dataset = pd.read_csv(dataset_path)
rate_values = torch.FloatTensor(dataset['RATE'].values).view(-1, 1).squeeze()
# Fourier series expansion
def create_fourier_series(data, num_terms, period):
x = torch.FloatTensor(np.arange(len(data))).unsqueeze(1)
fourier_terms = x.clone()
for n in range(1, num_terms + 1):
cos_term = torch.cos(n * 2 * np.pi * x / period)
sin_term = torch.sin(n * 2 * np.pi * x / period)
fourier_terms = torch.cat((fourier_terms, cos_term, sin_term), axis=1)
return fourier_terms[:, 1:]
# Model definition
class FourierLinearRegression(torch.nn.Module):
def __init__(self, input_feature):
super(FourierLinearRegression, self).__init__()
self.linear = torch.nn.Linear(input_feature, 1)
def forward(self, x):
return self.linear(x).squeeze()
# Hyperparameters
N = 30
period = 2030
learning_rate = 0.05
num_epochs = 2000
# Data preparation
fourier_series = create_fourier_series(rate_values, N, period)
input_feature = fourier_series.shape[1]
# Model initialization
model = FourierLinearRegression(input_feature)
loss_function = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
# Training loop
for epoch in range(num_epochs):
optimizer.zero_grad()
predictions = model(fourier_series)
loss = loss_function(predictions, rate_values)
loss.backward()
optimizer.step()
if (epoch + 1) % 100 == 0:
print(f'Epoch {epoch + 1}, Loss: {loss.item()}')
# Save predictions
with open('Fourier_output.csv', 'w', newline='') as file:
writer = csv.writer(file)
for value in model(fourier_series).detach().numpy():
writer.writerow([value])After expanding it into Fourier series terms and using linear regression to model these terms. The output result is shown below for the Fourier Linear Regression Model Prediction vs. Original Data which could be easily found that data has been normalized for further training.
TSD-Preparation
Time-series-decomposition(TSD) features preparations. For the time-occupancy prediction model, periodic patterns are hidden in the time-series. Causal impacts are also included in INDICATOR by special events.
Customize GRU
This model is designed to process sequential data, where each element of the sequence has a set of features. The unique aspect of this model is the way it treats the last feature of the input differently by concatenating it after GRU processing, which reflects on the feature of RNN
import pandas
import numpy as np
import torch
from torch import nn
import csv
from time import *
# input data
Trend, Cycle, Effect, train_size, test_size = import_TSD_data()
# Hyperparameters
LOOK_BACK = 6
INPUT_FEATURES_NUM = 2*LOOK_BACK + 1
HIDDEN_SIZE = 8
OUTPUT_FEATURES_NUM = 1
NUM_LAYERS = 1
max_epochs = 4000
LEARNING_RATE = 0.02
circle = 5
# GRU Neural Networks
class GRU_model(nn.Module):
def __init__(self, input_size, hidden_size, output_size, num_layers):
super().__init__()
self.gru = nn.GRU((input_size - 1), hidden_size, num_layers)
self.forwardProcessing = nn.Linear((hidden_size + 1), output_size)
# override initial forward
def forward(self, x_input):
# x_input is the input matrix
# size (seq length, batch, input_size)
x = x_input[:, :, 0:(INPUT_FEATURES_NUM-1)]
e = x_input[:, :, (INPUT_FEATURES_NUM-1)].reshape(1, x_input.shape[1], 1)
x, _ = self.gru(x)
x = torch.cat([x, e], dim=2)
s, b, h = x.shape
x = x.view(s * b, h)
x = self.forwardProcessing(x)
x = x.view(s, b, -1)
return xTSD-GRU Model Training
A combination of Time Series Decomposition (TSD) and a Gated Recurrent Unit (GRU) neural network is used to train the model. The TSD component breaks down the data into trend, cycle, and effect features, while the GRU model predicts future values based on these features. The code sets up training and testing datasets, applies TSD, and then feeds this data into the GRU model. It includes a training loop where the model’s parameters are randomly initialized in each cycle, and the loss is calculated and minimized over multiple epochs. The script also performs predictions on the test dataset and calculates various error metrics like Mean Squared Error (MSE), Mean Absolute Percentage Error (MAPE), and R-squared (R2) to evaluate the model’s performance. These metrics are averaged over several iterations (referred to as ‘circles’) to assess the model’s overall accuracy and effectiveness in predicting the time series data.
from tqdm import tqdm
# TSD-GRU formulation
def TSD_GRU(gru_model, trend, cycle, effect):
"""
# define training and testing sets after applying Time-Series-Decomposition
# create training set
# create testing sets
# evaluation matrices
Code for the part of dataset preparation has been omitted.
Please refer to Google Colab for complete code.
"""
# training process
for i in range(circle):
print('circle =', i)
"""
Model parameters are initilized randomly. This is done by creating random weights and biases for GRU
layers and the fully connected layer. It resets the model's state for each cycle, allowing for an
independent evaluation of the model's performance across cycles.
*refer to the model of GRU
"""
gru_weight1 = torch.randn(size=[3*HIDDEN_SIZE, (INPUT_FEATURES_NUM-1)])
gru_weight2 = torch.randn(size=[3*HIDDEN_SIZE, HIDDEN_SIZE])
gru_bias1 = torch.randn(size=[3*HIDDEN_SIZE])
gru_bias2 = torch.randn(size=[3*HIDDEN_SIZE])
fc_weight = torch.randn(size=[OUTPUT_FEATURES_NUM, (HIDDEN_SIZE+1)])
fc_bias = torch.randn(size=[OUTPUT_FEATURES_NUM])
weight_bias = [gru_weight1, gru_weight2, gru_bias1, gru_bias2, fc_weight, fc_bias]
for epoch in tqdm(range(max_epochs), desc="Training Progress"):
# initialize the model
weight_bias_index = 0
for name, parameter in gru_model.named_parameters():
if parameter.requires_grad:
parameter.data = weight_bias[weight_bias_index]
weight_bias_index += 1
output = gru_model(train_x_tensor)
loss = loss_function(output, train_y_tensor)
loss.backward()
optimizer.step()
optimizer.zero_grad()
# visualize the process
if (epoch + 1) % 100 == 0:
print('Epoch: [{}/{}], Loss:{:.5f}'.format(epoch + 1, max_epochs, loss.item()))
# prediction process
pre_y = gru_model(test_x_tensor)
y_hat = torch.reshape(pre_y, [test_batch_size]).detach().numpy()
y_act = torch.reshape(test_y_tensor, [test_batch_size]).detach().numpy()
# error calculation
error = y_hat - y_act
abs_error = list(map(abs, error))
squared_err = np.multiply(error, error)
MSE_list[i] = np.mean(squared_err)
MAPE_list[i] = np.mean(abs_error / y_act)
RAE_list[i] = np.sum(abs(y_hat - y_act)) / np.sum(abs(np.mean(y_act) - y_act))
# calculation of R2
# R-squared is a statistical measure that represents the goodness of fit of a regression model.
# sum of squared residuals
RSS = np.sum(np.multiply((y_hat - y_act), (y_hat - y_act)))
# total sum of squares
TSS = np.sum(np.multiply((y_act - np.mean(y_act)), (y_act - np.mean(y_act))))
R2_list[i] = 1 - RSS / TSS
print(MAPE_list[i])
av_MSE = np.mean(MSE_list)
av_MAPE = np.mean(MAPE_list)
av_RMSE = np.sqrt(av_MSE)
av_RAE = np.mean(RAE_list)
av_R2 = np.mean(R2_list)
return av_MSE, av_RMSE, av_MAPE, av_RAE, av_R2
Performance Evaluation
Test result in tuning parameters on TSD-GRU
Analysis of the Test Result
In TSD-GRU models, we set the based learning rate as 0.8 and all the experiments are set under this standard. During the adapatation process, we test the model under three different parameters: max epochs, look back windows and cycles. Corresponding results are shown as above.
Starting with the Mean Absolute Percentage Error (MAPE%), there is a noticeable decrease in error as ‘max_epochs’ increases, indicating an improvement in prediction accuracy with more extensive training. This trend is consistent but varies in magnitude across different ‘cycle’ values, suggesting that the ‘cycle’ parameter plays a significant role in determining the model’s accuracy. The effect of ‘Look Back’ on MAPE(%) is less straightforward, showing varied impacts depending on the combination of ‘Look Back’ and ‘cycle’ values.
Apart from that, the Root Mean Square Error (RMSE) and Realative Absolute Error (RAE) trends align with those observed results in MAPE.
The Coefficient of Determination (R2) exhibits an increasing trend with higher ‘max_epochs’, which means that the model becomes more capable of explaining the variance in the dependent variable with more training. The influence of ‘Look Back’ on R2 is not uniform across different ‘cycle’ values, hinting at a variable impact of this parameter on the model’s explanatory power. The variation in R2 across different ‘cycle’ values indicates the significance of this parameter in achieving a better model fit.
Quantitatively, the ranges of change in metrics like MAPE(%) and RMSE with varying ‘max_epochs’ and ‘cycle’ values indicate substantial improvements in model performance with specific parameter configurations. For instance, a decrease in MAPE(%) from around 2.8% to 2.3% or an RMSE reduction from approximately 2.3 to 1.65 with certain parameter combinations can be considered significant in predictive modeling.
Overall, the analysis suggests that while increasing ‘max_epochs’ generally leads to improved model performance, the effects of ‘Look Back’ and ‘cycle’ are more intricate and highly dependent on their interaction. This complexity underscores the importance of careful parameter tuning to optimize the model for accuracy and fit.
Results and Comparison
The experiment result is shown above. It is obvious that our proposed model outperforms the other three proposed baselined models. Our model could be considered as a variant of the GRU model, and the main difference between it and the GRU model is that before training, we added a Fourier Series transformation to fit the feature of the trend. TSD-GRU typically involves decomposing time series data into components (such as trend, seasonality, and residual) and then modeling these components using GRUs, which are efficient and effective in modeling sequential data.
The advantages of the three baselined models are depicted as:
FCNN: Best for non-sequential data, simple structure, but lacks temporal dynamics handling.
LSTM: Suited for sequential data, capable of learning long-term dependencies.
BiLSTM: Similar to LSTM but captures both past and future context, ideal for certain types of sequence predictions.
In the TSD-GRU model, the decomposition allows the model to focus on different aspects of the time series separately, potentially leading to better performance in forecasting or anomaly detection tasks in time series data.
Conclusion & Recommendation
For future recommendations, our ongoing research on dynamic pricing models for parking lots has identified areas for improvement. Firstly, our parking prediction model currently operates solely for a single parking facility, lacking the ability to seamlessly integrate and predict across an entire area. To address this limitation, we anticipate that future efforts will focus on expanding the model’s scope to facilitate the creation of a broader range of external systems, aiding parking managers in developing comprehensive pricing strategies.
Secondly, we recognize the need for our model to be trained more rapidly. Identifying viable optimization strategies involves incorporating meta-learning techniques to expedite the training process, thereby ensuring a balance between model accuracy and operational efficiency.
Lastly, we propose the integration of point-of-interest training into the model in future research, allowing users to conveniently select parking facilities that align with their preferences. This innovative feature is designed to enhance the personalization and intelligence of the parking experience, meeting users’ heightened expectations for parking facility selection.
In summary, by continually enhancing the scope, training speed, and user-friendliness of the model, we anticipate that our research will contribute advanced and efficient solutions to the field of parking management, providing comprehensive support for urban traffic management.
In this project, our team developed a novel variant of the Gated Recurrent Unit (GRU) model, which we have termed the Time Series Decomposition GRU (TSD-GRU). This approach involves applying Fourier Series transformations to the raw data to effectively capture its trend features. Additionally, we have incorporated cycle features and effect features into our solution for a more comprehensive analysis. The TSD-GRU model underwent training with custom forward steps and was benchmarked against three other prevalent predictive models. The results demonstrated that our model performs comparably, if not superiorly, to these established baselines. The successful application of the trained TSD-GRU neural network holds significant promise for parking lot owners, enabling them to implement dynamic pricing strategies informed by accurately predicted occupancy rates across various parking lots.
Code and data are available at:
https://drive.google.com/drive/folders/1VRZ56T9xjvRlRIkSx1n99XqyIvnIBeBa
Google Colab link:
Reference
[1] American Psychological Association. (2014). The fast and the furious. American Psychological Association. https://www.apa.org/topics/anger/road-rage
[2] J. Li, H. Qu and L. You, “An Integrated Approach for the Near Real-Time Parking Occupancy Prediction,” in IEEE Transactions on Intelligent Transportation Systems, vol. 24, no. 4, pp. 3769–3778, April 2023, doi: 10.1109/TITS.2022.3230199.
[3] Gao, L., Fan, W., Hu, Z., & Jian, W. (2023). Prediction of vacant parking spaces in multiple parking lots: A DWT-CONVGRU-BRC model. Applied Sciences, 13(6), 3791. https://doi.org/10.3390/app13063791
[4] Li, T.T.; Yang, Y.; Yu, P.; Zhao, H. Optimize the multi-step prediction of parking berths in the wavelet neural network. Chongqing Norm. Univ. 2018, 35, 113–120.
[5] Ji, Y.-J.; Gao, L.-P.; Chen, X.-S.; Guo, W.-H. Strategies for multi-step-ahead available parking spaces forecasting based on wavelet transform. J. Central South Univ. 2017, 24, 1503–1512.
[6] Caliskan, M.; Barthels, A.; Scheuermann, B.; Mauve, M. Predicting parking lot occupancy in vehicular ad hoc networks. In Proceedings of the 2007 IEEE 65th Vehicular Technology Conference-VTC2007-Spring, Dublin, Ireland, 22–25 April 2007; pp. 277–281.
[7] Fokker, E.S.; Koch, T.; van Leeuwen, M.; Dugundji, E.R. Short-Term Forecasting of Off-Street Parking Occupancy. Transp. Res. Rec. J. Transp. Res. Board 2021, 2676, 637–654.
[8] Zhang, F.; Liu, Y.; Feng, N.; Yang, C.; Zhai, J.; Zhang, S.; He, B.; Lin, J.; Zhang, X.; Du, X. Periodic Weather-Aware LSTM With Event Mechanism for Parking Behavior Prediction. IEEE Trans. Knowl. Data Eng. 2021, 34, 5896–5909.
[9] Hong, Seoyoung, et al. “Prediction-based One-shot Dynamic Parking Pricing.” Proceedings of the 31st ACM International Conference on Information & Knowledge Management. 2022.
[10] W. Shao, Y. Zhang, B. Guo, K. Qin, J. Chan, and F. D. Salim, “Parking availability prediction with long short term memory model,” in International Conference on Green, Pervasive, and Cloud Computing, 2018.
