# Vehicle Trajectory Prediction Method for Task Offloading in Vehicular Edge Computing

^{*}

## Abstract

**:**

## 1. Introduction

- We define a new TPPT data structure for trajectory prediction in VEC. To reduce the storage resources in VEC, the TPPT only stores the trajectories related to the current edge server. To improve the accuracy and efficiency, the TPPT stores the vehicle frequent item and the vehicle frequent pattern. The TPPT is updated in real time according to the feedback of the prediction result transmitted from the predicted edge server.
- In order to improve accuracy and efficiency when using the TPPT in VEC, we propose a TPPT construction algorithm, a TPPT prediction algorithm and a TPPT updating algorithm, respectively. By analyzing the characteristics of edge computing servers, we apply the TPPT in this scenario with the aim of improving efficiency and accuracy. At the same time, it provides real-time prediction results for task offloading.
- We design the task offloading strategies via V2I and V2V communication based on the proposed prediction. By analyzing the energy consumption, we propose a search algorithm for task offloading to minimize the energy consumption with the constraint of time consumption.

## 2. Literature Review and Problem Statement

#### 2.1. Task Offloading Research

#### 2.2. Trajectory Prediction Research

#### 2.3. Definitions and Problem Statement

**Definition**

**1.**

_{i}denotes the edge server through which vehicle v passes. The length of the vehicle trajectory TB is n + 1. Simulating the vehicle trajectory with the Capital Bikeshare datasets [24] and assuming that the vehicle trajectory of member number W00742 is TB

_{0}, we have

**Definition**

**2.**

_{i}in a given vehicle trajectory set D. It is defined as

_{1}, TB

_{2}, …, TB

_{j}, …, TB

_{z}}, where the vehicle trajectory TB

_{j}is an element in the set D. The length of the vehicle trajectory set D is z. If the vehicle trajectories TB

_{i}and TB

_{j}satisfy TB

_{i}⊆ TB

_{j}, TB

_{i}is the vehicle subtrajectory of TB

_{j}.

**Definition**

**3.**

_{h}between neighboring edge servers. Each edge R

_{h}consists of neighboring edge servers and the corresponding vehicle trajectory support, i.e., E = <R

_{1}, R

_{2}, …, R

_{h}, …, R

_{n}>, R

_{h}= (b

_{h−1}, b

_{h}, s

_{h}), s

_{h}= Support(TB

_{h}). In the sequence, the length of R is n, when the length of TB is n + 1. Moreover, another representation of the vehicle T-pattern is given in this paper:

_{0}is

- The set D = {TB
_{1}, TB_{2}, …, TB_{j}, …, TB_{z}} is extracted from the vehicle trajectory datasets, where any element TB_{j}is a vehicle trajectory; - The sequence TB
_{p}= <b_{1}, b_{2}, …, b_{k}, …, b_{p}> is the current vehicle trajectory, where any element b_{k}is an edge server, and its extension b_{p}_{+1}is to be predicted.

- The vehicle trajectory TB
_{p}_{+1}consists of the vehicle trajectory TB_{p}and the unknown but existing edge server b_{p}_{+1}; - The vehicle trajectory TB
_{p}_{+1}is a subset of the elements in the vehicle trajectory set D. That is, ∃TB_{j}ϵ D such that TB_{p}_{+1}⊆ TB_{j}.

_{p}

_{+1}such that the vehicle trajectory TB

_{p}and the edge server b

_{p}

_{+1}form the vehicle trajectory TB

_{p}

_{+1}. Meanwhile, the vehicle trajectory TB

_{p}

_{+1}has the maximum vehicle trajectory support.

## 3. Materials and Methods

