Online Interval Scheduling with Predictions
Joan Boyar, Lene M. Favrholdt, Shahin Kamali, Kim S. Larsen

TL;DR
This paper investigates online interval scheduling and disjoint path allocation using predictions, establishing bounds on algorithm performance based on prediction accuracy and validating findings with real-world experiments.
Contribution
It introduces a framework analyzing the impact of prediction errors on online scheduling algorithms, providing tight bounds and trade-offs between consistency and robustness.
Findings
Tight bounds on competitive ratios as a function of prediction error.
Asymptotically optimal trade-offs between consistency and robustness.
Experimental validation on real-world workloads confirming theoretical results.
Abstract
In online interval scheduling, the input is an online sequence of intervals, and the goal is to accept a maximum number of non-overlapping intervals. In the more general disjoint path allocation problem, the input is a sequence of requests, each consisting of pairs of vertices of a known graph, and the goal is to accept a maximum number of requests forming edge-disjoint paths between accepted pairs. We study a setting with a potentially erroneous prediction specifying the set of requests forming the input sequence and provide tight upper and lower bounds on the competitive ratios of online algorithms as a function of the prediction error. We also present asymptotically tight trade-offs between consistency (competitive ratio with error-free predictions) and robustness (competitive ratio with adversarial predictions) of interval scheduling algorithms. Finally, we provide experimental…
| name | input size () | no. timesteps () | max. length | avg. length |
|---|---|---|---|---|
| LLNL-uBGL-2006-2 | 13,225 | 16,671,553 | 14,403 | 1,933.92 |
| NASA-iPSC-1993-3.1 | 18,066 | 7,947,562 | 62,643 | 772.21 |
| CTC-SP2-1996-3.1 | 77,205 | 8,986,769 | 71,998 | 11,279.61 |
| SDSC-DS-2004-2.1 | 84,893 | 31,629,689 | 6,589,808 | 7,579.36 |
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsOptimization and Search Problems · Complexity and Algorithms in Graphs · Advanced Bandit Algorithms Research
11institutetext: University of Southern Denmark
11email: {joan,lenem,kslarsen}@imada.sdu.dk
https://imada.sdu.dk/u/{joan,lenem,kslarsen} 22institutetext: York University
22email: [email protected]
https://www.eecs.yorku.ca/~kamalis/
Online Interval Scheduling with Predictions††thanks: The first, second, and fourth authors were supported in part by the Danish Council for Independent Research grant DFF-0135-00018B.
The third author was supported in part by the Natural Sciences and Engineering Research Council of Canada (NSERC).
Joan Boyar 11
Lene M. Favrholdt 11
Shahin Kamali 22
Kim S. Larsen 11
Abstract
In online interval scheduling, the input is an online sequence of intervals, and the goal is to accept a maximum number of non-overlapping intervals. In the more general disjoint path allocation problem, the input is a sequence of requests, each involving a pair of vertices of a known graph, and the goal is to accept a maximum number of requests forming edge-disjoint paths between accepted pairs. These problems have been studied under extreme settings without information about the input or with error-free advice. We study an intermediate setting with a potentially erroneous prediction that specifies the set of intervals/requests forming the input sequence. For both problems, we provide tight upper and lower bounds on the competitive ratios of online algorithms as a function of the prediction error. For disjoint path allocation, our results rule out the possibility of obtaining a better competitive ratio than that of a simple algorithm that fully trusts predictions, whereas, for interval scheduling, we develop a superior algorithm. We also present asymptotically tight trade-offs between consistency (competitive ratio with error-free predictions) and robustness (competitive ratio with adversarial predictions) of interval scheduling algorithms. Finally, we provide experimental results on real-world scheduling workloads that confirm our theoretical analysis.
Keywords:
Online interval scheduling. Algorithms with prediction. Competitive analysis. Disjoint paths.
1 Introduction
In the interval scheduling problem, the input is a set of intervals with integral endpoints, each representing timesteps at which a process starts and ends. A scheduler’s task is to decide whether to accept or reject each job so that the intervals of accepted jobs do not overlap except possibly at one of their endpoints. The objective is to maximize the number of accepted intervals, referred to as the payoff of the scheduler. This problem is also known as fixed job scheduling and k-track assignment [33].
Interval scheduling is a special case of the disjoint path allocation problem, where the input is a graph and a set of requests, each defined by a pair of vertices in . An algorithm can accept or reject each pair, given that it can form edge-disjoint paths between vertices of accepted pairs. Interval scheduling is the particular case when is a path graph. The disjoint path allocation problem can be solved in polynomial time for trees [27] and outerplanar graphs by a combination of [23, 32, 26], but the problem is NP-complete for general graphs [25], and even on quite restricted graphs such as series-parallel graphs [40]. The disjoint path problem is the same as call control/call allocation with all bandwidths (both of the calls and the edges they would be routed on) being equal to 1 and as the maximum multi-commodity integral flow problem with edges having unit capacity.
In this work, we focus on the online variant of the problem, in which the set of requests is not known in advance but is revealed in the form of a sequence of intervals. A new request must either be irrevocably accepted or rejected, subject to maintaining disjoint paths between accepted requests. We analyze an online algorithm via a comparison with an optimal offline algorithm, . The competitive ratio of an online algorithm is defined as , where and , respectively, denote the payoff of and for intervals in (for randomized algorithms, is the expected payoff of ). Since we consider a maximization problem, our ratios are between zero and one.
For interval scheduling on a path graph with edges, the competitive ratios of the best deterministic and randomized algorithms are respectively and [16]. These results suggest that the constraints on online algorithms must be relaxed to compete with . Specifically, the problem has been considered in the advice complexity model for path graphs [13, 28], trees [14], and grid graphs [15]. Under the advice model, the online algorithm can access error-free information on the input called advice. The objective is to quantify the trade-offs between the competitive ratio and the size of the advice.
In recent years, there has been an increasing interest in improving the performance of online algorithms via the notion of prediction. Here, it is assumed that the algorithm has access to machine-learned information in the form of a prediction. Unlike the advice model, the prediction may be erroneous and is quantified by an error measure . The objective is to design algorithms whose competitive ratio degrades gently as a function of . Several online optimization problems have been studied under the prediction model, including non-clairvoyant scheduling [41, 43], makespan scheduling [34], contract scheduling [4, 5], and other variants of scheduling problems [8, 37, 11, 10]. Other online problems studied under the prediction model include bin packing [2, 3], knapsack [44, 31, 17], caching [38, 42], matching problems [6, 35, 36], and various graph problems [22, 24, 21, 9, 12]. See also the survey by Mitzenmacher and Vassilvitskii [39] and the collection at [1].
1.1 Contributions
We study the disjoint path allocation problem under a setting where the scheduler is provided with a set of intervals predicted to form the input sequence . Given the erroneous nature of the prediction, some intervals in may be incorrectly predicted to be in (false positives), and some intervals in may not be included in (false negatives). We let the error set be the set of intervals that are false positives or false negatives and define the error parameter to be the cardinality of the largest set of non-overlapping intervals in the error set, i.e., . We explain later that this definition of satisfies specific desired properties for the prediction error (Proposition 1). In the following, we use to denote the payoff of an algorithm for prediction and input . We also define ; this normalized error measure is helpful in describing our results because the point of reference in the competitive analysis is . Our first result concerns general graphs:
- •
Disjoint-Path Allocation: We first study a simple algorithm , which accepts a request only if it belongs to the set of intervals in a given optimal solution for . We show that, for any graph , any input sequence , and any prediction , (Theorem 3.1). Furthermore, for any algorithm and any positive integer ,
there are worst-case input sequence and prediction set over a star graph with leaves, such that and (Theorem 3.2). Thus, achieves an optimal competitive ratio in any graph that contains as a subgraph, i.e., any graph of maximum degree at least 8.
The above result demonstrates that even for trees, the problem is so hard that no algorithm can do better than the trivial . Therefore, our main results concern the more interesting case of path graphs, that is, interval scheduling:
- •
Interval Scheduling: We first show a negative result for deterministic interval scheduling algorithms. Given any deterministic algorithm and integer , we show there are worst-case instances and predictions such that and (Theorem 4.1, setting ).
Next, we present a negative result for . For any positive integer, , we show there are worst-case instances and predictions such that and (Theorem 4.2). This suggests that there is room for improvement over .
Finally, we introduce our main technical result, a deterministic algorithm that achieves an optimal competitive ratio for interval scheduling. is similar to in that it maintains an optimal solution for , but unlike , it updates its planned solution to accept requests greedily when it is possible without a decrease in the payoff of the maintained solution. For any input and prediction , we show that (Theorem 4.3), which proves optimality of in the light of Theorem 4.1.
- •
Consistency-Robustness Trade-off: We study the trade-off between consistency and robustness, which measure an algorithm’s competitive ratios in the extreme cases of error-free prediction (consistency) and adversarial prediction (robustness) [38]. We focus on randomized algorithms because a non-trivial trade-off is infeasible for deterministic algorithms (Proposition 2). Suppose that for any input , an algorithm guarantees a consistency of and robustness of . We show and (Theorem 5.1). For example, to guarantee a robustness of , the consistency must be at most , and to guarantee a consistency of , the robustness must be at most . We also present a family of randomized algorithms that provides an almost Pareto-optimal trade-off between consistency and robustness (Theorem 5.2).
- •
Experiments on Real-World Data: We compare our algorithms with the online algorithm (which accepts an interval if and only if it does not overlap previously accepted intervals), and on real-world scheduling data from [19]. Our results are in line with our theoretical analysis: both and are close-to-optimal for small error values; is almost always better than even for large values of error, while is better than only for small error values.
2 Model and Predictions
We assume that an oracle provides the online algorithm with a set of requests predicted to form the input sequence . One may consider alternative predictions, such as statistical information about the input. While these predictions are compact and can be efficiently learned, they cannot help achieve close-to-optimal solutions. In particular, for interval scheduling on a path with edges, since the problem is AOC-complete, one cannot achieve a competitive ratio with fewer than bits [18].
In what follows, true positive (respectively, negative) intervals are correctly predicted to appear (respectively, not to appear) in the request sequence. False positives and negatives are defined analogously as those incorrectly predicted to appear or not appear. We let , , , denote the four sets containing these different types of intervals. Thus, and . We use , to denote the error for the input formed by the set , when the set of predictions is . When there is no risk of confusion, we use instead of .
The error measure we use here is , and hence, the normalized error measure is . Our error measure satisfies the following desirable properties, the first two of which were strongly recommended in Im, et al. [30]: . In Section 2.0.1, we discuss natural error models, such as Hamming distance between the request sequence and prediction, and explain why these measures do not satisfy our desired properties.
- •
Monotonicity: This property ensures that increasing the number of true positives or negatives does not increase the error. To be more precise, if we increase by one unit (decreasing by one unit) or increase by one unit (decreasing by one unit), the error must not increase. Formally, for any , , the following must hold.
- –
For any , .
- –
For any , .
- •
Lipschitz property: Let denote the number of requests in an optimal solution for the input sequence, and denote the number of requests in an optimal solution for a set of predicted requests. The Lipschitz property requires the error to be at least equal to the net difference between and , that is,
[TABLE]
Note that this property ensures that the error is not “too small”. In particular, we should not be able to decrease the error to an arbitrarily small value by adding “dummy requests”. For example, false discovery rate, defined as , does not satisfy Lipschitz property: an adversary can construct a bad input and then add a lot of intervals to , contributing to , that neither the algorithm nor will choose, driving down the error.
- •
Lipschitz completeness (or simply completeness): We need the error measure to ensure that the error is not “too large”. Consider the following example for the disjoint paths problem. The input is formed by a set of requests, with and , where the ’s are disjoint, the ’s are disjoint, and overlaps and . The true optimal solution is then . Suppose the prediction is , and note that . The optimal solutions for and are disjoint but , and . In this case, the error should be relatively small, independent of . More generally, the error measure must not grow with the dissimilarity between the optimal solutions for and , but rather with the size of the optimal solution for and . This is guaranteed by the Lipschitz completeness, which requires
[TABLE]
Proposition 1 ()
The error measure satisfies the properties of monotonicity, Lipschitz, and Lipschitz completeness.
Proof
We check all properties listed above:
- •
Monotonicity: First, consider increasing the number of true positives. Let . Since is a false negative, it may or may not have been counted in , but removing it from (thus adding it to ) cannot make larger, i.e.,
[TABLE]
Similarly, for any , cannot be larger than , so
[TABLE]
- •
Lipschitz property: We need to show that
[TABLE]
We note that
[TABLE]
which implies
[TABLE]
- •
Lipschitz completeness: Follows trivially with the suggested bound, since .∎
2.0.1 Alternative Error Measures.
In what follows, we review a few alternative error measures that do not satisfy our desired properties of monotonicity, Lipschitz, and Lipschitz completeness (or simply completeness).
- •
Hamming distance between the bit strings representing the request sequence and the predictions:
[TABLE]
It fails completeness.
- •
Using and instead of and in the above measure:
[TABLE]
also fails completeness, according to the example given in connection with the definition of completeness.
- •
Either or fails Lipschitz property.
- •
Normalizing the Hamming distance, we obtain the Jaccard distance:
[TABLE]
This measure is sensitive to dummy requests: The adversary can construct a bad input and then add a lot of intervals to that neither the algorithm nor will choose, driving down the error.
- •
We also considered normalizing by the total number of possible intervals (order ), but this measure fails the Lipschitz property, as we can make the error arbitrarily small by “scaling up” each edge to an arbitrarily long path, without changing algorithms’ payoffs.
3 Disjoint-Path Allocation
In this section, we show that a simple algorithm for the disjoint path allocation problem has an optimal competitive ratio for any graph of maximal degree at least 8. simply relies on the predictions being correct. Specifically, it computes an optimal solution in before processing the first request. Then, it accepts any interval in that arrives and rejects all others.
We first establish that, on any graph, . The proof follows by observing that (i) false negatives cause a deficit of at most in the schedule of compared to the optimal schedule for , (ii) false positives cause a deficit of at most in the optimal schedule of , compared to the optimal schedule for , and (iii) .
Theorem 3.1 ()
For any graph , any prediction , and input sequence , we have
Proof
Since is an optimal selection from , the largest number of intervals that would be able to accept from compared to would be an optimal selection from . Thus, , and so .
Similarly,
the largest number of intervals that can be detracted from is realized when intervals that it planned to accept from do not appear is . Therefore, . Now,
[TABLE]
∎
The following result shows that Theorem 3.1 is tight for star graphs of degree 8. One can conclude that is optimal for any graph that contains stars of degree 8 as a subgraph, i.e., any graph of maximal degree at least 8.
Theorem 3.2 ()
Let be any deterministic algorithm and be any positive integer. On the star graph, , there exists a set of predicted intervals and a request sequence such that and .
Proof
We consider the non-center vertices of in groups of eight, and handle them all identically, one group at a time, treating each group independently. The prediction is fixed, but the input sequence depends on the algorithm’s actions. For each group, we show that the error in the prediction is 1, and the payoff of is at least 2 units more than that of . Given that groups do not share edges between themselves, the total error and algorithms’ payoffs are summed over all groups. Hence, the total error will be equal to , and we can write , that is, .
Next, we explain how an adversary defines the input for each group. For group , the non-center vertices are , where , but we refer to these vertices by the value . Let be the part of the prediction relevant for the current group of eight vertices. Both and are always included in the input sequence, with arriving immediately before . accepts at most one of them. This is discussed in the cases below. The first request in the input is always , and can either accept or reject it.
Case accepts : The next interval to arrive is . If rejects this interval, the next to arrive is . If also rejects this interval, then the intervals and also arrive, but is a false positive (see Figure 1(a)). Then, accepts , only accepts , and . Thus, we may assume that accepts at least one of and , which we call where . We call the other of these two edges . Then, the intervals and also arrive, along with a false negative . The interval is a false positive and is not in the input (see Figure 1(b)). Since and share an edge, . accepts , and accepts . To conclude, the error increases by 1, and ’s deficit to increases by 2.
Case rejects : The next interval to arrive is .
Subcase accepts : As in the previous case, we consider which of and accepts. If neither is accepted, in addition to , arrives, but is a false positive (Figure 1(c)). Again, payoffs of and are respectively 1 and 3, and . The error is increased by 1, and the net advantage of over is increased by at least 2.
Next, we assume that accepts and rejects . Then, in addition to the intervals and , arrives, along with a false negative (Figure 1(d)). The interval is a false positive and is not in the input. Since and share an edge, . accepts , and accepts . Again, the error is increased by 1, and the net advantage of over is increased by 2.
Subcase rejects : The next interval to arrive is .
Regardless of whether accepts or rejects , as in the previous cases, we consider which of and accepts. If neither is accepted, then and have already arrived, but is a false positive. The payoff of is at most 1 if it accepts and 0 otherwise, while accepts , and . Thus, the error is increased by 1, and the net advantage of over is increased by 2. In what follows, we assume accepts for .
Subsubcase accepts : Then, in addition to the intervals and , a false negative, , arrives. The interval is a false positive and is not in the input. Since and share an edge, . accepts , and accepts (Figure 1(e)). As before, the error is increased by 1, and the net advantage of over is increased by 2.
Subsubcase rejects : In this case, the interval is a false positive, and there are no false negatives. Thus, the payoffs of and are respectively 1 and 3, and (Figure 1(f)). That is, the error is increased by 1, and ’s deficit compared to is increased by 2.
This completes the proof for one group of eight vertices. Repeating it independently for each of the groups of eight vertices gives the claimed result. ∎
4 Interval Scheduling
In this section, we show tight upper and lower bounds on the competitive ratio of a deterministic algorithm for interval scheduling. As an introduction to the difficulties in designing algorithms for the problem, we start by proving a general lower bound. We show that for any deterministic algorithm , there exists an input sequence and a set of predictions such that , and that this can be established for any positive integer error. We also show that the competitive ratio of is arbitrarily small.
Theorem 4.1 ()
Let be any deterministic algorithm. For any positive integers and , there are instances and predictions such that and
Proof
will be presented with intervals of length , and the remainder of the sequence will depend on which of these it accepts. The prediction, however, will include the following requests: \operatorname{\mathit{\hat{I}}}=\bigcup_{i=0}^{p-1}\big{\{}(ci,c(i+1)),(ci,ci+1)\big{\}}\,.
The input is formed by phases, . The th phase starts with the true positive . There are two cases to consider:
- •
If accepts , then the phase continues with
The first of these requests is a true positive, and the other are false negatives. Note that cannot accept any of these requests. The optimal algorithm rejects the original request and accepts all of the following unit-length requests.
- •
If rejects , the phase ends with no further requests. In this case, is a false positive.
The contribution, , of phase to is in the first case and in the second. Since the intervals in are disjoint, we can write and it follows that . Moreover, the net advantage of over in phase is at least : in the first case, accepts and accepts one request, and in the second case, accepts and accepts no requests. Given that there are phases, we can write
In phases where accepts the first request, accepts times as many requests as . In phases where rejects the first request, accepts one interval, and accepts no intervals. Thus, ∎
For , we get and . The next theorem shows that the competitive ratio of compared to the lower bound of Theorem 4.1 is not tight. The proof follows from an adversarial sequence similar to that of Theorem 4.1 in which the payoff of and grow in phases while the payoff of stays 0.
Theorem 4.2 ()
For any integer , there exists a prediction and an input sequence so that and
Proof
Let the prediction be
\operatorname{\mathit{\hat{I}}}_{w}=\bigcup_{i=0}^{p-1}\big{\{}(3i,3i+2),(3i+1,3i+3)\big{\}}\,.
chooses an optimal solution from . For each , will contain either or . If is in , that interval will be in , and will select , which will be a -interval in . Further, will contain the -interval, .
If, instead, is in , that interval will be in , and will select , which will be a -interval in . Further, will then contain the -interval, .
Thus, , and for each , the interval in and the interval in overlap, that so . Since , does not accept any intervals, so
[TABLE]
∎
4.1
In this section, we introduce an algorithm , , which achieves an optimal competitive ratio for interval scheduling.
4.1.1 The algorithm.
starts by choosing an optimal solution offline set of the schedules in , and plans to accept those intervals in and reject all others, and it just follows its plan, except possibly when the next request is in . maintains an updated plan, . Initially, is . When a request, , is in , accepts if overlaps no previously accepted intervals and can be accepted by replacing at most one other interval in that ends no earlier than . In that case, is added to , possibly replacing an overlapping interval to maintain the feasibility of (no two intervals overlap). As a comment, only the first interval from that replaces an interval in the current is said to “replace” it. There may be other intervals from that overlap and are accepted by , but they are not said to “replace” it. We let denote the set of intervals in that are not replaced during the execution of .
4.1.2 Analysis.
Let denote the set of intervals chosen by on input and prediction , and the intervals chosen by the optimal algorithm. We define the following subsets of and :
- •
and
- •
and
Lemma 1
Each interval overlaps an interval in extending no further to the right than .
Proof
Assume to the contrary that there is no interval in that overlaps and ends no later than . If does not overlap anything in , we could have added to and have a feasible solution (non-overlapping intervals), contradicting the fact that is optimal. Thus, must overlap an interval in , which, by assumption, must end strictly later than . This contradicts the construction of , since would have been in instead of . ∎
We define a set consisting of a copy of each interval in and let . We define a mapping as follows. For each :
If there is an interval in that overlaps and ends no later than , then let be the rightmost such interval.
- (a)
If , then . 2. (b)
Otherwise, has been replaced by some interval . In this case, . 2. 2.
Otherwise, by Lemma 1, belongs to .
- (a)
If there is an interval in that overlaps and ends no later than and an interval in that overlaps ’s right endpoint, let be the rightmost interval in that overlaps and ends no later than . In this case, . 2. (b)
Otherwise, let be the copy of in . In this case, .
We let denote the subset of mapped to by and note that in step 1a, intervals are added to when . In step 2b, all intervals are added to .
Lemma 2
The mapping is an injection.
Proof
Intervals in are only mapped to in step 1a. Note that and are disjoint. If an interval is mapped to an interval in this step, overlaps the right endpoint of . There can be only one interval in overlapping the right endpoint of , so this part of the mapping is injective. Intervals in are only mapped to in steps 1b and 2a. In step 1b, only intervals that replace intervals in are mapped to. Since each interval in replaces at most one interval in and the right endpoint of each interval in overlaps at most one interval in , no interval is mapped to twice in step 1b. If, in step 2a, an interval, , is mapped to an interval, , overlaps the right endpoint of . There can be only one interval in overlapping the right endpoint of , so no interval is mapped to twice in step 2a.
We now argue that no interval is mapped to in both steps 1b and 2a. Assume that an interval, , is mapped to an interval, , in step 1b. Then, there is an interval, , such that overlaps the right endpoint of and overlaps the right endpoint of . This means that the right endpoint of is no further to the left than the right endpoint of . Assume for the sake of contradiction that an interval is mapped to in step 2a. Then, overlaps the right endpoint of , and there is an interval, , overlapping the right endpoint of . Since overlaps , must be to the left of . Since is mapped to , extends no further to the right than . Thus, since overlaps both and , must overlap the right endpoint of , and hence, overlaps . This is a contradiction since and are both in . Intervals in are only mapped to in step 2b and no two intervals are mapped to the same interval in this step. ∎
Lemma 3
The subset of mapped to by is a feasible solution.
Proof
We first note that is feasible since and is feasible. Moreover, is feasible since the intervals of are identical to the corresponding subsets of . Thus, we need to show that no interval in overlaps any interval in .
Consider an interval mapped to from an interval . Since is not mapped to its own copy in , its copy does not belong to . Since , no interval in overlaps . Thus, we need to argue that contains no interval strictly to the left of overlapping .
Assume for the sake of contradiction that there is an interval to the left of overlapping . Since ended up in although its right endpoint is overlapped by an interval from , there is no interval in (because of step 1 in the mapping algorithm) or in (because of step 2a in the mapping algorithm) overlapping and ending no later than . Thus, contains no interval strictly to the left of overlapping . This contradicts the fact that has not been replaced since the interval in corresponding to could have replaced it. ∎
The following theorem follows from Lemmas 2 and 3.
Theorem 4.3 ()
For any prediction and any input sequence , we have
[TABLE]
Proof
We show that
[TABLE]
[TABLE]
∎
5 Consistency-Robustness Trade-off
We study the trade-off between the competitive ratio of the interval scheduling algorithm when predictions are error-free (consistency) and when predictions are adversarial (robustness). The following proposition shows an obvious trade-off between the consistency and robustness of deterministic algorithms.
Proposition 2 ()
If a deterministic algorithm has non-zero consistency, , it has robustness .
Proof
Consider a prediction that indicates the input to be one long interval, . In order to have non-zero consistency, , the algorithm must accept this interval, if it is first in some sequence because it might be the only interval in that sequence.
Suppose an input is Clearly, accepts the intervals of length , giving robustness . ∎
The more interesting case is randomized algorithms. The proof of the following was inspired by the proof of Theorem 13.8 in [16] for the online case without predictions, and that result was originally proven in [7].
Theorem 5.1
If a (possibly randomized) algorithm is both -consistent and -robust, then and .
Proof
Let and let . Consider a prediction , where and, for , . Note that consists of disjoint intervals of length . For , let .
In order to maximize the number of small intervals that can be accepted if they arrive, an algorithm would minimize the (expected) fraction of the line occupied by the larger intervals, to leave space for the small intervals, while maintaining -robustness. Since and is -robust, . For with , accepts all intervals in , so . To be -robust, the expected number of intervals of length at most that accepts is at least . Inductively, for , by the linearity of expectations, this is at least intervals of length , and these intervals have a total expected size of at least . Again, by the linearity of expectations, for , the expected sum of the lengths of the accepted intervals is at least .
From , the expected number of intervals must have accepted is at least . If is the actual input sequence, then the predictions are correct, so for to be -consistent, we must have . Since also , we can combine these two inequalities and obtain . Since , this reduces to . Solving for , . ∎
Note that as approaches 1 (optimal consistency), goes to [math] (worst-case robustness) and vice-versa. Next, we present a family of algorithms, RobustTrust, which has a parameter and works as follows. With a probability of , RobustTrust applies . (Applying , instead of , gives the same consistency and robustness results.) With probability , RobustTrust ignores the predictions, and applies the Classify-and-Randomly-Select () algorithm described in Theorem 13.7 in [16]. is strictly -competitive (they use ratios at least one). A similar algorithm was originally proven -competitive in [7].
For completeness, we include the algorithm. To avoid the problem of possibly not being a power of , we define and . Thus, the algorithm will define its behavior for a longer line and some sequences that cannot exist.
We define a set of levels for the possible requests. Since is a power of two, there is an odd number of edges, so the middle edge, , in the line is well defined. The set and Level 1 consists of all intervals containing . After Levels 1 through are defined, we define and Level as follows: After removing all edges in from the line, we are left with segments, each consisting of vertices. The set consists of the middle edges of these segments, and Level consists of all intervals, not in any of the Levels through , but containing an edge in . Thus, the levels create a partition of all possible intervals.
The algorithm initially chooses a level between and , each with probability . It accepts any interval in Level that does not overlap an interval it already has accepted. Any intervals not in Level are rejected.
When RobustTrust applies and the predictions are correct, it accepts exactly as many intervals as there are in the optimal solution. From these observations, we can get the following results.
Theorem 5.2 ()
RobustTrust* () with parameter has consistency at least and robustness at least .*
Proof
We investigate the RobustTrust when all predictions are correct (the consistency) and when some predictions may be incorrect (robustness).
Suppose all predictions are correct. RobustTrust applies with probability . Since is optimal when all predictions are correct, the expected payoff of RobustTrust is at least . Therefore, the competitive ratio (consistency) of RobustTrust is at least .
Suppose some predictions are incorrect. If the intervals in Level are the only intervals given, and chooses that level, accepts as many intervals as does, since each interval in Level contains an edge in , and no intervals containing more than one edge in exist. Since the number of levels is , the expected number of intervals from ’s configuration that accepts on any given level is times the number of intervals accepted from that level, so by the linearity of expectations, this totals . is chosen with probability , so the robustness is at most . ∎
6 Experimental Results
We present an experimental evaluation of and in comparison with the algorithm, which serves as a baseline online algorithm, and , which serves as the performance upper bound. We evaluate our algorithms using real-world scheduling data for parallel machines [19]. Each benchmark from [19] specifies the start and finish times of tasks as scheduled on parallel machines with several processors. We use these tasks to generate inputs to the interval scheduling problem; Table 1 details the interval scheduling inputs we generated from benchmarks of [19]. For each benchmark with tasks, we create an instance of an interval scheduling problem by randomly selecting tasks from the benchmark and randomly permuting them. This sequence serves as the input to all algorithms. To generate the prediction, we consider equally distanced values of . For each value of , we initiate the prediction set with the set of intervals in , remove randomly selected intervals from and add to it randomly selected intervals from the remaining tasks in the benchmark. The resulting set is given to and as prediction . For each value of , we compute the normalized error , and report the payoff of and as a function of .
Figure 2 shows the results for two representative benchmarks from [19], namely, LLNL (the workload of the BlueGene/L system installed at Lawrence Livermore National Lab), SDSC (the workload log from San Diego Supercomputer Center), NASA-iPSC (scheduling log from Numerical Aerodynamic Simulation -NAS- Systems Division at NASA Ames Research Center) and CTC-SP2 (Cornell Theory Center IBM SP2 log). These four benchmarks are selected to represent a variety of input sizes and interval lengths. These four benchmarks are selected to represent a variety of input sizes and interval lengths. The results are aligned with our theoretical findings: quickly becomes worse than as the error value increases, while degrades gently as a function of the prediction error. In particular, is better than for almost all error values. We note that performs better when there is less overlap between the input intervals, which is the case in LLNL compared to SDSC. In an extreme case, when no two intervals overlap, is trivially optimal. Nevertheless, even for LLNL, is not much worse than for extreme values of error: the payoff for the largest normalized error of was 5149 and 5198 for and , respectively. Note that for SDSC, where there are more overlaps between intervals, is strictly better than , even for the largest error values. It is worth noting that, in an extreme case, where , the predictions contain a completely different set from the input sequence. In that case, , and takes values in .
We also experiment in a setting where false positives and negatives contribute differently to the error set. We generate the input sequences in the same way as in the previous experiments. To generate the prediction set , we consider equally-distanced values of in the range as before. We first consider a setting in which all error is due to false negatives; for that, we generate by removing randomly selected intervals from . In other words, is a subset of the intervals in . Figures 3(a) and 3(c) illustrate the payoff of and in this case. We note that is strictly better than both and . In an extreme case, when , becomes empty and becomes ; in other words, is the same algorithm as with the empty predictions set .
We also consider a setting in which there are no false negatives. For that, we generate by adding intervals to . In other words, will be a superset of intervals in . Figures 3(a) and 3(c) illustrate the payoff of and in this case. In this case, the payoff of and is similar to the setting where both false positives and negatives contributed to the error set. In particular, quickly becomes worse than as the error increases, while degrades gently as a function of the prediction error.
7 Related Problems: Matching and Independent Set
In [27], the authors observe that finding disjoint paths on stars is equivalent to finding maximal matchings on general graphs, where each request in the input to the disjoint path selection bijects to an edge in the input graph for the matching problem. Therefore, we can extend the results of Section 3 to the following online matching problem. The input is a graph , where is known, and edges in appear in an online manner; upon arrival of an edge, it must be added to the matching or rejected. The prediction is a set that specifies edges in . As before, we use and to indicate the set of false positives and false negatives and define , where indicates the size of the matching for graph .
The correspondence between the two problems is as follows: Consider a set of intervals on a star. Each such interval is a pair of vertices. We can assume no pair contains the star’s center since all such intervals should be accepted if they can be. For the matching problem, the pairs of vertices from the disjoint paths problem on the star can be the edges in the graph. A feasible solution to the disjoint paths problem corresponds to matching and vice versa. One can similarly consider an instance of a matching problem, and the endpoints of the edges can be the non-center vertices of the star in the disjoint paths problem.
Using this correspondence between disjoint paths on a star and matchings in general graphs, for the star , we get the following graph for matching: , where and
[TABLE]
See also Figure 4. Note that the edges in this graph correspond to the intervals that are used in the proof of Theorem 3.2. The proof can be simulated in this new setting so that the number of intervals accepted in the different cases in Theorem 3.2 is the same as the number of edges in the matchings found in the corresponding subgraphs of . Thus, the same result holds for matchings in any graph class containing this graph.
All edges have one even-numbered endpoint and one odd, so this includes the bipartite graph class. It is also planar but not an interval or chordal graph.
Given the correspondence between interval scheduling and the matching problem, the following is immediate from Theorems 3.1 and 3.2.
Proposition 3
For any instance of the online matching problem under the edge-arrival model and a prediction set , there is an algorithm that matches at least edges. Moreover, there are instances of the matching problem, along with predictions for which any deterministic algorithm matches at most edges.
Using the correspondence between matchings in a graph, , and an independent set in the line graph of , we can get the same result for the independent set. The line graph of a graph, , has a vertex for each edge in and an edge between two vertices if the corresponding edges in share a vertex.
The line graph of the graph above used for matching is defined by
[TABLE]
where, for brevity, we use the notation to denote the vertex corresponding to the edge from . The set of edges is then
[TABLE]
Intervals from the proof in Theorem 3.2 correspond to vertices here. See also Figure 4.
We note that the graph is planar, but not outerplanar, since, contracting and into one vertex, , the sets and form a minor, which is a so-called forbidden subgraph for outerplanarity [20, 29]. Also, it is not chordal. However, the lower bound from Theorem 4.1, that for any deterministic algorithm , there are instances and predictions such that clearly holds for independent sets in interval graphs, too, by considering the interval graph corresponding to a set of intervals on the line.
Using the correspondence between matchings in a graph, , and the independent set in the line graph of , we can get a similar result for the independent set under the vertex-arrival model.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] Algorithms with predictions. https://algorithms-with-predictions.github.io/ , accessed: 2023-02-19
- 2[2] Angelopoulos, S., Dürr, C., Jin, S., Kamali, S., Renault, M.: Online computation with untrusted advice. In: Proc. ITCS. pp. 52:1–52:15 (2020)
- 3[3] Angelopoulos, S., Kamali, S., Shadkami, K.: Online bin packing with predictions. In: Proc. IJCAI. pp. 4574–4580 (2022)
- 4[4] Angelopoulos, S., Kamali, S.: Contract scheduling with predictions. In: 35th AAAI Conference on Artificial Intelligence (AAAI), 33rd Conference on Innovative Applications of Artificial Intelligence (IAAI), 11th Symposium on Educational Advances in Artificial Intelligence (EAAI). pp. 11726–11733. AAAI Press (2021)
- 5[5] Angelopoulos, S., Arsénio, D., Kamali, S.: Competitive sequencing with noisy advice. Co RR abs/2111.05281 (2021)
- 6[6] Antoniadis, A., Gouleakis, T., Kleer, P., Kolev, P.: Secretary and online matching problems with machine learned advice. In: Proc. Neur IPS (2020)
- 7[7] Awerbuch, B., Bartal, Y., Fiat, A., Rosén, A.: Competitive non-preemptive call control. In: Proc. (SODA). pp. 312–320 (1994)
- 8[8] Azar, Y., Leonardi, S., Touitou, N.: Flow time scheduling with uncertain processing time. In: Proc. STOC (2021)
