MDVSP
Multiple Depot Vehicle Scheduling Problem
view repo
We define a new problem called the Vehicle Scheduling Problem (VSP). The goal is to minimize an objective function, such as the number of tardy vehicles over a transportation network subject to maintaining safety distances, meeting hard deadlines, and maintaining speeds on each link between the allowed minimums and maximums. We prove VSP is an NP-hard problem for multiple objective functions that are commonly used in the context of job shop scheduling. With the number of tardy vehicles as the objective function, we formulate VSP in terms of a Mixed Integer Linear Programming (MIP) and design a heuristic algorithm. We analyze the complexity of our algorithm and compare the quality of the solutions to the optimal solution for the MIP formulation in the small cases. Our main motivation for defining VSP is the upcoming integration of Unmanned Aerial Vehicles (UAVs) into the airspace for which this novel scheduling framework is of paramount importance.
READ FULL TEXT VIEW PDFMultiple Depot Vehicle Scheduling Problem
Vehicle scheduling problem (VSP) is a new scheduling problem that we define in this work. Many of the scheduling problems in the literature are motivated by real life applications. The motivation for defining this new scheduling problem is the impending integration of the Unmanned Aerial Vehicles (UAVs) in the airspace and a lack of framework for accommodating them in a scalable way. They will be used in a wide array of applications from search and rescue, to package delivery, traffic enforcement, infrastructure inspection and cinematography. This means in any city, there will be a high amount of congestion that needs to be managed to prevent mid-air collisions as well as to provide an efficient service[5]. While our main motivation comes from the application of UAVs, our scheduling problem is generic and malleable enough to use in other areas as well.
On a high level, the problem we try to solve is as follows. We are given a path over a graph for each vehicle. Our goal is to minimize the number of tardy vehicles (or any other objective function) subject to the deadlines, minimum and maximum allowed speeds on the links, and separation time gap needed when entering the nodes (which play the role of intersections).
We first compare VSP with a large class of scheduling problems known as Job Shop Scheduling (JSP). The Job Shop Scheduling problem comes in many types which are motivated by the real life problems they strive to solve. Therefore, given the vast amount of literature on the subject, a first point of attack will be to model our problem in terms of a variant of JSP. In the classic Job Shop Scheduling problem, we are given a set of jobs, each composed of a chain of operations, and each operation can be performed on a specific machine from the set of all machines. A machine can only process one operation at a time at a specified processing time. At first sight, it seems the nodes in our graph can be simulated by machines and the separation time is analogous to the processing time. However, upon further inspection, it is not clear how to model the time it takes for a vehicle to reach from one node to another. Of course, this does not seem possible in a straightforward way using the classical type. However, even using variants of JSP with properties including BLOCKING, NO-WAIT, SETUP TIMES, etc. does not seem to represent our problem in an uncomplicated way. In JSP with BLOCKING, machines will hold up the operation and remain busy if the next machine is busy which corresponds to a lack of buffer between machines. In JSP with NO-WAIT, a task cannot wait between machines. In JSP with SETUP TIMES, there will be a time delay to set up a new job on a machine. For a reference to these variants of JSP, look at e.g. [13].
Some researchers have extended JSP and these more or less standardized variants to include transportation times between the machines. That is for a job to start executing in the next machine, it will be delayed by the transportation time between the previous machine and the new one. For instance, see [7] and [14]. However, in these cases, the transportation time is fixed whereas in VSP the velocity over a link can be chosen from a range. Furthermore, in some of these works, one or more robots are used for transportation with empty trips as necessary which again does not have a resemblance to our work [7],[6].
scheduling in computer networks is another area with a vast literature. However, the underlying structure in computer networks is different. Firstly, the bottleneck are the router buffers (similar to the nodes in our case) and the packets spend most of their time in the routers whereas in our case vehicles spend only a minimal amount of time at a node and spend most of their times travelling on the links. Another difference is that packets might drop (i.e. vanish if needs be), but this is not an option for the vehicles. Furthermore, the velocity of each packet during transmission on a link is constant and equal whereas vehicles can have different velocities over the links. These results in drastically different scheduling algorithms and policies which makes it difficult to use in VSP [12].
For the application of scheduling of Unmanned Aerial Vehicles, we are aware of one work [16]. However, the authors formulate the problem as a joint optimization of routing and scheduling whereas in our case we are only interested in the scheduling aspect. This is a valid problem on its own as for various reasons, as the operator, we might not be authorized to make routing decisions. For instance, the government might restrict UAV flights for a company to only certain paths.
In the context of air traffic management, the problems are formulated differently and the algorithms being used are not directly applicable to our problem. To be more precise, in the context of air traffic management, the air space is separated into sectors that are basically a volume of airspace and the goal is to avoid over loading each sector by means of either postponing the flight or changing the calculated route for a flight [2, 11]. Therefore the underlying graph structure in our problem is different.
An area of research that has some similarities is the train scheduling literature. There are similarities and differences between our approach. Similar to us, some of the train scheduling problems use a Mixed Integer Programming (MIP) model and a similar idea of treating arrival Time Stamps at a segment as a modelling variable. But most of these models are designed for a single main line with multiple short segments attached to the main line where trains can effectively park and let other trains take over before continuing their travel on the main line. There will be different set of constraints as well involved such as assignment of locomotives and crews which do not have a counterpart for unmanned aerial vehicles[4, 3].
Our contribution can be summarized as follows.
We define a new scheduling problem called Vehicle Scheduling Problem and formulate it in terms of a mixed integer linear programming. Our model has applications among other things to movements of autonomous vehicles over a transportation network; especially autonomous unmanned aerial vehicles. The model is versatile in that we can model vehicles with various minimum and maximum speeds as well as upperbounds on deadlines. Furthermore, we can adjust the safety gap as needed per pair of vehicles for each intersections (that is nodes of the graph).
We then proceed to show the NP-hardness of VSP for all commonly used objective functions in the context of job shop scheduling problems. These include minimizing
Makespan: The time the last vehicle exits the graph.
Total (weighted) completion time: Total or (equivalently) the average travel time with potentially different weights for different vehicles.
Maximum lateness: The maximum (positive or negative valued) difference between deadline and trip completion of all vehicles.
Total tardiness: The total time past deadlines
(weighted) number of tardy vehicles: The number of vehicles that missed their deadlines.
It is possible to provide an MIP of VSP for all these objective function. To demonstrate that, we pick the objective function of number of tardy vehicles and give an MIP formulation of VSP. To deal with the computational complexity of VSP in this case, we devise a heuristic algorithm in the case where all trips are requested at the same time. We analyze the complexity of our algorithm and compare the solutions yielded from our algorithm to the optimal solution to MIP for a few random instances with a small number of vehicles. We also compare these results to a baseline algorithm that we designed.
Finally, we conclude with a discussion of the shortcomings of our algorithm such as sensitivity to noise as well as ideas for future improvement.
We first give an informal definition of VSP and then proceed to define it in a more rigorous way.
In VSP, we are given a number of vehicles each of which request to make a trip at some point in time. Trips take place over a transportation network which is abstracted away as a graph. Each trip consists of a sequence of edges on this graph. We can have unlimited vehicles on each edge travelling at the same time, but when any two vehicles reach a vertex (i.e. intersection), they must be separated by some separation time constant. Therefore, to minimize some objective function (e.g. number of tardy vehicles) we have to schedule vehicles in a way that minimizes the congestion or prioritizes certain vehicles. The velocity of each vehicle on each link must be between a minimum and a maximum velocity. Given the length of the link, one can instead find the minimum and maximum allowed time on the link. In the formal definition, instead of formulating in terms of velocities, we use these time constants. Each vehicle has to meet its trip completion hard deadline. The goal is to assign an arrival time for each vehicle at each vertex on their way (i.e. the schedule) such that the objective function is minimized.
Now, we define VSP in a more rigorous way.
An instance of VSP is a -tuple as follows. Graph is a directed connected graph that represents the traffic network. The set is a set of directed walks on and is the sequence of vertices vehicle will visit. Time constants and are the set of minimum and maximum allowed times for a vehicle to reach its next vertex in the walk. Accordingly, for each vehicle , takes the form . In a similar way, is defined. The -tuple denotes the trip request times and hard deadline is the maximum allowed delays for completing the walks. Soft deadline is the maximum allowed delays after which depending on the objective function, a penalty will incur. The set is a set of elements that specify the time separation between distinct vehicles and when performing the ’th and ’th step of their walks, respectively. Each element is defined only if vertices and are identical.
Subject to the following constraints, the goal is to find a set where for each vehicle , assigns to each vertex an arrival time stamp while the objective function is minimized. Note that we define and takes the arrival time stamps as the input.
Constraints:
Trip request time, trip continuity, and hard deadline:
(1) |
Minimum and maximum allowable link travel time:
(2) |
Separation enforcement:
(3) |
In the definition above, only the vertices are included in the description of the walk and not the edges. In our definition, since edges have unlimited capacity, we do not concern ourselves with the particular edge that is chosen. However, in real life application, the length of a link and the minimum and maximum velocity among other factors might limit us to a particular edge.
In the general case, VSP is NP-hard. We prove this for various objective functions. First we define the GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM. For the cases and , these problems are already defined in [10] and [8] (with no release dates, deadlines, or no-wait condition), respectively. Since our goal is to reduce this problem to VSP, we do not use the more or less standard notation for JSP since it makes the description of the reduction difficult.
An instance of GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM is a -tuple where is a set of machines , and is a set of jobs . Each job denotes a sequence of machines that will each process job in order, for a duration of one time unit. The -tuple denotes the release dates and denotes the deadlines corresponding to each job, respectively. Additionally, is a Boolean parameter that is if jobs cannot wait between machines, otherwise .
Subject to the following constraints, the goal is to find a set where for each job , assigns to each operation a starting time on their associated machine while the objective function is minimized. Note that we define and takes the arrival time stamps as the input.
Constraints:
– Operations done in order, i.e.
.
– Any machine can process only one operation at a time, i.e. for any distinct , if there exists such that , then .
– No job scheduled before its release date, i.e.
.
– If deadlines are hard deadlines, then meeting deadlines, i.e.
.
– No-wait condition, i.e.
if is , for any and any with , we have .
We first show there is an efficient reduction from GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM with an arbitrary objective function to VSP.
GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM has a polynomial time reduction to VSP.
The input to GENERALIZED K-MACHINE UNIT JOB SHOP is a -tuple . The input to VSP is a -tuple . We generate an input to the latter, for every input to the former. We set with vertices to be a complete digraph with vertices. We establish a one-to-one correspondence between the jobs in and walks in as follows. Assuming and job has a length of ; for and the job , we create a corresponding walk where if and only if . The sequences , , and will have a length of and for any , both and have length . Next, we set . If is (i.e. jobs can wait), we set , otherwise if is (no-wait), . We set . For the deadlines, if is a hard deadline, we set . However, if is a soft deadline, we set and . Lastly, we will use the same objective function in the reduction with arguments changing from to . This completes the conversion of the inputs. Now, to translate the solution for VSP to GENERALIZED K-MACHINE UNIT JOB SHOP is straightforward. To convert the outputs, for any arrival time stamps for , we let , and with this, the reduction is complete. ∎
We prove NP-hardness for all commonly used objective functions in the context of job shop scheduling [13].
VSP with any of the following objective functions is NP-hard.
Minimizing:
Makespan ()
Total completion time ()
Total weighted completion time ()
Maximum lateness (lateness can be positive, 0, or negative for each vehicle) ()
Total tardiness (0 or positive for each vehicle) ()
Weighted number of tardy (or late) vehicles ()
Number of tardy (or late) vehicles ()
For any of these objective functions, we refer to a special case of GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM that is proven NP-hard in the literature. Then, by applying Theorem 1, the NP-hardness of VSP is established for that objective function. In the following, the objective functions related to tardy vehicles correspond to tardy jobs in the context of JSP problem.
Makespan: GENERALIZED K-MACHINE UNIT JOB SHOP is NP-hard according to [10], where and all jobs are released at time () and there is no deadline () and the jobs can wait (). This problem is referred to as 3-MACHINE UNIT JOB SHOP.
Total tardiness: GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM with and the same setting as in the Makespan case above is NP-hard. This problem is referred to as 2-MACHINE UNIT JOB SHOP [8, 15].
Total (weighted) completion time, (Weighted) number of tardy vehicles: Using the same setting as above for 2-MACHINE UNIT JOB SHOP PROBLEM with release dates, this problem is NP-hard. Note that without the release dates, this problem is polynomially solvable [8, 9, 15].
Maximum lateness: For similar setting as in the case of Total Completion Time, 2-MACHINE UNIT JOB SHOP PROBLEM where jobs cannot wait between two machines () is strongly NP-hard [15]. ∎
In the next section, we give an MIP formulation of the VSP where to demonstrate, we use the number of tardy vehicles as our objective function. It is possible to develop MIP formulation for the other objective functions as well by perhaps introducing more variables and doing the necessary minor adjustments.
We use the same notation from VSP problem and some additional notations as follows.
Variables ,
, decision binary variable
, and a large fixed number will be used to convert the absolute value constraints to mixed integer linear constraints. The decision binary variable will effectively decide between each pair of vehicles with a conflicting node, which one will have the right of way.Variable will designate a late vehicle, will designate how late vehicle is and a large fixed number will be used to convert the constraints of form into mixed integer linear constraints. We add variable to designate a soft deadline that a vehicle will strive to meet. On the other hand, the hard deadline must be met to have a feasible solution.
We use the total number of tardy vehicles as our objective function.
(4) |
We use the same constraints as in Definition II.1 except for the constraints that follow. The first constraint is the separation enforcement constraint of Eq. 3 where through the standard techniques, the absolute value constraint can be converted to a set of three mixed integer linear constraints.
(5) |
(6) |
(7) |
Furthermore, we convert the late vehicle constraints into the acceptable form for a linear integer programming instance using familiar techniques as follows.
(8) |
(9) |
(10) |
(11) |
We introduce this baseline algorithm with the purpose of comparing its result to the result from the heuristic algorithm introduced in the next section. Our goal is to establish the superiority of the latter algorithm.
The algorithm PROXIMITY resembles the decentralized heuristics used by car drivers in the real world and is as follows. Each vehicle on a link attached to an intersection will access that intersection at the earliest possible time, if and only if it is the closest (in time) vehicle to cross that intersection. An implementation of this algorithm is shown in Fig. 1 and Fig. 2 with variable set accordingly.
Our heuristic algorithm is as follows. The algorithm returns the best solution from three independent subroutines.
PROXIMITY : It is the baseline algorithm introduced earlier.
ABS DEADLINE & PROXIMITY: It is similar to PROXIMITY with the difference that among vehicles of equal (time) distance, the ones with a lower so called delay slack are prioritized over those with higher values. We calculate the delay slack for a vehicle as the difference between its deadline and the shortest trip time possible. However, if no delay slack is left; that is the calculated delay slack is a negative quantity, we give these vehicles the lowest priorities and among themselves, they will cross the intersection in arbitrary orders.
REL DEADLINE & PROXIMITY: It is similar to the previous subroutine except that the delay slack is divided by the number of intersections left in the trip.
An implementation for each of these subroutines is shown in Fig. 1 and Fig. 2 with variable set accordingly.
The implementation of the three subroutines mentioned above are the same with minor differences in the subroutine component in Fig. 2. This results for the time complexity of all these algorithms to be similar. This is true because with efficient implementation of the data structures, the has the same time complexity of in all of the cases. Therefore to obtain the time complexity of all the three subroutines, we need only to obtain the time complexity of the subroutine in Fig. 1.
The time complexity of the algorithm will depend on the actual implementation of the data structures which is as follows. In the implementation, we assume we populate these data structures at the point in the algorithm where is assigned which will take time. We keep the following hash tables:
Time stamps to list of vehicles:
2-tuples of current node time stamps and next nodes to list of vehicles: .
Nodes to the list of time stamps:
The most time consuming operations is step 22 in Fig. 1 which takes where is the total number of time stamps. Assuming is the degree of the underlying graph, considering the outer loops, the total time spent on this operation is where is the number of vehicles.
If we make the further assumption that the length of each path is constant, the worst case complexity of both the baseline and the heuristic algorithm is simplified to .
In this section, we compare the performance of our heuristic algorithm DEADLINE & PROXIMITY to our baseline algorithm PROXIMITY. Additionally, for the smaller cases, We compare the results from both these algorithms to the exact solution obtained from solving the MIP. We consider three metrics in our comparisons, namely, the number of vehicles, the tightness of the soft deadlines, and the run time of the algorithms.
In our setup, we create uniformly at random pairs of source and destinations and calculate the shortest paths on the grid like graph as shown in Fig 3. We use the following parameters.
Separation gap for any .
Minimum and maximum times on link and for all .
Hard deadlines for each .
Trip request time for each .
For our setup we used Gurobi optimization engine version 8.1.1 running on Microsoft Surface Pro 5 with 8GB RAM and 4 Intel(R) Core(TM) i5-7300U CPUs clocking at 2.60GHz. A Gurobi Python 3.6 binding was used to solve the MIP exactly. Also, we implemented the baseline and the heuristic algorithm in Python 3.6.
We create instances of VSP with four different vehicle counts; 25, 50, 75, and 100. For each instance, we experiment with varying levels of tightness of the soft deadline. The fraction of missed deadlines corresponding to each deadline value are reported in Fig. 4. The worst run time over all deadlines for each number of vehicles is reported in Fig. 6 for the baseline and the heuristic algorithms.
For 25 vehicles, Fig. (a)a shows the results comparing the percentage of missed deadlines for our heuristic algorithm, the baseline, and the exact solution from MIP. Given the small difference between the result from the baseline algorithm and the exact solution, it is plausible to infer the baseline algorithm is in fact a very effective one in producing schedules with a few number of missed deadlines.
In the case of 25 vehicles, we are able to solve most of the MIP instances exactly in a reasonable amount of time (less than 1 hour). Since The MIP quickly becomes intractable with increasing the number of vehicles; the 25 vehicles is about the maximum number of vehicles that can be used in our test. The comparison between the run time of our heuristic algorithm to the MIP instance solved by Gurobi is reported in Fig. 5 on a logarithmic scale. In most cases, our algorithm is between 1 to 3 orders of magnitude faster, despite the fact that our heuristic algorithm is implemented in notoriously slow Python.
Finally, Fig. 6 shows a comparison between the run time of our heuristic algorithm and the baseline algorithm.
In this work, we assumed the route for each vehicle is fixed. There are scenarios where this might make sense for example when some UAV companies are allocated various paths in the airspace by the government and all the scheduling must be performed over these preallocated paths. However, in absence of these kind of limitations, an interesting problem to consider for future research is the joint optimization of routing and scheduling.
Another simplified aspect of the problem is the assumption that each link has unlimited capacity for holding vehicles. This is not entirely without merit as the in-flow and out-flow are bounded by various constraints. However, it might be plausible to set a direct capacity limit on a link, especially when the minimum permitted velocity on a link is .
With minor modifications, it is possible to expand the DEADLINE & PROXIMITY algorithm and the baseline PROXIMITY to the dynamic VSP to make it more applicable to the real word. It is interesting to see how these two algorithms will compare in that case.
In our numerical result section, we demonstrated for some special cases the result from our heuristic algorithm. It will be interesting to explore more cases, such as when the trip request times are arbitrary and the minimum speed for vehicles can be more than 0.
A limitation of our work is that in our heuristics algorithm DEADLINE & PROXIMITY, the access rule is based on first the proximity of the vehicles to the intersections and only then the deadlines are used as a tie breaking mechanism. In our setup, the time stamps from the created schedules were all a multiple of an integer (in our case, 5), allowing the tie breaking rule a chance to have an influence. In practice, the tie breaking will likely never be used as the odds of having two vehicles at the exact same distance (up to our measurement digital precision) is close to 0. In other words, in presence of noise, etc., our heuristic algorithm degrades to the baseline algorithm. A simple fix is to use a window of a certain size inside which the deadline is the deciding rule. However, to determine the optimal window size will be the subject of a future work.
Another question with regard to both the baseline and the heuristic algorithms is how irregular sizes for the links will affect the quality of the created schedules. For example, a vehicle might be an intersection away from an intersection of interest, and only a very short distance away. But it will get a lower priority compared to a further away vehicle which is already on a connected link to the intersection. It is an interesting line of research to pursue expanding the pool of eligible vehicles in deciding the right of way to include vehicles such as the one in the example above.
Finally, there is an approximation algorithm that is used for Job Shop Scheduling known as Shifting Bottleneck as first appeared in the seminal work [1]. The goal was to minimize the makespan (completion time of the last job to finish). The algorithm works by sequencing each machine as a one machine optimization problem which can be solved efficiently. At any point, a list of sequenced machines and a list of unsequenced machines exists. Based on some criteria about which machine is the biggest next bottlenecks, the unsequenced machines are ranked and the machine with the highest rank is chosen to be sequenced next. Based on the results, the already sequenced machines are resequenced one by one till no further improvements can be found in their schedule. Again, based on the outcome of this step, and according to the bottleneck criteria the next machine is chosen and the process is repeated till all the machines are sequenced. In our context, it is an interesting venue for research to see if any algorithm with a similar idea of detecting the bottleneck vehicles or the bottleneck nodes or even a set of bottleneck neighboring nodes (similar to a zone) can be used to give better schedules.
In this work we introduced a new scheduling problem called Vehicle Scheduling Problem. Given a path between a pair of source and destination for each vehicle over a graph, the goal is to minimize some objective function such as the number of tardy vehicles (i.e. missed deadlines) subject to various constraints as follows. This includes, maintaining a safety time gap at conflicting nodes and meeting hard deadlines after trips are requested by vehicles. Furthermore, each vehicle is required to maintain its speed in an allowable range over any link. We established the NP-hardness of VSP for all commonly used objective functions in the context of JSP. Then, we formulate this problem in terms of a Mixed Integer Linear Programming where the chosen objective function is the number of tardy vehicles. For the case of simultaneous trip requests, we then devised a heuristic algorithm based on giving priority to vehicles closer to an intersection and with less slack time left. We also devised a baseline algorithm that mimics to some extent the real world traffic, i.e. vehicles closer to an intersection will get there first. We then performed numerical experiments on random instances of the problem over a grid like graph to compare the obtained objective value from the exact solution to the MIP formulation as well as the baseline algorithm and our algorithm.
We would like to thank Stephen Smith for fruitful discussions on the subject.
The Knowledge Engineering Review
27 (3), pp. 361–392. Cited by: §I.