- We construct the TPPT on the edge server in the initialization stage of the VEC scenario. We propose a TPPT construction algorithm which constructs the vehicle T-pattern tree, vehicle frequent itemset and vehicle frequent pattern based on the historical vehicle trajectories on the edge server locally.
- We predict the vehicle trajectory based on the TPPT in the VEC scenario. We propose a TPPT prediction algorithm which predicts the future location of the edge server in real time. The computation tasks are transmitted to the prediction result via V2I or V2V communication for the task offloading optimization of VEC.
- We update the TPPT based on the feedback of prediction results in the VEC scenario. In order to maintain the timeliness of the TPPT in VEC, we propose a TPPT updating algorithm which updates the vehicle frequent itemset and vehicle frequent pattern of the TPPT in real time according to the feedback of the prediction result transmitted from the predicted edge server.

_{max}}, where c is the number of computation resources required to complete the task, d is the size of the task, and t

_{max}denotes the maximum tolerable delay. The computation process of VEC usually considers 2 scenarios. If the computation task uses local computation resources, then it takes time t

_{1}= c/c

_{l}to complete this task, where c

_{l}denotes the local computation resources. Since the local computing resource c

_{l}is usually small, it is difficult for time t

_{1}to satisfy t

_{1}< t

_{max}. The computation task can also be transmitted to the edge server b

_{0}. Therefore, the overall process requires time t

_{2}= c/c

_{s}+ t

_{c}+ t

_{y}, where c

_{s}denotes the computational resources of the edge server, t

_{c}denotes the time of communication, and t

_{y}denotes the time of trajectory prediction. The vehicle trajectory prediction method based on the vehicle frequent pattern makes the total time t

_{2}satisfy t

_{2}< t

_{max}as much as possible by reducing t

_{c}and t

_{y}.

#### 3.1. Definition of the T-Pattern Prediction Tree

**Definition**

**4.**

**Definition**

**5.**

_{0}, b

_{1}, …, b

_{k}, …, b

_{n}}, b

_{k}denotes the edge server in Equation (1); E is similar to the set of edges in Equation (4), i.e., E = {R

_{1}, R

_{2}, …, R

_{h}, …, R

_{m}}, R

_{h}= (b

_{k−1}, b

_{k}, s

_{k}). In the vehicle T-pattern tree, the data structure is not a sequence. As a result, there is no direct relationship between the length of edge servers n and the length of edges m. In the vehicle T-pattern tree, node b

_{k}is the child of node b

_{k−1}, and node b

_{k−1}is the parent of node b

_{k}. If b

_{k}does not have a parent node, b

_{k}is the root node; if b

_{k}does not have a child node, b

_{k}is a leaf node.

_{k}ϵ N′, R

_{h}ϵ E′ such that 1 ≤ |{R

_{h}|b

_{k}ϵ R

_{h}}| ≤ 2, TPT′ is a branch of the vehicle T-pattern tree TPT, denoted as TR.

- Each node has different children;
- Each branch is a portion of the vehicle T-pattern;
- All the branches starting with the root node and ending with the parent of the leaf node are the prefixes of the vehicle T-pattern.

**Definition**

**6.**

**Definition**

**7.**

#### 3.2. Construction of the T-Pattern Prediction Tree

Algorithm 1: Algorithm for construction of the T-pattern prediction tree. |

Input: vehicle trajectory datasets D, D = {TB_{1}, TB_{2}, …, TB_{j}, …, TB_{z}}. |

Output: T-pattern prediction tree TPPT. |

1. Init(TPT, IT, FR) |

2. for each TB_{j} in D |

3. for each b_{k} in TB_{j} |

4. TB_{k} = <b_{0}, …, b_{k}> |

5. TP_{k} = convert_TP(TB_{k}) |

6. if TP_{k} in TPT: |

7. TP_{i} = TPT.find_branch(TP_{k}) |

8. TP_{i}.support += 1 |

9. if TP_{k} not in TPT: |

10. TP_{i}_{−1} = TPT.find_branch(TP_{k}_{−1}) |

11. TP_{i} = TP_{i}_{−1}. Add_node(b_{k}) |

12. TP_{i}.support = 1 |

13. end for |

14. end for |

15. for b_{k} in TPT.Leaf_node |

16. TB_{k} = <b_{0}, …, b_{k}> |

