Deep Learning Based Caching for Self-Driving Car in Multi-access Edge Computing

10/03/2018 ∙ by Anselme Ndikumana, et al. ∙ The University of Sydney 0

Once self-driving car becomes a reality and passengers are no longer worry about it, they will need to find new ways of entertainment. However, retrieving entertainment contents at the Data Center (DC) can hinder content delivery service due to high delay of car-to-DC communication. To address these challenges, we propose a deep learning based caching for self-driving car, by using Deep Learning approaches deployed on the Multi-access Edge Computing (MEC) structure. First, at DC, Multi-Layer Perceptron (MLP) is used to predict the probabilities of contents to be requested in specific areas. To reduce the car-DC delay, MLP outputs are logged into MEC servers attached to roadside units. Second, in order to cache entertainment contents stylized for car passengers' features such as age and gender, Convolutional Neural Network (CNN) is used to predict age and gender of passengers. Third, each car requests MLP output from MEC server and compares its CNN and MLP outputs by using k-means and binary classification. Through this, the self-driving car can identify the contents need to be downloaded from the MEC server and cached. Finally, we formulate deep learning based caching in the self-driving car that enhances entertainment services as an optimization problem whose goal is to minimize content downloading delay. To solve the formulated problem, a Block Successive Majorization-Minimization (BS-MM) technique is applied. The simulation results show that the accuracy of our prediction for the contents need to be cached in the areas of the self-driving car is achieved at 98.04 minimize delay.



There are no comments yet.


page 12

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

I-a Background and Motivations

According to road traffic accident statistics, in 2016, 235,532 people were killed, and 6,648,078 people were injured in traffic accidents [1]. Furthermore, US National Highway Traffic Safety Administration (NHTSA) data in 2015 shows that, in Georgia, of car accidents caused by human errors and bad decisions[2]. Therefore, in order to save lives, prevent human errors and bad decisions, and releasing human from stressful tasks of controlling car, many research projects for the autonomous car have been introduced [3].

Recently, the automobile industries have made remarkable improvements by creating autonomous cars that can drive themselves with human driver intervention. Some companies, such as Google, Uber, Samsung, Tesla, Mercedes-Benz, Baidu, etc., have already started to focus on the next stage of autonomous driving called


where cars can drive themselves without human driver intervention [4]. Therefore, self-driving cars will have full driving automation in all situations. Furthermore, in order to make the self-driving car more intelligent, the self-driving car needs to be equipped with smart sensors and analytics tools that collect and analyze heterogeneous data related to people on-board, pedestrian, and environment in real time, in which deep learning plays significant roles [5].

Even though a self-driving car has On-Board Unit (OBU) that can handle Computation, Communication, Caching, and Control (4C), we still consider the self-driving car’s resources for 4C to be limited, and requires assistance from the remote clouds [6]. For effective self-driving car’s data analytics, there is a strong need for low-latency and reliable computations. However, reliance on a cloud can hinder the performance of the self-driving car’s data analytics, due to the associated end-to-end delay. Therefore, to reduce end-to-end delay, we consider Multi-access Edge Computing (MEC) [7] as a suitable technology that can support self-driving cars for edge analytics [8]. MEC has been recently introduced by the European Telecommunications Standards Institute (ETSI) to supplement cloud computing, where MEC servers are deployed at the edge of the network for 4C [9]. In this work, MEC servers are deployed at RoadSide Units (RSUs) for edge analytics and content caching in close proximity to the self-driving cars.

We focus on self-driving cars for public transport such as buses, because in the future, self-driving buses are expected to roll down in smart cities [10]. Furthermore, with deep learning and 4C features in the self-driving car, passengers will no longer be limited to onboard radio and TV, instead spending more time on watching media, playing games, and social networks. However, retrieving these contents from Data Centers (DCs) can make content delivery service worse, due to the associated end-to-end delay, and consumed backhaul bandwidth resources. As an example, watching a video in a car requires three components, namely video source, screen, and a sound system. Therefore if the source of the video is not in the car, the car needs to download it from DC. Assuming the DC is distantly located, then in-car services will incur high delay, caching in self driving car will play an important role to enhance the users’ experience.

