A Universal Error Measure for Input Predictions Applied to Online Graph Problems
Anonymous Author(s)
AffiliationAddress email
Abstract
We introduce a novel measure for quantifying the error in input predictions.
Theerror is based on a minimum-cost hyperedge cover in a suitably defined hypergraphand provides a general template which we apply to online graph problems.
Themeasure captures errors due to absent predicted requests as well as unpredicted actual requests; hence, predicted and actual inputs can be of arbitrary size.
We achieverefined performance guarantees for previously studied network design problems inthe online-list model, such as Steiner tree and facility location.
Further, we initiatethe study of learning-augmented algorithms for online routing problems, such asthe traveling salesperson problem and dial-a-ride problem, where (transportation)requests arrive over time (online-time model).
We provide a general algorithmicframework and we give error-dependent performance bounds that improve uponknown worst-case barriers, when given accurate predictions, at the cost of slightlyincreased worst-case bounds when given predictions of arbitrary quality
Introduction
We develop a novel measure for quantifying the error in input predictions and apply it to deriveerror-dependent performance guarantees of algorithms for online metric graph problems.
Onlinegraph problems are among the most fundamental online optimization problems, where an initiallyunknown input is revealed incrementally.
The two main paradigms for the incremental informationrelease are the online-time model and the online-list model.
In the online-time model, initiallyunknown requests are revealed over time and can be served any time, whereas in the online-list model,requests are revealed one-by-one and must be served immediately before the next request appears.
Inthis work, we address specifically the following online routing and network design problems.
Online-time routing problems In the classical Online Traveling Salesperson Problem (O L TSP) and
Online Dial-a-Ride Problem (O L DARP), a server can move at unit speed in a given metric space.
Transportation requests appear online over time, each defining a start and end point in the metricspace (in the TSP both points are equal).
The task is to determine a tour to serve all requests (inany order) by moving to the corresponding start and end points.
The objective is to minimize themakespan, i.e., the time point when all requests have been served and the server is back in the origin.
These problems are well-studied [7,8,16,17,24], as well as other related variants [30,31,37].
Online-list network design problems In the Online Steiner Tree Problem
, requests are terminalnodes that are revealed one-by-one in a given metric space (typically represented as a complete edgeweighted graph) and must be connected to a fixed root by selecting edges via other (Steiner) nodes.
Inthe closely related Online Steiner Forest Problem , a request is composed of two nodes which have to beconnected by the selected set of edges.
In both problems, the objective is to minimize the total cost ofselected edges.
In the more general Online Facility Location Problem , a facility can be opened at everyvertex at a certain one-time cost at any time, and arriving client vertices are connected upon arrival to the closest open facility at the cost of the shortest path to it.
The goal is to minimize the opening andconnection cost.
These problems are very well-studied [2–4,9,13,15,19,21,23,26,27,29,40,47,48].
The performance of online algorithms is typically assessed by worst-case analysis.
An algorithm iscalled ρ - competitive if it computes, for any input instance, a solution with objective value within amultiplicative factor ρ of the optimal value that can be computed when knowing the full instanceupfront.
The competitive ratio of an algorithm is the smallest factor ρ for which it is ρ -competitive.
For the above problems (nearly) tight bounds on the competitive ratio are known.
For O L TSPand O L DARP, there have been shown best possible 2 -competitive algorithms [7,8].
For the onlinenetwork design problems, the existence of O (1) -competitive algorithms has been ruled out [26,29,40]and algorithms with (tight) (poly-)logarithmic upper bounds have been shown [15,26,29,40,47].
The assumption in online optimization of not having any prior knowledge about future requestsseems overly pessimistic.
In particular, given the success of machine-learning methods and datadriven applications, one may expect to have access to predictions about future requests.
However,simply trusting such predictions might lead to very poor solutions, as these predictions come withno quality guarantee.
The recent vibrant line of research initiated in [38,39] aims at incorporatingsuch error-prone predictions into online algorithms, to go beyond worst-case barriers.
The goal arelearning-augmented algorithms with a performance that is close to that of an optimal offline algorithmwhen given accurate predictions (called consistency ) and, at the same time, never being (much) worsethan that of a best known algorithm without access to predictions (called robustness ).
Further, theperformance of an algorithm shall degrade in a controlled way with increasing prediction error.
In this paper, we consider an input predictions model, i.e., there is given a set ˆ R of predictions for theactual online input R of a problem.
We do not make any assumption on the quality of the predictionor on its size.
In particular, ˆ R might be substantially larger or smaller than R .
Defining an appropriate error measure is a crucial task in this line of research.
There is no commonagreement (yet) in the literature on what constitutes a good error measure.
The philosophy behindour error measure is the following.
Any learning-augmented algorithm needs to trust the predictionsto some extent, as otherwise no improvement upon an online algorithm is possible.
The error shouldthen be able to sensitively bound how much any (reasonable) algorithm pays for erroneous predictions.
Roughly, our error measure achieves this by approximating the extra cost that an algorithm trustingthe predictions has when it serves the true instance; very informally, this is OPT trust
ˆ R ( R ) − OPT( R ) .
Several natural measures (for graph problems) have been proposed, such as the number of erroneouspredictions [49], the ℓ 1 -norm (e.g., distances between predicted and real points), or more involvedperfect matching-based errors [12].
Although we cannot expect that a single error measure isappropriate for all problems, we propose a universal template based on the cost of a hyperedge coverin a bipartite hypergraph that is constructed in a problem-specific way.
1.1 Our contributions
Cover error for input predictions The main idea of our error measure is to separately cover theerrors incurred by unexpected actual requests , R \ ˆ R , and absent predicted requests , ˆ R \ R , as thesepose a potential threat to an algorithm which trusts ˆ R .
For each of the two error types we considera suitable weighted bipartite hypergraph with erroneous requests on the left side and combine theminimum costs of edge covers of the left side in both graphs.
In all our problems the cost of ahyperedge (with a single endpoint on the right side) intuitively measures the optimal cost for thesubinstance induced by the covered erroneous requests anchored by the covering request on theright.
E.g. in O L TSP the value of an optimal tour for some unexpected requests (left) when startingfrom some predicted request (right), which can be seen as the optimal detour from the predictedrequest to serve the unexpected requests.
We introduce a hierarchical family of error measuresparameterized by k ≥ 1 , roughly the maximum size of a hyperedge. While a larger k always impliesa more sensitive error, its scaling in the error-dependencies of algorithms also grows with k , whichis unavoidably due to the mentioned strong lower bounds. We prove error-dependent performancebounds of algorithms for all k simultaneously . Such configurable error-bounds still allow for a morefine-grained performance analysis for a larger class of instances and predictions.
We call this errornotion the cover error and denote its value by Λ k .
Precise definitions will be given later.
The cover error fulfills several useful properties.
Since we can use cost functions based on the valuesof optimal solutions, the error can be stated problem-independent, based on ˆ R and R alone, and yet it provides, for any concrete problem, a value which is comparable to the objective of a solution ofthe problem.
Further, it allows to integrate both actual and predicted release dates for online-timeproblems.
This is a feature which previous metric graph errors seem not to satisfy, as they rely e.g.only on counting incorrect predictions [12,49] or on min-cost perfect matchings [12], which disallowasymmetric cost functions—a crucial requirement for precisely incorporating lateness between releasedates.
Finally, it naturally supports different sizes of R and ˆ R , which seems favorable in practice, asit removes constraints on a predictor.
Although previously studied measures [12,49] support this intheory, they are not robust against artificial dummy requests. Indeed, we show that previous measuresfail to detect good predictions in certain scenarios, which results in imprecise performance bounds oflearning-augmented algorithms—equal to those of classic online algorithms—while the cover errorcan guarantee an almost optimal performance.
We therefore hope that the cover error will be usefulboth for better analyzing existing learning-augmented algorithms and other problems in the future.
Algorithms with error-sensitive performance bounds Our algorithmic results are twofold: weprovide the first learning-augmented algorithms for online-time routing problems, and we give newerror-dependencies for existing algorithms for online-list network design problems.
The unifyingelement is that we achieve these by problem-dependent implementations of our new cover error.
We first introduce the general framework D ELAY T RUST for O L TSP and O L DARP and prove anerror-dependency w.r.t.
the cover error as well as robustness w.r.t.
a blackbox online algorithm.
Theorem 1.
The competitive ratio of D ELAY T RUST for O L TSP and O L DARP using a ρ -competitivealgorithm as a blackbox is, for any α > 0 , bounded by
[Equation]
Hence, predictions help to beat the classic lower bound of 2 [8] for online-time routing.
When using S MART S TART [7] as a blackbox algorithm, we can further refine D ELAY T RUST bycarefully aligning the used waiting strategies and prove an improved robustness guarantee.
Theorem 2.
The competitive ratio of S MART T RUST for O L TSP and O L DARP is, for any α > 0 ,bounded by min (cid:8) (1 + α ) (cid:0) 1 + 3 · Λ 1 C ∗ (cid:1) , {+
+} + 2 α (cid:9) .
In general, the main focus of online algorithms for O L TSP and O L DARP is tackling the uncertaintyof the input rather than efficient running times, which is also the case for the above discussed results.
Yet, we show that we can trade efficiency with slightly larger constant factors in the guarantees.
We remark that simpler and tightened results are possible for restricted metric spaces: in Section 3.2we provide improved bounds for O L TSP on the positive half of the real line.
We complement these theoretical bounds with empirical results on simulated real-world taxi instancesin the city road network of Manhattan, which indicate the superior performance of S MART T RUSTcompared to classic methods in both general and relevant restricted scenarios.
Further, we consider online-list graph problems and analyze the algorithmic framework provided by
Azar, Panigrahi and Touitou [12] w.r.t.
the cover error.
For each problem, we specify hyperedge costfunctions which follow the same uniform paradigm and prove new error-dependent bounds.
Theorem 3.
The algorithms in [12] for the online Steiner tree or online (capacitated) facility locationproblem incur, for any parameter k ≥ 1 , a cost of at most O (1) · OPT + O (log k ) · Λ k .
Theorem 4.
The algorithm in [12] for the online Steiner forest problem incurs, for any parameterk ≥ 1 , a cost of at most O (1) · OPT + O ( k ) · Λ k .
These bounds hold simultaneously for any k and the bounds provided in [12].
This is especiallytrue for the robustness bound of O (log | R | ) .
On the technical side, we can exploit a technical lemmaby [12] that allows us to split the analysis in two parts.
The actual proofs for bounding the algorithm’scost by the cost of an optimal solution and the cover error are completely different.
For certain input scenarios we substantially strengthen the bounds on the competitive ratio providedby Azar et al.
Indeed, their bound never improves over Ω(log(max {| R | , | ˆ R |}− min {| R | , | ˆ R |} )) ,which is not better than the best possible competitive ratio O (log | R | ) for classic online algorithms,if | ˆ R | and | R | differ significantly.
We show that there are input scenarios for which their errormeasure overestimates the actual error substantially and, thus, gives poor performance bounds while the algorithm performs actually well; more precisely, we prove a constant competitive ratio for thealgorithm in [12] w.r.t.
our error measure whereas the bound w.r.t.
the previous measure is O (log | R | ) .
1.2 Further related work
While untrusted predictions have been successfully integrated into online models for many differentproblems in the past few years, none of the previous approaches and models seem to capturethe complexity of combined routing and scheduling decisions.
Related research includes workon scheduling [10, 11, 14, 28, 33, 35, 41, 43, 44], routing in metric spaces such as the k-serverproblem and more generally metrical task systems [5,36], graph exploration [22] and online networkdesign [1,12,49].
Further, there is hardly any work on integrating untrusted predictions into online problems in theonline-time model.
The only exception seems to be the work by Antoniadis et al.
[6] on onlinespeed scaling with a prediction model that includes release dates and deadlines.
The nature of thespeed-scaling problem, however, is very different from the routing problems we consider.
Otherworks on non-clairvoyant scheduling with jobs arriving over time (minimizing flow time [10,11], totalcompletion time [35] and energy [14]) assume predictions on the job sizes or priorities; release datesare known in advance in [14], while [10,11,35] consider purely online problems w.r.t.
job arrivals.
The cover error
Given an input prediction ˆ R and the actual input R , we design an error measure that covers everyerroneously predicted item, i.e., all unexpected requests R \ ˆ R and all absent predicted requests ˆ R \ R .
As a concrete example think of O L TSP where a learning-augmented algorithm trusts (at least to acertain degree) the predicted requests in ˆ R , and thus follows an optimal tour on ˆ R .
After serving apredicted request ( ˆ x, ˆ r ) , it may serve some unexpected actual requests R ′ ⊆
R \ ˆ R that have alreadybeen released and are relatively close to ( ˆ x, ˆ r ) (both time- and location-wise).
In our terminology,think of ( ˆ x, ˆ r ) covering R ′ , and observe that the cost for this cover shall naturally be equal to theoptimal cost for serving R ′ when starting in ˆ x at time ˆ r .
Conversely, the predicted requests that have not shown up and are nevertheless visited, ˆ R \ R , shouldbe covered by actual requests, to make up for the extra cost incurred by these superfluous visits.
We can arguably expect that any well-performing algorithm should be as least as good as serving allunexpected requests R \ ˆ R and all absent predicted requests ˆ R \ R in such partitions which can becovered by, respectively, predicted and actual requests in the cheapest possible way.
We now embed this intuition into a precise definition.
Let A and B be two sets of (possibly different)size and let k ≥ 1 .
We define a bipartite hypergraph G k
=
( A ∪ B, H ) where every hyperedge h ∈ Hhas exactly one endpoint in B and at most k endpoints in A .
A k - hyperedge cover of A by B is aset of hyperedges H ′ ⊆
H in G k such that every vertex in A is incident to at least one hyperedgein H ′ .
If every hyperedge h ∈ H of G k has an associated cost γ ( h ) , a minimum-cost k -hyperedgecover H ′ is a k -hyperedge cover which minimizes the total hyperedge cost (cid:80) h ′ ∈H ′ γ ( h ′ ) .
We denotethe value of a min-cost k -hyperedge cover of A by B by Γ k
( A, B ) .
Finally, the cover error, denotedby Λ k ( R, ˆ R ) , is given by
[Equation]
Notice that we allow arbitrary large hyperedges ( k = ∞ ) to cover predicted requests ˆ R .
This is thestrongest statement as, clearly, Γ i ( A, B ) ≥ Γ
i +1 ( A, B ) , for any i .
We simply write Λ k if ˆ R and Rare clear from the context.
Since our error measure shall give value zero if ˆ R =
R , we require thatthe cost of every hyperedge { a } ∪ { b } for some a ∈ A and b ∈ B is equal to zero if a = b .
Then, allvertices in A ∩ B can be covered trivially by B , and we conclude that Γ k ( A \ B, B ) =
Γ k ( A, B ) .
Figure 1 depicts an example of a k -hyperedge cover.
It remains to specify the cost γ ( A ′ , b ) of a hyperedge A ′ ∪ { b } .
Although we will give precisedefinitions separately for every concrete problem, all definitions follow a certain paradigm.
Thatis, the cost γ ( A ′ , b ) shall be equal to the value of an optimal solution for the subinstance induced
[Figure]
R \
ˆ R ˆ R ≤ k (b) Min-cost k -hyperedge cover
R ˆ R ≤ k (
[Figure]
by A ′ with respect to b .
This anchoring requirement is the single detail which has to be specified for aconcrete problem.
Note that this matches our intuition discussed above for O L TSP.
Comparison to other error measures We compare the cover error to previously proposed errormeasures for the (undirected) online Steiner tree problem.
Xu and Moseley [49] define a predictionerror η = max {| ˆ R | , | R |} − | ˆ R ∩ R | , the number of erroneous requests, and prove that their algorithmis O (log(min {| R | , η } )) -competitive.
Azar et al.
[12] introduce the metric error with outliers λ =(∆ , D ) , where D is the value of a min-cost perfect matching between two equally sized subsets of Rand ˆ R , and ∆ is the total number of unmatched points in R and ˆ R .
They prove for their algorithms amultiplicative error dependency w.r.t.
log(min {| R | , ∆ } ) and an additive error dependency w.r.t.
D .
We give a family of instances with n actual requests and an input prediction for which the algorithmsof Azar et al.
[12] and Xu and Moseley [49] perform arguably well, but their error measures andanalyses yield a bound of O (log n ) · OPT + O ( ϵ ) , which could be achieved even without predictions.
For some ϵ > 0 , the instance is composed of one terminal request at x 1 and n − 1 requests in an ϵ -ballaround the Steiner point x 2 , but no request is exactly on x 2 .
Both x 1 and x 2 are predicted.
We canimmediately observe that the number of erroneous requests [49] is η = n − 1 .
For the metric error withoutliers [12], note that any perfect matching is composed of at most two matches, therefore ∆ ≥ n − 2and D
= O ( ϵ ) .
On the other hand, our cover error is bounded by Λ k ≤ Λ 1 = O ( n · ϵ ) for any k ,because x 2 covers all requests in the ϵ -ball around it.
Then, Theorem 3 concludes that the algorithmof Azar et al.
[12] is indeed constant competitive for this instance when ϵ → 0 .
Online metric TSP with predictions
Let M =
( X, d ) be a metric space, consisting of a set of points X , with origin o ∈ X and a metric d .
In the Online Metric Traveling Salesperson Problem (O L TSP), a set of unknown requests R isreleased online over time.
A request ( x, r ) is composed of a point x ∈ X and a release date r ∈ R ≥ 0 ,i.e., the time at which the request becomes known and can be served.
The task of an algorithm is toroute a server, which is initially in the origin and moves at unit speed, through all requests back to theorigin.
The objective is to minimize the makespan, i.e., the total time required for this task.
The O L TSP with predictions , is an O L TSP in which we are given additionally an a priori prediction
ˆ Ron the set of requests.
We assume that the server receives a signal when it is back at the originafter serving all the actual requests.
Unlike in the classic O L TSP, this is important, as otherwise analgorithm might continue considering predicted requests, thus, ruling out any robustness.
To specify our cover error, we define the cost of a hyperedge R ′ ∪{ ( x ′ , r ′ ) } as the extra cost of servingerroneous (
To get some intuition, consider an algorithm that does not move before time t if there are no requests.
It will receive an adversarial request ( t, t ) and hence encounters a ratio of 32 [17].
To overcome thiswhen having (almost) accurate predictions, the server has to move towards (predicted) requests before they actually arrive.
However, this pre-moving technique brings several challenges.
If an algorithmmoves the server without interruption to a predicted request at the beginning of the instance, anadversary would immediately spawn the single actual request at the origin, giving an unboundedrobustness.
If the server would directly move back, one can similarly argue that the consistency is atleast 32 .
Therefore, the key is to define a proper waiting strategy before moving towards predictedrequests.
We show that we can execute an arbitrary online algorithm while delaying pre-moving togain information about the instance.
This is very delicate, since too much delay clearly weakens theconsistency, but too little delay gives weak robustness.
In Appendix A we prove the following result.
Theorem 5.
Let α ∈ (0 , 1 / 2) and let A be a (1 + α ) -consistent deterministic learning-augmentedalgorithm for O L TSP .
Then, A can be β -robust only for β ≥ 1 α − 1 .
This holds even on the half-line.
Our final algorithm uses a hyperparameter α > 0 to configure the waiting duration and therebyachieves a tight asymptotic consistency-robustness tradeoff.
Intuitively, we can express our confidencein the prediction using α and get customized guarantees.
3.1 A general framework for O L TSP with predictions
Our strategy involves an initial delay phase in which we follow an arbitrary online algorithm, up tosome predetermined time depending on the predicted optimal cost ˆ C .
After that, we start followingan optimal tour of the predicted requests, ˆ T , adjusting it whenever the actual requests deviate fromthe predictions.
We call this greedy strategy
P REDICT R EPLAN (P RED R EPLAN for short), due to theanalogy with the classic R EPLAN heuristic [7].
Let p ( t ) be the server’s location at time t .
Follow ˆ T .
Whenever an unexpected request ( x, r ) is released, recompute and follow a fastest tour from p ( r ) to the origin serving all unserved predicted requests as well as all the unserved unexpected requests.
If the server receives an end signal in the origin, terminate.
While this algorithm might move towards predicted requests which are known to be absent to make theanalysis clearer, a practical implementation ignores these and thereby only improve its performance.
We formally define the class of algorithms D ELAY T RUST , that is parameterized by our trust parameterα > 0 , which scales the delay.
Let A be any ρ -competitive online algorithm for O L TSP.
Algorithm
D ELAY T RUST
i: Follow A as long as for time t it holds t ≤ α ˆ C − d ( p ( t ) , o ) ii: Move the server to the origin iii: Follow the P RED R EPLAN strategy until the end
We refer to the execution of each line as a phase .
To prove the main Theorem 1 for O L TSP, we showseparately an error-dependent bound in Lemma 6 and a robustness bound in Lemma 7.
Given an O L TSP instance, we denote by C ∗ the makespan of an optimal tour T ∗ serving all actual requests.
Lemma 6.
D ELAY T RUST has a competitive ratio of at most (1 + α ) (cid:0) 1 + 3 · Λ 1 C ∗ (cid:1) , for any α ≥ 0 .
Proof.
We first bound ˆ C .
Fix a min-cost ∞ -hyperedge cover of ˆ R by R and an optimal tour T ∗ for R .
For every hyperedge ˆ R ′ ∪ { ( x, r ) } in the cover, we extend T ∗ by adding the optimal offline O L TSPtour for R ′ which starts at x at the time t at which T ∗ serves x .
Note that, since r ≤ t , the makespanof this subtour is bounded by the cost of ˆ R ′ ∪ { ( x, r ) } .
Since every predicted request is covered by atleast one hyperedge, the constructed tour serves ˆ R and we conclude that ˆ C ≤ C ∗ + Γ ∞ ( ˆ R, R ) .
We now bound the makespan of the tour of the algorithm.
If the algorithm terminates in Phases (i)or (ii), its makespan is at most α ˆ C ≤ α · ( C ∗ + Γ ∞ ( ˆ R, R )) ≤ (1 + α ) · ( C ∗ + Λ 1 ) .
Otherwise, the algorithm reaches Phase (iii).
There it first computes an optimal tour ˆ T of lengthat most ˆ C serving all unserved predicted requests.
The makespan only increases when unexpected o       ≤ r ′ − ˆ rγ ( { 7 } , ( ˆ x 3 , ˆ r 3 ))
R
[Figure]
requests arrive.
To this end, fix a min-cost 1 -hyperedge cover of R by ˆ R and a hyperedge { ( x ′ , r ′ ) } ∪{ ( ˆ x, ˆ r ) } of this cover.
We upper bound the additional cost due to ( x ′ , r ′ ) by the cost of an excursionwhich serves ( x ′ , r ′ ) from the algorithm’s current tour.
The algorithm might find a faster tour toserve all unserved requests and henceforth uses that.
We distinguish two cases depending on thealgorithm’s remaining tour before request ( x ′ , r ′ ) arrived.
If ˆ x is not part of this tour, we consider anexcursion which immediately deviates from p ( r ′ ) to serve ( x ′ , r ′ ) and then returns to p ( r ′ ) .
By thetriangle inequality, the length of this excursion is bounded by twice the distance between p ( r ′ ) and ˆ x ,plus the cost for optimally serving ( x ′ , r ′ ) from ˆ x when starting at time ˆ r .
Due to our assumption,( ˆ x, ˆ r ) must have already been served at some time t with r ′ ≥ t ≥ ˆ r .
Thus, the algorithm’s server isat most r ′ − ˆ r units away from ˆ x at time r ′ . Therefore, the total time incurred for this excursion isbounded by
[Equation]
Note that the inequality is due to the fact that ( x ′ , r ′ ) can only be served after its release date.
In the other case, the algorithm’s server will visit ˆ x at some later point in time, especially at least onceafter time ˆ r .
We thus wait until the algorithm reaches ˆ x at some time t ≥ ˆ r , and then serve ( x ′ , r ′ )using at most γ TSP ( { ( x ′ , r ′ ) } , ( ˆ x, ˆ r )) additional time.
See Figure 2 for an illustration of both cases.
Since every actual request is covered by one hyperedge, we conclude that Phase (iii) takes time atmost ˆ C + 3 · Γ 1 ( R, ˆ R ) .
Adding the time for Phases (i) and (ii) gives a makespan of at most
[Equation]
Lemma 7.
D ELAY T RUST has a competitive ratio of at most 1 + ρ + ρα , for any α > 0 andany ρ -competitive algorithm used in Phase (i).
Proof.
If the algorithm terminates during Phase (i) or (ii), the competitive ratio is ρ .
We are guaranteedto finish in one of these two phases if ρC ∗ ≤ α ˆ C .
If we terminate within Phase (iii), then ˆ C < ρα C ∗ .
Once the last request has arrived at sometime r last ≤ C ∗ , our tour stays fixed.
We distinguish two cases.
If the last request arrives before theend of Phase (ii), then the cost of our tour comprises of the cost for finishing Phase (ii), which is atmost α ˆ C , and the cost of P RED R EPLAN for following the predicted tour, including all unexpectedyet unserved requests, which is at most ˆ C + C ∗ .
The total cost is thus bounded from above by
[Equation]
In the second case, the last request arrives in Phase (iii).
In this case the cost after r last is the cost offollowing the predicted tour, adapted for incorporating the unexpected, yet unserved, requests.
Thisis bounded above by the cost of returning to the origin, following the predicted tour ˆ T , and finallyfollowing the optimal tour, T ∗ .
Note that the cost of returning to the origin is at most r last − αC ∗ .
Hence, we complete the proof by upper bounding the makespan, for any ρ ≥ 1 , by
[Equation]
3.2 Extensions and improvements
An improved algorithm for O L TSP with predictions A best possible online algorithm for O L TSPis S MART S TART , which is 2-competitive [7].
Using this in Phase (i) of D ELAY T RUST , Theorem 1yields a robustness factor of at most 3 + 2 α .
We exploit S MART S TART ’s waiting strategy to serve yetunserved requests and expedite Phase (iii) avoiding unnecessary waiting time, obtaining an algorithm,
S MART T RUST , with improved robustness factor 2 + 2 α .
See Theorem 2 for O L TSP in Appendix B.1.
Algorithms with polynomial running time Algorithms D ELAY T RUST and S MART T RUST requirethe computation of optimal TSP tours on subinstances.
NP-hardness of TSP prohibits polynomialrunning time, unless P = NP.
We provide performance guarantees for our learning-augmented algorithm framework when using polynomial-time ν -approximation algorithms for solving TSP, whichguarantee to find a TSP tour within a factor ν of the optimum.
We use a modified efficient P RED R EPLAN strategy which uses a ν -approximate solution instead of anoptimal solution and further ensures that errors due to such approximations do not add up too much.
Adjusting the proof of Theorem 1 yields the following result, whose proof is in Appendix B.2.
Theorem 8.
Given a ν -approximation algorithm for metric TSP, the competitive ratio of the polynomial time D ELAY T RUST using a polynomial time ρ -competitive online algorithm in Phase (i) is, forany α > 0 , bounded by min (cid:8) (1 + ν )(1 + α ) (cid:0) 1 + 3 · Λ 1 2 · C ∗ (cid:1) , (cid:0) ρ + (1 + ν )(1 + ρα ) (cid:1)(cid:9) .
Online metric Dial-a-Ride with predictions The Online Metric Dial-a-Ride Problem (O L DARP)is a generalization of O L TSP where each request ( x s , x d , r ) has a starting location x s and a destination x d .
To serve a request, the server must first visit x s at some time not earlier than r , and then x d .
We assume that the server can carry at most one request at the time and cannot store it after pickup.
We show in Appendix B.3 that slight modifications of D ELAY T RUST and S MART T RUST yield
Theorems 1 and 2 for this generalized setting.
We define the cost function γ DaRP for the cover error: [Equation] DaRP
[Equation]
,where D is the maximum transportation distance in R ∩ ˆ R .
Intuitively, an excursion can start from x safter time r or from x d after time r + d ( x s , x d ) to serve R ′ , whatever is the shorter of the two.
An improved algorithm for O L TSP on the half-line metric When restricting the metric spaceto X = R ≥ 0 , the best possible online algorithm is 32 -competitive
We design a learningaugmented algorithm tailored to this metric space and a minimalistic prediction, namely, a singlevalue ˆ C predicting the optimal makespan C ∗ .
We prove (Appendix B.4)
the following error-dependentperformance bound, which gives an almost tight consistency-robustness tradeoff w.r.t Theorem 5.
Theorem 9.
There is a learning-augmented algorithm for the half-line metric that has for everyα ∈ (0 , 1 / 2] a competitive ratio of at most min (cid:8) (1 + α ) (cid:0) 1 + Λ 1 C ∗ (cid:1) , 32 α (cid:9) .
Online network design problems with predictions
This section sketches the applicability of our new error measure for the online-list problems Steiner
Tree, Steiner Forest and (capacitated) facility location.
To prove new error-dependent performancebounds as stated in Theorem 3 and Theorem 4, we revisit the algorithms proposed by Azar et al.
[12]and analyze it w.r.t.
our cover error measure.
The key is an appropriate, problem-specific definition ofthe cost of a hyperedge and the corresponding analysis.
Recall that the cost of a hyperedge R ′ ∪ { x ′ }should (intuitively) be equal to the value of an optimal solution for serving a set of unexpected(predicted absent)
requests R ′ w.r.t.
a predicted (actual) request x ′ .
We define the cost functions:
Steiner tree: γ ST ( R ′ , x ′ )
=
cost of an optimal Steiner tree for terminals R ′ with root x ′
Steiner forest: γ SF ( R ′ , x ′ )
=
cost of an optimal Steiner forest for terminal pairs R ′
when
connecting via x ′ =
( s ′ , t ′ ) is free.
Facility
location: γ FL ( R ′ , x ′ )
=
cost for opening facility x ′ and assigning clients R ′ to it.
Our main technical contribution for online network design problems are the proofs of Theorem 3 and
Theorem 4.
We now give some intuition on how these proofs work by considering the online Steinertree problem, and defer details and results for this and the other problems to Appendix C.
[Figure]
On a very high level, the algorithm by Azar et al.
[12] for online Steiner tree connects arrivingterminals to the current solution greedily, i.e., by buying the edges on the shortest path to vertices ofthe current solution.
Additionally, at times depending on a doubling strategy, it connects as manyfuture predicted requests to the current solution as a certain budget allows.
The proof of Theorem 3 splits the execution of this algorithm into two subsequences depending onthe time when all predicted requests are satisfied.
We use a sub-result provided by Azar et al.
[12] tobound the total cost of both subsequences by variables of the algorithm.
To further bound the firstpart, we use the structure of a min-cost ∞ -hyperedge cover of ˆ R to prove an upper bound of at most
O (1) · OPT+ O (1) · Γ ∞ ( ˆ R, R ) .
For the second part, we consider the total cost the Greedy algorithmincurs for a hyperedge of a min-cost k -hyperedge cover of R , and conclude by the bounded hyperedgesize and Greedy properties that this is at most O (log k ) times the hyperedge cost, yielding a totalbound of O (1) · OPT + O (log k ) · Γ k
( R, ˆ R ) .
Here we especially use the fact that any predictedterminal ˆ x which covers actual requests must already be served due to our chosen splitting point.
Experiments
We performed various empirical experiments on real-world O L TSP instances that demonstrate thebenefits of using our algorithms over classic online algorithms.
We consider the road network of
Manhattan [18,42] and compose 100 instances of 10 requests each based on taxi pickup requests froma dataset offered by the NYC Taxi & Limousine Commission.
1 We compare S MART T RUST with theclassic online algorithms R EPLAN
[7], I GNORE [7,24,46] and S MART S TART [7]; all algorithms useefficient TSP heuristics.
We report for every experiment and instance the empirical competitive ratio,i.e. the average ratio between the algorithms performance and the approximated value of the optimalmakespan, as well as error bars that denote the 95% confidence interval over all instances.
We sketch here two relevant experiments and defer further details to Appendix D. The first experimentconsiders synthetic predictions with Gaussian noise σ only in the request locations, i.e., the releasedates are predicted correctly.
The results (Figure 3a) show that S MART T RUST with α = 0 .
1 dominatesclassic algorithms even for arbitrarily bad predictions.
In the second experiment only a part of theactual instance is predicted, which is an interesting and practice-relevant variant.
Again, the results(Figure 3b) show that for small values of α , S MART T RUST outperforms all classic algorithms.
Concluding remarks
The universal cover error can be applied to arbitrary problems with uncertain inputs.
As it seems tobe the first error measure that captures arrival times, it seems very natural to investigate, in particular,other online-time problems such as, e.g., scheduling problems.
Further, it would be interesting toidentify more compact or smaller predictions.
While we predict a full input instance much lessinformation might be sufficient to gain high-quality solutions.
This can be only partial informationabout the input instance or predictions on algorithmic actions, such as an optimal tour instead ofrequest sequences.
In the latter case, we can directly apply our framework after approximating thepredicted tour by some time-stamped discrete points and using those as input prediction.
Checklist
For all authors...
(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s
contributions and scope?
[Yes]
(b) Did you describe the limitations of your work?
[Yes]
(c) Did you discuss any potential negative societal impacts of your work?
[N/A]
(d) Have you read the ethics review guidelines and ensured that your paper conforms to
them?
[Yes]
If you are including theoretical results...
(a) Did you state the full set of assumptions of all theoretical results?
[Yes]
(b) Did you include complete proofs of all theoretical results?
[Yes] See Appendix for
most of the full proofs.
If you ran experiments...
(a) Did you include the code, data, and instructions needed to reproduce the main exper-
imental results (either in the supplemental material or as a URL)?
[Yes] See source
[Table]
code folder in supplemental material; instructions can be found in README.md.
[Table]
(b) Did you specify all the training details (e.g., data splits, hyperparameters,
how they
[Table]
were chosen)?
[Yes] See Appendix D
[Table]
(c) Did you report error bars (e
g., with respect to the random seed after running experi-
ments multiple times)?
[Yes] See Appendix D
[Table]
(d) Did you include the total amount of compute and the type of resources used (e
g., typeof GPUs, internal cluster, or cloud provider)?
[Yes] See Appendix D
[Table]
If you are using existing assets (e
g., code, data, models) or curating/releasing new assets...
[Table]
(a) If your work uses existing assets, did you cite the creators?
[Yes] OpenStreetMap
[Table]
contributors cited
[Table]
(b) Did you mention the license of the assets?
[N/A]
[Table]
(c) Did you include any new assets either in the supplemental material or as a URL?
[N/A]
[Table]
(d) Did you discuss whether and how consent was obtained from people whose data you’re
[Table]
using/curating?
[N/A]
[Table]
(e) Did you discuss whether the data you are using/curating contains personally identifiable
[Table]
information or offensive content?
[N/A]
[Table]
If you used crowdsourcing or conducted research with human subjects...
[Table]
(a) Did you include the full text of instructions given to participants and screenshots, ifapplicable?
[N/A]
(b) Did you describe any potential participant risks, with links to Institutional Review
Board (IRB) approvals, if applicable?
[N/A]
(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
[N/A]