17. TP_{k} = Convert_TP(TB_{k}) |

18. set_{k} = (b_{k}, TP_{k}.support) |

19. IT.Add_set(set_{k}) |

20. FR.Add_relationship(TP_{k}, b_{k}) |

21. end for |

22. return TPPT = (TPT, IT, FR) |

_{k}of the vehicle trajectory TB

_{j}. Lines 4~5 construct the vehicle trajectory TB

_{k}and its corresponding vehicle T-pattern TP

_{k}, with b

_{0}as the start and b

_{k}as the end. Lines 6~12 determine whether there is the same vehicle T-pattern as TP

_{i}in the vehicle T-pattern tree. If there is, the vehicle trajectory support corresponding to TP

_{i}is incremented; otherwise, TP

_{i}is constructed in the vehicle T-pattern tree and the vehicle trajectory support corresponding to TP

_{i}is set to 1.

_{k}of the vehicle T-pattern tree to construct the vehicle trajectory TB

_{k}and its corresponding vehicle T-pattern TP

_{k}starting from b

_{0}and ending at b

_{k}. Lines 18~19 construct a set composed of the leaf node b

_{k}and the corresponding vehicle trajectory support. Then, the set is added into the vehicle frequent itemset. Line 20 constructs a binary tuple jointly constituted by the vehicle T-pattern TP

_{k}and the leaf node b

_{k}. Then, the binary tuple is added into the vehicle frequent patten.

#### 3.3. Prediction Based on the T-Pattern Prediction Tree

_{p}. set.value is the latter element of the set in the vehicle frequent itemset, i.e., the vehicle trajectory support s

_{p}. The optimization scheme is to find the edge server that has the highest support score among the vehicle frequent itemset, which can also be represented as

_{p}

_{+1}is the prediction result, i.e., the edge server that the vehicle trajectory will pass through in the future. For this optimization scheme, this paper designed a prediction algorithm for the T-pattern prediction tree, also called the TPPT algorithm. The Algorithm 2 is shown below.

Algorithm 2: Prediction algorithm for the T-pattern prediction tree. |

Input: T-pattern prediction tree TPPT, current vehicle trajectory TB_{p}. |

Output: Edge computing server b_{p}_{+1}. |

1. TPT = extract_TPT(TPPT) |

2. while IT = Ø do: |

3. TB = match_TB(TPT, TB_{p}) |

4. IT = match_IT(TB, FR) |

5. TB_{p} = delete_first_node(TB_{p}) |

6. end while |

7. merge(IT) |

8. Highest_score = 0 |

9. for each set in IT: |

10. if set.value > Highest_score: |

11. b_{p}_{+1} = set.key |

12. Highest_score = set.value |

13. end for |

14. return b_{p+1} |

#### 3.4. Real-Time Updating of the T-Pattern Prediction Tree

_{p}

_{+1}of the edge server b

_{p}and the time threshold t, if the current vehicle has passed the edge server b

_{p}

_{+1}within the time threshold t, the prediction result is correct. Otherwise, the prediction result is incorrect. The edge server b

_{p}

_{+1}generates feedback of the prediction result based on whether the prediction result is correct or not. The feedback is transmitted to the edge server b

_{p}. The edge server b

_{p}updates the maintained TPPT after obtaining the feedback. The Algorithm 3 is shown below.

Algorithm 3: Real-time updating algorithm for the T-pattern prediction tree. |

Input: original T-pattern prediction tree TPFT_{α}, feedback of prediction result. |

Output: updated T-pattern prediction tree TPFT_{β}. |

1. TB = match_TB(TPT, result.TB) |

2. IT = match_IT(TB, FR) |

3. if result.prediction = True: |

4. TB.support += 1 |

5. IT.set.value += 1 |

6. if result.prediction = False: |

7. TB.support −= 1 |

8. IT.set.value −= 1 |

9. TPFT_{β} = update(TPFT_{α}, TB, IT) |

10. return TPFT_{β} |