I-B Challenges for Caching in Self-Driving Car

  • For traveling people, the self-driving car will be a new entertainment place. Therefore, content providers and game developers need to grasp this new opportunity by providing high-quality of entertainment contents. However, there is still lack of literature on how caching for entertainment contents in self-driving can be performed.

  • The self-driving car could deliver more heterogeneous entertainment contents such as movies, TV, music, and games as well recent emerging platforms such as Virtual Reality (VR) [11]. However, the self-driving car’s resources for 4C are limited. Therefore, self-driving cars need to be supported by MEC servers.

  • The self-driving car is sensitive to delay. Therefore, to reduce car-DC delay and save backhaul bandwidth, communication and caching resources utilization in MEC servers and self-driving cars needs to be reinforced and optimized.

As related works, content caching at BSs, and RSUs has gained significant attention in [9, 12, 13, 14, 15]. In addition, in [16, 17], the authors proposed deep learning approaches for edge caching (at BS, RSUs, and user equipment). Still, in these works, content caching in the self-driving car was not addressed thoroughly. In [18], the authors proposed the cloud-based vehicular ad-hoc network, where both vehicles and RSUs participate in content caching. However, introducing the cloud-based controller in vehicle caching can increase content retrieval delay. Other alternatives have also been proposed in [19], where the authors considered two levels of caching at edge servers (BSs) and at autonomous cars. In this proposal, the edge server injects contents to some selected cars that have enough influences to share these contents with other cars. However, in a realistic network environment, BSs and cars may belong to the different entities. Therefore, without incentive mechanism, there are no motivations for car owners to allow BS operator(s) to inject the contents in their cars and participate in content sharing. Finally, in [20], self-driving car caching forum was introduced by GEOCACHING in March 2018, but still, there is no proposal on how caching in self-driving car can be implemented.

I-C Contributions

In order to address the aforementioned challenges, we propose improving entertainment services in self-driving cars using deep learning based caching and 4C approaches in MEC. The main contributions of this paper are summarized as follows:

  • People have different content flavor, in which their choices depend on ages and genders [21]

    . To fulfill the demands of passengers in self-driving car, we use a Convolutional Neural Network (CNN) approach to predict their ages and genders via facial recognition. Specifically, CNN outputs are used by self-driving car for the purpose of deciding on which entertainment contents, such as music, video, and game data, are appropriate for passengers and thus need to be cached.

  • To get the appropriate entertainment content for passengers, the self-driving car needs to be supported by MEC and DC. At DC, we propose a Multi-Layer Perceptron (MLP) framework to predict the probability of content to be requested in a specific area of self-driving car. Then, the MLP prediction outputs are deployed at MEC servers (at RSUs) in close proximity to the self-driving car. During off-peak hours, each MEC server uses MLP outputs to download and then cache the contents that have high probabilities for being requested. We choose MLP over other prediction methods such as AutoRegressive (AR) and the AutoRegressive Moving Average (ARMA) models, because MLP has the capability to cope with both linear and non-linearly prediction problems [22].

  • For the contents need to be cached, the self-driving car downloads MLP outputs from MEC server, which is then compared with the CNN outputs. For the comparison, we combine k-means and binary classification. We choose k-means and binary classification over other clustering algorithms due to their computational efficiencies and elegant simplicities in their implementation [23, 24].

  • We formulate caching in a self-driving car for entertainment services using deep learning exploiting 4C components in MEC to minimize content-downloading delay. To solve the formulated problem, we use Block Successive Majorization-Minimization (BS-MM) technique [25]. We choose BS-MM over other optimization techniques because BS-MM is a new technique that allows decomposing problem into small subproblems by partitioning the formulated problem into blocks.

Specifically, the novelties of our proposal over related works in [9, 12, 13, 14, 15, 16, 17, 18, 19, 20] are: to the best of our knowledge, we are the first to investigate self-driving car caching for entertainment contents, where caching decisions are based on MLP, CNN, and available communication, caching, and computation resources.

The rest of the paper is organized as follows. We discuss system model in Section II, and present our proposal in Section III. In Section IV, we discuss about the problem formulation and solution. We present performance evaluation in Section V. Finally, we conclude the paper in Section VI.

Ii System model

Figure 1: Illustration of our system model.