_{α}. Lines 4~9 determine whether the prediction result is correct or not. If the prediction result is correct, the vehicle trajectory support corresponding to this vehicle trajectory is incremented. Otherwise, the vehicle trajectory support corresponding to this vehicle trajectory is decremented. Line 10 synchronizes the update results to the T-pattern prediction tree.

#### 3.5. Task Offloading Strategies, Energy Consumption and Search Algorithm

_{1}, T

_{2}, …, T

_{v}, …, T

_{w}}. Each task T

_{v}= {c

_{v}, d

_{v}, t

_{v}} is a ternary tuple T

_{v}where c

_{v}is the number of computation resources required to complete the task T

_{v}, d

_{v}is the size of the task, and t

_{v}denotes the maximum tolerable delay. Then, for each edge server, b is a quintet defined as $b=\{{f}_{b},{P}_{b}^{c},{P}_{b}^{c}\}$, where ${f}_{b},{P}_{b}^{c},{P}_{b}^{c}$ are the computation rate, computation power and transmission power, respectively. Finally, let f

_{r}be the transmission rate.

_{p}denotes the time consumption of the prediction, and the energy consumption is

Algorithm 4: Search algorithm for task offloading. |

Input: computation tasks set C, edge server b_{1}, edge server b_{2}. |

Output: minimum energy consumption E_{min}. |

1. E_{min} = +ꝏ |

2. for each v in |C|: |

3. t_{all} = calculate t in Equation (19) based on v, b_{1,} b_{2} |

4. E_{all} = calculate E in Equation (20) based on v, b_{1,} b_{2} |

5. if t_{all} < min(t_{1}, …, t_{w}): |

6. if E_{all} < E_{min}: |

7. E_{all} = E_{min} |

8. return E_{all} |

## 4. Results and Discussions

#### 4.1. Experimental Environment, Datasets and Parameters

_{j}denotes the number of samples predicted correctly, and F

_{j}denotes the number of samples predicted incorrectly in sample j. The experiment analyzed the accuracy by this formula and the efficiency by the running time of the program.

#### 4.2. Comparisons and Analysis with Deep Learning Methods

#### 4.3. Comparisons and Analysis with the T-Pattern Algorithm

#### 4.3.1. Accuracy Comparisons and Analysis

#### 4.3.2. Efficiency Comparisons and Analysis

#### 4.4. Performance Evaluation of Task Offloading

## 5. Conclusions and Future Work

- In terms of trajectory prediction, we will integrate more trajectory information to further improve the accuracy and efficiency, such as coordinate, timestamp and distance. Such information will affect the accuracy of trajectory predictions. In addition, such information is helpful in VEC, which affects the strategies of task offloading.
- In terms of task offloading in VEC, we will incorporate more of the energy consumption which is important in VEC. For the energy consumption, we may consider traffic dynamics and load balance in VEC. In addition, we will use the blockchain to manage the tasks.
- In terms of the styles of computing, we will try to use the TPPT in vehicular cloud computing and vehicular fog computing. Since different paradigms have different scopes of application, we will compare their application results.

## Author Contributions

## Funding

## Institutional Review Board Statement

## Informed Consent Statement

## Data Availability Statement

## Conflicts of Interest

## References