The system model is depicted in Fig. 1:

  • At Data Center (DC): Typically, DC hosts dataset from data market for prediction purpose. In the DC, we use MLP described in section III-A1 for predicting the probabilities of contents to be requested in specific areas. In order to reduce communication delay between the self-driving car and DC, the outputs of the MLP are deployed at MEC servers attached to RSUs based on their locations. We use to denote the set of geographic locations, where each location has one MEC server.

  • At RoadSide Unit (RSU): We consider that each RSU has access to DC via a wired backhaul of capacity , where is the set of RSUs. Furthermore, we consider as a set of self-driving cars, in which each RSU can provide broadband Internet service to self-driving cars via wireless link of capacity at each time slot. In addition, each RSU has one MEC server. Unless stated otherwise, we use also the terms “RSU”, and “MEC server” interchangeably. Furthermore, each MEC server has cache storage of capacity and computational resource of capacity .

    During off-peak hours, by using backhaul communication resources, based on the MLP outputs, each MEC server can download and cache predicted contents with high probabilities of being requested in its region. We use to denote a set of contents, where each content has a size of Mb. In addition, based on demands for content, each cached content can be served as it is or after being computed. Therefore, we use to denote the content before computation, and to denote the content after computation. As an example, content with format .avi may be not available in the cache storage of MEC server. Instead, the cache storage may have content with format .mpeg of the same content. Therefore, for satisfying the demand, by using the computational resource, MEC server can convert to .

  • At self-driving car: We consider that the self-driving car has an OBU that can handle 4C with MEC to support caching of entertainment contents for passengers. Each self-driving car has cache storage of capacity and computation capability . Furthermore, to decide which entertainment content to request and cache in the self-driving car, we use CNN approach presented in III-A2 to predict age and gender of car passengers, where each self-driving car is equipped with a camera system for capturing incoming passenger. After CNN prediction, the self-driving car can request its nearest RSUs the MLP prediction. Then, by using k-means and binary classification presented in III-A3, self-driving car compares its CNN prediction with the predicted outputs from MLP. This helps to identify the entertainment contents which are appropriate to the passengers. Finally, the self-driving car downloads and caches the identified contents.

Notation Definition
Set of self-driving car,
Set of contents,
Set of contents need to be cached in area
of RSU ,
Set of consumers of contents,
Set of RSUs,
Input of MLP
Output of MLP
Ground truth for MLP
The number of inputs features
The number of geographic areas
Caching capacity of each RSU
Computation capability of RSU
Caching capacity of each car
Computation capability of car
Input image of passenger in car
Total delay experienced by each passenger
Data rate for each passenger via IWR of car
Table I: Summary of key notations.

Iii Deep Learning Based Caching in Self-Driving Car

As described in the previous section, for caching contents, the self-driving car needs to compare its CNN prediction with MLP prediction. Here, we discuss deep learning and recommendation model in Section III-A, where the output of the recommendation model is the contents that should to be cached in the self-driving car. Furthermore, for requesting and downloading the recommended contents, the self-driving car requires communication resources. Therefore, in Section III-B, we will discuss the communication model. For caching downloaded contents, we present the caching model in Section III-C. Based on demands, cached contents can be converted or transcoded to the different formats by using computational resources, where computation model is described in Section III-D.

Iii-a Deep Learning and Recommendation Model

Iii-A1 Multi-Layer Perceptron (MLP)

As depicted in Fig. 1

, at DC, we use MLP, where green circles represent neurons of input and output layers, while red circles represent neurons of hidden layers.

For predicting the probabilities of contents to be requested in specific areas, we use a demographical dataset that will be described in Section V. The inputs and outputs are described as follows:

  • Inputs: In the dataset, we have entertainment content names, rating, viewer’s age, gender, and locations as the inputs of MLP. We use

    to denote the input vector, where the subscripts are used to denote the features.

  • Outputs: From the inputs, MLP tries to predict as the output vector and the subscripts are used to denote the geographical areas. In addition, in the output layer, each area

    corresponds to one neuron and predicts the probabilities of contents require to be cached in that area. Furthermore, for predicting the ranking of entertainment contents over time, long short-term memory (LSTM) described in

    [26] can be used. However, we consider LSTM for predicting content rating to be outside of the scope of this paper.

Before presenting the MLP, let us start with a simple artificial neural network (ANN) of one layer, where we consider the outputs as the weighted sum of the inputs. We use to denote weight from input to output . Therefore, the output can be expressed as follows:


where is the activation functiona and is the bias added with a linear combiner ().

As an extension to the above simple ANN, we consider MLP as an ANN which has more hidden layers, where each hidden layers has more units called neurons. For MLP, we use to denote the the number of hidden layers, for input vector,

for bias vectors,