- Liu, L.; Chen, C.; Pei, Q.; Maharjan, S.; Zhang, Y. Vehicular Edge Computing and Networking: A Survey. Mob. Netw. Appl.
**2021**, 26, 1145–1168. [Google Scholar] [CrossRef] - Luo, Q.; Hu, S.; Li, C.; Li, G.; Shi, W. Resource Scheduling in Edge Computing: A Survey. IEEE Commun. Surv. Tutor.
**2021**, 23, 2131–2165. [Google Scholar] [CrossRef] - Huang, X.; Yu, R.; Kang, J.; He, Y.; Zhang, Y. Exploring Mobile Edge Computing for 5G-Enabled Software Defined Vehicular Networks. IEEE Wirel. Commun.
**2017**, 24, 55–63. [Google Scholar] [CrossRef] - Zhuang, W.; Ye, Q.; Lyu, F.; Cheng, N.; Ren, J. SDN/NFV-Empowered Future IoV With Enhanced Communication, Computing, and Caching. Proc. IEEE
**2020**, 108, 274–291. [Google Scholar] [CrossRef] - Fan, W.; Su, Y.; Liu, J.; Li, S.; Huang, W.; Wu, F.; Liu, Y. Joint Task Offloading and Resource Allocation for Vehicular Edge Computing Based on V2I and V2V Modes. IEEE Trans. Intell. Transp. Syst.
**2023**, 24, 4277–4292. [Google Scholar] [CrossRef] - Hejja, K.; Berri, S.; Labiod, H. Network Slicing with Load-Balancing for Task Offloading in Vehicular Edge Computing. Veh. Commun.
**2022**, 34, 100419. [Google Scholar] [CrossRef] - Zhang, K.; Mao, Y.; Leng, S.; He, Y.; Zhang, Y. Mobile-Edge Computing for Vehicular Networks: A Promising Network Paradigm with Predictive Off-Loading. IEEE Veh. Technol. Mag.
**2017**, 12, 36–44. [Google Scholar] [CrossRef] - Liu, W.; Du, Q.; Wang, W. Cloud-based Computation Offloading in Vehicular Networks. In Proceedings of the 2021 IEEE 2nd International Conference on Information Technology, Big Data and Artificial Intelligence, Chongqing, China, 17–19 December 2021; pp. 242–246. [Google Scholar] [CrossRef]
- He, B.; Li, T. An Offloading Scheduling Strategy with Minimized Power Overhead for Internet of Vehicles Based on Mobile Edge Computing,” Journal of Information Processing Systems. J. Inf. Process. Syst.
**2021**, 17, 489–504. [Google Scholar] [CrossRef] - Wang, Y.; Hu, X.; Guo, L.; Yao, Z. Research on V2I/V2V Hybrid Multi-hop Edge Computing Offloading Algorithm in IoV Environment. In Proceedings of the 2020 IEEE 5th International Conference on Intelligent Transportation Engineering, Beijing, China, 11–13 September 2020; pp. 336–340. [Google Scholar] [CrossRef]
- Liu, J.; Liu, N.; Liu, L.; Li, S.; Zhu, H.; Zhang, P. A Proactive Stable Scheme for Vehicular Collaborative Edge Computing. IEEE Trans. Veh. Technol.
**2023**, 72, 10724–10736. [Google Scholar] [CrossRef] - Wei, H.; Luo, H.; Sun, Y. Mobility-Aware Service Caching in Mobile Edge Computing for Internet of Things. Sensors
**2020**, 20, 610. [Google Scholar] [CrossRef] [PubMed] - Bahra, N.; Pierre, S. RNN-Based User Trajectory Prediction Using a Preprocessed Datasets. In Proceedings of the 2020 16th International Conference on Wireless and Mobile Computing, Networking and Communications, Thessaloniki, Greece, 12–14 October 2020; pp. 1–6. [Google Scholar] [CrossRef]
- Tsiligkaridis, A.; Zhang, J.; Paschalidis, I.C.; Taguchi, H.; Sakajo, S.; Nikovski, D. Context-Aware Destination and Time-To-Destination Prediction Using Machine learning. In Proceedings of the 2022 IEEE International Smart Cities Conference, Pafos, Cyprus, 26–29 September 2022; pp. 1–7. [Google Scholar] [CrossRef]
- Cao, K.; Liu, Y.; Meng, G.; Sun, Q. An Overview on Edge Computing Research. IEEE Access
**2020**, 8, 85714–85728. [Google Scholar] [CrossRef] - Nguyen, T.H.; Park, L. A Survey on Deep Reinforcement Learning-driven Task Offloading in Aerial Access Networks. In Proceedings of the 2022 13th International Conference on Information and Communication Technology Convergence, Jeju Island, Republic of Korea, 19–21 October 2022; pp. 822–827. [Google Scholar] [CrossRef]
- Monreale, A.; Pinelli, F.; Trasarti, R.; Giannotti, F. WhereNext: A Location Predictor on Trajectory Pattern Mining. In Proceedings of the 15th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Paris, France, 28 June–1 July 2009; pp. 637–646. [Google Scholar] [CrossRef]
- Dong, Z.; Deng, J.; Jiang, X.; Wang, Y. RTMatch: Real-Time Location Prediction Based on Trajectory Pattern Matching. In Proceedings of the Database Systems for Advanced Applications: DASFAA 2017 International Workshops: BDMS, BDQM, SeCoP, and DMMOOC, Suzhou, China, 27–30 March 2017; pp. 103–117. [Google Scholar] [CrossRef]
- Cai, H.; Guo, Y.; Lu, K. A Location Prediction Method for Work-in-process Based on Frequent Trajectory Patterns. Proc. Inst. Mech. Eng. Part B-J. Eng. Manuf.
**2019**, 233, 306–320. [Google Scholar] [CrossRef] - Han, N.; Qiao, S.; Yuan, G.; Mao, R.; Yue, K.; Yuan, C. A Novel Handover Detection Model via Frequent Trajectory Patterns Mining. Int. J. Mach. Learn. Cybern.
**2020**, 11, 2587–2606. [Google Scholar] [CrossRef] - Cai, M.; Yan, R.; Doryab, A. Daily Trajectory Prediction Using Temporal Frequent Pattern Tree. In Proceedings of the 6th International Congress on Information and Communication Technology, London, UK, 25–26 February 2022; pp. 333–343. [Google Scholar] [CrossRef]
- Comito, C. NexT: A Framework for Next-place Prediction on Location Based Social Networks. Knowl. Based Syst.
**2020**, 204, 106205. [Google Scholar] [CrossRef] - Real Vehicle Data. Available online: https://github.com/rblaughol/real-vehicle-data (accessed on 1 September 2023).
- Capital Bikeshare Trip History Data. Available online: https://ride.capitalbikeshare.com/system-data (accessed on 19 July 2023).
- Waheed, A.; Shah, M.A.; Mohsin, S.M.; Khan, A.; Maple, C.; Aslam, S.; Shamshirband, S. A comprehensive review of computing paradigms, enabling computation offloading and task execution in vehicular networks. IEEE Access
**2022**, 10, 3580–3600. [Google Scholar] [CrossRef] - Adam, H.; Philippe, B.; Veronique, C.; Yao, W. Vehicle Trajectory Prediction based on Motion Model and Maneuver Recognition. In Proceedings of the 2013 IEEE/RSJ International Conference on Intelligent Robots and Systems, Tokyo, Japan, 3–7 November 2013; pp. 4363–4369. [Google Scholar]
- Huang, Y.; Bi, H.; Li, Z.; Mao, T.; Wang, Z. STGAT: Modeling Spatial-Temporal Interactions for Human Trajectory Prediction. In Proceedings of the 2019 IEEE/CVF International Conference on Computer Vision, Seoul, Republic of Korea, 27 October–2 November 2019; pp. 6271–6280. [Google Scholar] [CrossRef]
- Wang, C.; Ma, L.; Li, R.; Durrani, T.S.; Zhang, H. Exploring Trajectory Prediction Through Machine Learning Methods. IEEE Access
**2019**, 7, 101441–101452. [Google Scholar] [CrossRef] - Li, Q.; Zou, D.; Xu, Y. Combining Individual Travel Behaviour and Collective Preferences for Next Location Prediction. Transp. A
**2022**, 18, 1754–1776. [Google Scholar] [CrossRef] - Huang, M.; Zhu, M.; Xiao, Y.; Liu, Y. Bayonet-corpus: A Trajectory Prediction Method Based on Bayonet Context and Bidirectional GRU. Digit. Commun. Netw.
**2021**, 7, 72–81. [Google Scholar] [CrossRef] - Liu, Y.; Yu, H.; Fang, H. Application of KNN Prediction Model in Urban Traffic Flow Prediction. In Proceedings of the 2021 5th Asian Conference on Artificial Intelligence Technology, Haikou, China, 29–31 October 2021; pp. 389–392. [Google Scholar] [CrossRef]