for the weight matrices at each hidden layer, and for output vector. can be expressed as follows:


The above equation (2

) shows that each neuron received the output from the previous layer and after processing, it sends output to the next neurons of the next layer. In our MLP, we use Rectified Linear Unit (ReLU) as the activation function in all the layers except at the output layer. The ReLU can be mathematically expressed as follows:


We choose ReLU over other activation function, because it solves the vanishing gradient problem experienced by MLP during the training process

[27]. Furthermore, in the output layer , we use softmax function as an activation function. The purpose of softmax function is to squeeze the output vector into a set of probability values, where softmax function is defined as:


The output layer has neurons that correspond to the number of geographical locations, where the cache-enable RSU will be used for caching the contents.

The aims of our MLP is to compute the output for each input . Therefore, during the training of our MLP, we need to adjust our such that the correct output can be obtained for each input . In other words, we need to adjust the network weights such that the error function is minimized. As described in [27]

, weight adjustment can be done through a series of gradient descent weight updates in a backward manner from the output layer, and this technique is called backpropagation.

For error function, we choose cross entropy error function overs other error functions as our MLP aims to classify the contents needs to be cached in

geographical areas. This problem can be considered as classification problem, where we interpret the outputs as probabilities of the contents to be cached in specific geographical area. The cross entropy error function can be expressed as follows:


The above cross entropy error function penalizes large deviations from the desired caching locations. Technically,

calculates the cross-entropy between the estimated class probabilities

and the ground truth .

Finally, in order to reduce communication delay between the self-driving car and DC, as DC may be located in a far distance from the self-driving car, the outputs of MLP are sent to MEC servers attached to RSUs based on their geographical locations/areas.

Iii-A2 Convolutional Neural Network (CNN)

We use CNN for automatic age and gender extraction from facial images. This problem has been extensively studied in [28]. We consider that features like age and gender will play an important role in entertainment content consumption. Once the facial image of passenger is captured via the camera of self-driving car, we can extract features such as location, size, eyes, nose, mouth, chin, etc., and use them for classifying the face into different age and genders classes by using CNN VGG16 described in [29]. We describe CNN workflow for automatic age and gender extraction as follows:

  • Inputs: In the self-driving car, we consider as the input image of incoming passenger(s) with three dimensions space: height, width, and the number of color channels (red, green, and blue).

  • Convolution layer: Convolution layer applies filters to input regions and computes the output of each neuron. Each neuron is connected to local regions of inputs and by using dot products between weight and local regions, convolution layer comes out with feature map . We use to denote the feature map after convolution layer in self-driving car .

  • RELU layer: In this layer, we apply ReLU as an elementwise activation function. The ReLU keeps the size of its associated convolution layer unchanged.

  • Max pooling layer:

    After Convolution and RELU layers, we have a high dimensional matrix. Therefore, for dimension reduction, we apply maxing pooling layer as downsampling operation.

  • Fully-connected layer: This layer is fully connected to all previous neurons and is used to compute the class scores that a face could potentially belong to. Here, we have classes for gender (male and female) and classes of age (from 0 to 101). In other words, we use two fully-connected layers, one for age and another one for gender classification.

  • Softmax layer: In this layer, for each facial image, we need to interpret output as probability values that indicate the classes for gender and age that a face could potentially belong to. To achieve this, the softmax activation function is applied to the outputs of the fully-connected layers.

Iii-A3 Recommendation Model

Once the self-driving car is connected to RSU, it downloads MLP output. Then, it uses the CNN prediction and MLP output to decide the contents that need to be downloaded and cached in its cache storage. The workflow of the recommendation model for the self-driving car is described as follows:

  • Step 1: Each self-driving car downloads MLP output from MEC server (attached to RSU).

  • Step 2: By using the k-means algorithm for age-based grouping and binary classification for gender-based grouping on MLP output, each self-driving car makes clusters of consumers of contents and generates an initial recommendation for the contents that need to be cached and have high requested probabilities.

  • Step 3: For each new passenger , the self-driving car uses CNN for automatically predicting its age and gender. We assume that the self-driving car trains CNN once by using dataset, saves the model, and uses it for predicting age and the gender without always training the model again.

  • Step 4: The self-driving car uses these passenger’s features to calculate the similarity of passenger with the existing classified people (consumers of contents). From the result of similarity calculation, the passenger will be assigned to a cluster.

  • Step 5: After clustering of passenger(s), self-driving car updates the recommendation for the content that the self-driving car needs to be downloaded and cached.

  • Step 6: Finally, self-driving car downloads the recommended contents via RSUs and caches them in its cache storage .

Let us describe in detail how to use k-means algorithm and binary classification in the recommendation model at each geographical location of self-driving car . For k-means algorithm, first, we use age as numerical data points. We denote as MLP output at each geographical location and as inputs of k-means algorithm. The k-means seeks to partition data points into clusters and . In k-means, people are grouped into clusters based on category of their age, where we choose the number of clusters equals to the number of age categories. In addition, clusters are disjoint . The goal of k-means is to assign data points to the cluster’s centroid such that the below objective function is minimized:


where is the centroid of cluster , which is defined as follows:


In addition to the age, people in the same cluster can have different gender. Furthermore, as shown in the processed YouTube demographic dataset from Next Analytics [21], based on gender, people have different choices for contents. Therefore, in each cluster, we need to group data points based on gender. For gender-based grouping, we apply binary classification described in [24] which results in formation of two groups, one group for females (denoted ) and another group for males (denoted ), where and .

Since downloading both MLP outputs and top recommended contents requires communication resources, we propose communication model that is described in below subsection.

Iii-B Communication Model

During off-peak hours, based on the MLP outputs, each MEC server downloads recommended contents by using fiber backhaul link of capacity . The transmission delay for downloading contents from DC to the MEC server is expressed as:


where , , denotes the set of predicted contents via MLP that need to be cached in region of RSU and is a decision variable that indicates whether or not MEC server downloads recommended content i from DC, such that:


In self-driving car, downloading the top recommended contents requires communication resources. We consider each self-driving car moves in region covered by macro base stations (BSs) and RSUs. In addition, we assume that in each route of self-driving car , there can be many RSUs, where some of them are cache-enabled. Therefore, before the self-driving car starts its journey, it can select RSUs that will be used to download the top recommended contents and the speed that will be used for having less variation in time for downloading contents. Therefore, to discover cache-enabled RSUs located in a route of each self-driving car, Access Network Discovery and Selection Function (ANDSF) implemented in cellular network [30] can be utilized. To get RSU information (their coordinates and coverages), the self-driving car sends a request to ANDSF server via BS. In the request includes self-driving car geographic location, speed, and direction. The ANDSF server’s response includes coordinates and coverage radius all RSUs available in the direction of the self-driving car.

Each self-driving car computes the following distance between each RSU and its route:


where is the angle between the trajectory of movement of self-driving car and the straight line originating from RSU physical location, and is geographical distance between self-driving car and cache-enabled . and can be obtained via Global Positioning System (GPS) [31]. In addition, each self-driving car computes the following distance remaining to reach each area covered by cache-enabled RSU :


As described in [31], we defined as a probability that cache-enabled RSU will be selected as a source of contents required to be cached in self-driving car as follows:


where is the radius of area covered by RSU . The equation (12) ensures that once the self-driving car reaches in area covered by cache-enabled RSU , it immediately starts downloading recommended contents. Therefore, we define as decision variable that indicates whether or not self-driving car is connected to RSU as follows:


We consider each RSU has wireless channel of capacity and each self-driving car can use one channel at each time slot. The channel is shared via time-division multiplexing fashion. As described in [32], at each time slot , we assume that the channel is not changing. Therefore, can be expressed as follows:


where is the authorized bandwidth for car to RSU communications, is the channel gain between RSU and self-driving car , and is the scalar factor that represents the transmission power of RSU . Therefore, based on channel capacity, the transmission delay for downloading content from MEC server to self-driving car is expressed as:


where is the most requested content by consumers of the gender female and is the most requested content by consumers of the gender male in each cluster , i.e., .

We consider as a time required by self-driving car to leave an area covered by RSU as follows:


where is the speed of self-driving car . When , the self-driving doesn’t need to reduce for having more time to download the recommended contents in the region of RSU . However, when , without endangering other cars and breaking minimum speed limit allowed in its lane, the self-driving car can reduce for having more time to download more contents and cache them.

We consider that each self-driving car has Integrated WiFi Router (IWR) on board, and it can provide WiFi connectivity to passengers. The IWR channel resources are shared to the passengers via contention-based model described in [33]. Therefore, the instantaneous data rate for each passenger via IWR of self-driving car is given by:


where is WiFi throughput efficiency factor, and is the number of passengers that be connected simultaneously to IWR of self-driving car , where . is used to determine overhead related to MAC protocol layering such as header, DIFS, SIFS, and ACK. Furthermore, is the maximum theoretical data rate that IWR can handle, which is assumed to be protocol depended and apriori known [33]. Furthermore, is channel utilization function [33], which is a function of number of passengers connected simultaneously to IWR. is used to determine impact of contention over WiFi throughput. In addition, we use as a decision variable that indicates whether or not passenger is connected to WiFi of self-driving , specifically:


For each passenger , based on its instantaneous data rate , the transmission delay for downloading content via or from self-driving car is given by:


Iii-C Caching Model

The aim of caching contents in the self-driving car is to reduce the delay experienced by passengers in downloading content. This helps in improving Quality of Experience (QoE) for consumers (passengers) and quality of service for Content Providers (CPs).

We assume that the cache storage for each self-driving car is limited. Therefore, the sizes of the recommended contents need to be downloaded from MEC server and cached must satisfy cache resource constraint, which is expressed as follows:


where, in each cluster , we let be the decision variable that indicates whether or not self-driving car has to cache content , where is given by:


On the other hand, we let be the decision variable that indicates whether or not self-driving car has to cache content , where is given by:


Furthermore, for analyzing cache storage utilization, which is based on cache hit and cache miss, we assume that and are cached in the same cache storage . Therefore, we omit the subscript and superscript on content, and use to denote any content or .

We use to denote the cache hit indicator at self-driving car for content requested by customer :


In case of cache miss (), the self-driving car needs to forward demand for content to its associated MEC server. Based on MLP output at RSU, we consider that the MEC server caches the contents that has high probabilities of being request in its region , where cache allocation has to satisfy the following constraint:


where is a decision variable that indicates whether or not MEC server has to cache content , defined as follows:


Furthermore, we use to denote the cache hit indicator at MEC server for content requested by self-driving :


Due to the limited cache capacity, when the cache storage is full, the self-driving car or MEC server replaces the contents by using Least Frequently Used (LFU) cache replacement policy [34] [35].

However, when MEC server does not have content in its cache storage, MEC server forwards the demand for content to DC via wired backhaul link.

Iii-D Computation Model for Cached Content

In the self-driving car, a passenger may request a content format (e.g., avi), which is not available in the cache storage . Instead, the cache storage may have other content formats (e.g., mpeg) of the same content which can be transcoded to the desired format.

Therefore, in order to adopt this process of serving cached content after computation, we define the following decision variable:


In order to make sure that self-driving car returns only one format of content, the following constraint has to be satisfied:


We assume that converting content to content requires to use computation resource of self-driving car , where computational resource allocation is given by:


where is the computation workload or intensity in terms of CPU cycles per bit required for converting cached content to , while is computation decision variable which is expressed as:


In (29), for computational resources allocation, we use weighted proportional allocation, because it is simple to implement in practical communication systems such Vehicular Ad-hoc Networks (VANETs), 4G and 5G cellular networks [36, 9]. In weighted proportional allocation, each transcoding task receives a fraction of computational resources based on its computation workload requirement.

Furthermore, we assume that the computational resource to be limited, and computation allocation must satisfy the following constraint:


In addition, converting content to content involves the executing time. Therefore, in self-driving car , as defined in [37], the execution time is given by:


When constraint (31) cannot be satisfied due to insufficient computational resource for converting content into requested content , self-driving car forwards the demand for content to MEC server.

At MEC server, to convert cached content into content , it requires execution time . Thus, the execution time at MEC server is given by:


where is a computation decision variable, which is expressed as:


where the computational resource allocation at RSU for converting cached content to content can be calculated as follows:


In addition, we assume that computation resource at MEC server to be limited, where computation allocation has to satisfy the following constraint:


We define as a decision variable that indicates whether or not MEC server returns requested content to self-driving car after computation, where is given by:


Therefore, in order to ensure that converting to is executed only at one location and MEC server returns only one format of content, we impose the following constraints:


where . However, when the MEC server does not have enough computation resources to satisfy the above constraint (36), it forwards the demand for content to DC via backhaul wired link.

Iv Problem Formulation and Solution

To join aforementioned deep Learning, communication, and computation approaches, we formulate an optimization problem in Section IV-A. Finally, we propose a solution of our optimization problem in Section IV-B.

Iv-a Problem Formulation