Key | Value |
---|---|

(b) 20th St | 1 |

(d) 20th St | 2 |

(c) 18th St | 2 |

…… | …… |

Data Sources | Field Name | Field Type |
---|---|---|

Real-vehicle datasets | Trajectory serial number | Unsigned integer |

Bayonet serial number | Unsigned integer | |

Capital Bikeshare | Duration of use | Unsigned integer |

Start date | String (computer science) | |

End date | String (computer science) | |

Start position | String/unsigned Integer | |

End position | String/unsigned Integer | |

Vehicle number | String (computer science) | |

Membership type | String (computer science) |

Algorithm | Training Stage | Predicting Stage | ||
---|---|---|---|---|

Minimum Time | Average Time | Minimum Time | Average Time | |

TPPT | 5.8904 | 43.6172 | 0.0045 | 0.5313 |

RNN | 3355.9228 | 3355.9228 | 81.399 | 81.399 |

Transformer | 3743.5721 | 3743.5721 | 698.6232 | 698.6232 |

λ | Algorithm | Correct Amount | Incorrect Amount |
---|---|---|---|

3 | TPPT | 179,976 | 49,939 |

T-Pattern | 159,226 | 70,689 | |

4 | TPPT | 21,006 | 7786 |

T-Pattern | 16,835 | 11,957 | |

5 | TPPT | 3234 | 1949 |

T-Pattern | 2136 | 3047 | |

6 | TPPT | 541 | 510 |

T-Pattern | 242 | 809 |

Training Set | TEST Set | Algorithm | Correct Number |
---|---|---|---|

Data from Jan to Mar | Data for Apr | TPPT | 648 |

T-Pattern | 216 | ||

Data from May to Jul | Data for Aug | TPPT | 837 |

T-Pattern | 230 | ||

Data from Sep to Nov | Data for Dec | TPPT | 1084 |

T-Pattern | 478 |

λ | Algorithm | Running Time (s) |
---|---|---|

3 | TPPT | 1.9925 |

T-Pattern | 13.3361 | |

4 | TPPT | 0.1048 |

T-Pattern | 1.7502 | |

5 | TPPT | 0.0234 |

T-Pattern | 0.3809 | |

6 | TPPT | 0.0045 |

T-Pattern | 0.0907 |

Parameter | Description | Value |
---|---|---|

${c}_{i}$ | Computation load of task i | 100 |

${f}_{b}$ | Computation rate of server b | 500 |

${d}_{i}$ | Size of task i | 20 |

${f}_{r}$ | Transmission rate | 200 |

${P}_{b}^{c}$ | Computation power of server b | 200 |

${P}_{r}^{c}$ | Transmission power of server b | 150 |

${t}_{p}$ | Time consumption of prediction | 0.5 |

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |

© 2023 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Yan, R.; Gu, Y.; Zhang, Z.; Jiao, S.
Vehicle Trajectory Prediction Method for Task Offloading in Vehicular Edge Computing. *Sensors* **2023**, *23*, 7954.
https://doi.org/10.3390/s23187954

**AMA Style**

Yan R, Gu Y, Zhang Z, Jiao S.
Vehicle Trajectory Prediction Method for Task Offloading in Vehicular Edge Computing. *Sensors*. 2023; 23(18):7954.
https://doi.org/10.3390/s23187954

**Chicago/Turabian Style**

Yan, Ruibin, Yijun Gu, Zeyu Zhang, and Shouzhong Jiao.
2023. "Vehicle Trajectory Prediction Method for Task Offloading in Vehicular Edge Computing" *Sensors* 23, no. 18: 7954.
https://doi.org/10.3390/s23187954