We formulate a novel deep learning based caching scheme in self-driving car that exploits 4C components of MEC as an optimization problem. The problem aims at minimizing total delay, where total delay for retrieving contents is given by:


Therefore, for minimizing delay , the optimization problem can be expressed as follows:

subject to:

The constraint in (41a) ensures that the communication resource allocation for self-driving cars has to be less or equal to the total available communication resources of RSU . The constraints in (41b) and (41c) guarantee that caching and computational resource allocations have to be less or equal to the available caching and computational resources of the self-driving car. The constraint in (41d) ensures that self-driving car or MEC server returns only one format of the requested content. The constraint (41e) ensures that converting to is only executed at one location, either at MEC server or at self-driving car .

The formulated optimization problem in (41) has a non-convex structure, which makes it complicated to solve. Therefore, in order to make it convex and solve it easily, we use a Block Successive Majorization-Minimization (BS-MM) [25] and rounding technique [38, 39] described below in the Section IV-B.

Iv-B Proposed Solution

We solve (41) by using BS-MM. The BS-MM belongs to a family of algorithms called Majorization-Minimization (MM) algorithms described in [25]. We choose BS-MM over other MM algorithms because BS-MM allows partitioning problem into blocks and applies MM to one block of variables while keeping the values of other block fixed. To ensure that all blocks are utilized, we can use selection rules such as Cyclic, Gauss-Southwell, and Randomized described in [9, 25]. Therefore, with BS-MM, each subproblem can be solved separately using parallel computation. Furthermore, in order to use BS-MM in (41), we consider , , and as non-empty and closed sets of relaxed , , and , respectively. Therefore, to simplify our notation, we use to denote (41), where is expressed as follows:


To solve (42) by using BS-MM, we apply MM steps summarized below:

  • Step 1: In the first step, called majorization, we need to find a convex surrogate function denoted by which is the upper-bound of (42).

  • Step 2: In the second step, called minimization, instead of minimizing (42) which is intractable, we need to minimize the convex surrogate function .

The success of BS-MM relies on choosing the surrogate function . Therefore, a surrogate function that is easy to solve and follows the shape of the objective function (42) is preferable. To achieve this, in majorization step, we use proximal minimization technique described in [25] and make the surrogate function by adding quadratic term () to (42). Therefore, the convex surrogate function can be expressed as follows:


where , , are a given initial feasible points. Furthermore, the surrogate function in (43) can be applied to other vectors and . Due to its quadratic term (), is convex optimization problem.

In minimization step, we minimize surrogate function , which is convex and upper-bound of the objective function in (42). Therefore, as the surrogate function in (43) can be divided into blocks, we consider as set of indexes, where at each iteration and , is used to denote a positive penalty parameter.

For minimizing the surrogate function , we propose Algorithm 1, where we can obtain solution of (43) by solving the below optimization problems at each each iteration :


For the obtained solution by using the relaxed vectors , and that take values in , we need to ensure that , and

are vectors of binary variables. In order to achieve this, we apply the rounding techniques described in

[38]. As an illustration example, for a solution , we define rounding threshold , where enforced binary value of is given by:


As highlighted in [9, 39], the rounding technique may violate communication, caching, and computation resource constraints. Therefore, as proposed in [9] and [39], to overcome this issue, we solved in the form by updating the constrains in (41a), (41b), and (41c) as follows:


where, in self-driving car, we use as maximum violation of communication, caching, and computation resource constraints and as the weight parameter of . Furthermore, the values of , , and are given by:


In order to evaluate the quality of our rounding technique, we use the integrality gap defined and proved in [38]. Therefore, for given problems and , the integrality gap is expressed as follows:


For , the solution is obtained by using relaxed vectors , and . On other hand, for , the solution is obtained by enforcing the vectors , and to be the vectors of binary variables. Therefore, the best rounding is achieved, when ( for the feasible solution).

Iv-B1 Proposed Algorithm

1:  Preconditions: MLP outputs are deployed to the RSUs;
2:  Input: : A vector of passengers; : A vector of self-driving cars, : A vector of RSUs, : A vector of backhaul capacities, : A vector of wireless link capacities, : MLP outputs, : Vector of recommended contents for self-driving car , , , and ;
3:  Output: ;
4:  Initialize ;
5:  Find initial feasible points (, , );
6:  repeat
7:     Choose index set ;
8:     Let ;
9:     Set