On decision-making without regret, routing games, and convergence to equilibria

On decision-making without regret, routing games, and convergence toequilibria Avrim Blum Carnegie Mellon University [Talk includes work joint with Eyal Even-Dar, Katrina Ligett, Yishay Mansour, and Brendan McMahan]

Online learning and game theory Avrim Blum Carnegie Mellon University [Talk includes work joint with Eyal Even-Dar, Katrina Ligett, Yishay Mansour, and Brendan McMahan]

Consider the following setting… • Each morning, you need to pick one of N possible routes to get to work. • But traffic is different each day. • Not clear a priori which will be best. • When you get there you find out how long your route took. (And maybe others too or maybe not.) MIT 32 min • Is there a strategy for picking routes so that in the long run, whatever the sequence of traffic patterns has been, you’ve done not much worse than the best fixed route in hindsight? (In expectation, over internal randomness in the algorithm) • Yes.

In fact, results of this sort have been known for a long time… Plan for this talk: • History and background on these “no-regret” algorithms. • Some recent results / new directions. • Connections to game-theoretic equilibria (correlated equilibria, Nash equilibria in some cases) Talk is combination of classic and new work. Talk-version of survey chapter that Yishay Mansour and I are writing….

“No-regret” algorithms for repeated games Adversary – world - life Algorithm A bit more generally: • Repeated play of matrix game with N rows. (Algorithm is row-player, rows represent different possible actions). • At each time step, algorithm picks row, life picks column. • Alg pays cost for action chosen. • Alg gets column as feedback (or just its own cost in the “bandit” model). • Need to assume some bound on max cost. Let’s say all costs between 0 and 1.

“No-regret” algorithms for repeated games • At each time step, algorithm picks row, life picks column. • Alg pays cost for action chosen. • Alg gets column as feedback (or just its own cost in the “bandit” model). • Need to assume some bound on max cost. Let’s say all costs between 0 and 1. Define average regret in T time steps as: (avg per-day cost of alg) – (avg per-day cost of best fixed row in hindsight). We want this to go to 0 or better as T gets large [= “no-regret” algorithm].

Some intuition & properties of no-regret algs. Adversary – world - life Algorithm • Time-average performance guaranteed to approach minimax value V of game (or better, if life isn’t adversarial). • Two NR algorithms playing against each other will have empirical distribution approach minimax optimal. • Existence of no-regret algs yields proof of minimax thm. • Algorithms must be randomized or else it’s hopeless.

History and development (abridged) • [Hannan’57, Blackwell’56]: Alg. with regret O((N/T)1/2). • Re-phrasing, need only T = O(N/2) steps to get time-average regret down to . (will call this quantity T) • Optimal dependence on T (or ). Game-theorists viewed #rows N as constant, not so important as T, so pretty much done. • Learning-theory 80s-90s: “combining expert advice” • Perform (nearly) as well as best f2C. View N as large. • [LittlestoneWarmuth’89]: Weighted-majority algorithm • E[cost] · OPT(1+e) + (log N)/e· OPT+T+(log N)/ • Regret O((log N)/T)1/2. T = O((log N)/2). • Optimal as fn of N too, plus lots of work on exact constants, 2nd order terms, etc. [CFHHSW93]… • Extensions to bandit model (adds extra factor of N).

Efficient implicit implementation for large N… MIT • Bounds have only log dependence on N. • So, conceivably can do well when N is exponential in natural problem size, if only could implement efficiently. • E.g., case of paths… • Recent years: series of results giving efficient implementation/alternatives in various settings

Efficient implicit implementation for large N… • Recent years: series of results giving efficient implementation/alternatives in various settings: • [HelmboldSchapire97]: best pruning of given DT. • [BChawlaKalai02]: 1+ static-optimal for list-update • [TakimotoWarmuth02]: online shortest path in DAGs. • [KalaiVempala03]: elegant setting generalizing all above • Online linear programming, more general online optimization (offline ) online) • [Zinkevich03]: online convex programming • [AwerbuchKleinberg04][McMahanB04]:[KV]!bandit model • [Kleinberg,FlaxmanKalaiMcMahan05]: [Z03] ! bandit model • [DaniHayes06]: faster convergence for [MB]

Kalai-Vempala setting and algorithm • Set S of feasible points in Rm, of bounded diameter. (E.g., indicator vectors for possible paths) • Assume have oracle for offlineproblem: given vector c, find x 2 S to minimize c¢x. Use to solve online problem: on day t, must pick xt2 S before ct is given. • Form of bounds: • T = O(diam(S) ¢ L1 bound on c’s ¢ log(m)/ 2). • For online shortest path, T = O(nm¢log(n)/2). • Bandit setting [AK][MB]…: What if alg is only told costxt¢ct and not ct itself. Can you still be comparable to the best path in hindsight (which you don’t even know)? • Ans: yes, though bounds are worse. x

A natural generalization • A natural generalization of our regret goal is: what if we also want that on snowy days, we do nearly as well as the best route for snowy days. • And on Mondays, do nearly as well as best route for Mondays. • More generally, have N “rules” (on Monday, use path P). Goal: simultaneously, for each rule i, guarantee to do nearly as well as it on the time steps in which it fires. • For all i, want E[costi(alg)] · (1+)costi(i) + O(-1log N). (costi(X) = cost of X on time steps where rule i fires. Can extend to fractional case too.)

A natural generalization • This generalization is esp natural in machine learning for combining multiple if-then rules. • E.g., document classification. Rule: “if <word-X> appears then predict <Y>”. E.g., if has football then classify as sports. • So, if 90% of documents with footballare about sports, we should have error · 11% on them. “Specialists” or “sleeping experts” problem. Studied theoretically in [B95][FSSW97][BM05]; in practice [CS’96,CS’99]. Give simple alg. (joint with Yishay Mansour). Will describe in two ways…

A natural generalization • Recall setup: have N “rules” (on Monday, use path P). • For all i, want E[costi(alg)] · (1+)costi(i) + O(-1log N). (costi(X) = cost of X on time steps where rule i fires. Can extend to fractional case too.) • Will consider case that rules are explicitly given.

A natural generalization • Algorithm works as follows: • Define “relaxed regret” with respect to rule i as: Ri = E[costi(alg)]/(1+) – costi(i). • Give rule i weight wi = (1+)Ri. Pick with prob pi=wi/W. • Initially, all weights are 1 and sum to N. • Prove sum of weights never increases: • Conclude Ri· log1+N ¼-1log N. • Can extend to rules that can be fractionally on too. Want ·-1log N insert proof here

A natural generalization • Algorithm works as follows: • Define “relaxed regret” with respect to rule i as: Ri = E[costi(alg)]/(1+) – costi(i). • Give rule i weight wi = (1+)Ri. Pick with prob pi=wi/W. • Initially, all weights are 1 and sum to N. • Prove sum of weights never increases: • Conclude Ri· log1+N ¼-1log N. • Can extend to rules that can be fractionally on too. Want ·-1log N

A natural generalization Equivalent view: • Start with all rules at weight 1. • At each time step, of the rules i that fire, select one with probability pi/ wi. • Update weights: • If didn’t fire, leave weight alone. • If did fire, raise or lower depending on performance compared to weighted average: • ri = [j pj cost(j)]/(1+) – cost(i) • wiÃ wi(1+)ri • So, if rule i does exactly as well as weighted average, its weight drops a little. Weight increases if does better than weighted average by more than a (1+) factor. This ensures sum of weights doesn’t increase. • Ri is sum of ri over all time steps in which rule i fired.

Can combine with KV too: • Assume we are given N “conditions” or “features” to pay attention to (is it snowing?, is it a Monday?, …). • Each day satisfies some conditions and not others. • For each condition i, run a copy of KV on just the days satisfying that condition. • Then view these N algorithms as “sleeping experts” and feed their suggestions as inputs into previous alg. • For each condition i, on the days satisfying that condition we do nearly as well as the best copy of KV for the days satisfying that condition.

Now to Part II…

What if everyone started using no-regret algs? • What if changing cost function is due to other players in the system optimizing for themselves? • No-regret can be viewed as a nice definition of reasonable self-interested behavior. So, what happens to overall system if everyone uses one? • In zero-sum games, behavior quickly approaches minimax optimal. • In general-sum games, does behavior quickly (or at all) approach a Nash equilibrium? (after all, a Nash Eq is exactly a set of distributions that are no-regret wrt each other). • Well, unfortunately, no.

A bad example for general-sum games • Augmented Shapley game from [Z04]: “RPSF” • First 3 rows/cols are Shapley game (rock / paper / scissors but if both do same action then both lose). • 4th action “play foosball” has slight negative if other player is still doing r/p/s but positive if other player does 4th action too. • NR algs will cycle among first 3 and have no regret, but do worse than only Nash Equilibrium of both playing foosball. • We didn’t really expect this to work given how hard NE can be to find…

What can we say? • If algorithms minimize “internal” or “swap” regret, then empirical distribution of play approaches correlated equilibrium. • Foster & Vohra, Hart & Mas-Colell,… • Alg joint with Yishay Mansour gives current best T as fn of size of game N. • [don’t worry, I’ll define CE…] • In some natural cases, like routing in Wardrop model, can show daily traffic actually approaches Nash. • Work joint with Eyal Even-Dar and Katrina Ligett.

Internal/swap regret • “best expert” or “external” regret: • Given n strategies. Compete with best of them in hindsight. • “sleeping expert” or “regret with time-intervals”: • Given n strategies, k properties. Let Si be set of days satisfying property i (might overlap). Want to simultaneously achieve low regret over each Si. • “internal” or “swap” regret: like (2), except that Si = set of days in which we chose strategy i.

Internal/swap regret • In the set of days I used strategy i, how much better could I have done following some other strategy j? • Don’t want to have regret of the form “every time I bought IBM, I should have bought Microsoft instead”. • Internal regret: (maxi Ri)/T. • Swap regret: (i Ri)/T. Key motivation: If all parties have swap regret ·, then empirical distribution of play is an -correlated equilibrium.

Internal/swap regret • In the set of days I used strategy i, how much better could I have done following some other strategy j? • Don’t want to have regret of the form “every time I bought IBM, I should have bought Microsoft instead”. • Swap regret: (i Ri)/T. Suppose all parties have swap-regret ·: • Suppose a correlator chooses a random time t2 {1,2,…,T}. Tells each player to play the action i they played in time t (but does not reveal value of t). • Expected incentive to deviate:iPr(i)(Regret|i) = swap-regret of algorithm ·. • So, this gives a nice distributed way to get apx correlated equilibria in multiplayer games.

Internal/swap regret How to achieve low regret? • Several algorithms known (in standard setting where have N actions, listed explicitly). [HartMasColell][FosterVohra] [Cesa-BianchiLugosi][StoltzLugosi]… • Best explicit bounds for efficient algorithm [BMansour]: • T = O((N log N)/2). [For · 1/log N] • Nice open question: can you get sublinear in N (ideally want log N) against oblivious adversary? • Easy (N) lower bound with adaptive adversary: each day gives random cost vector in {0,1}N, except that previously-tried actions have cost 1. • Issue: swap-regret has implicit penalty for trying new actions.

[BMansour] algorithm: Plan: use a “best expert” algorithm A as subroutine. Idea: • Instantiate one copy Ai responsible for expected regret over times we play i. • If each Ai proposed to play qi, so all together we have matrix Q, then define p = pQ. • Allows us to view pi as prob we chose action i or prob we chose algorithm Ai. • Each time step, if we play p=(p1,…,pn) and get cost vector c=(c1,…,cn), then Ai gets cost-vector pic. • Then do a few calculations to show this works. (but not now)

Now on to the last part of the talk…

Consider Wardrop/Roughgarden-Tardos traffic model ce(f)=f vt vs ce(f)=2f • Given a graph G. Each edge e has non-decreasing cost function ce(fe) that tells latency of that edge as a function of the amount of traffic using it. • Say 1 unit of traffic (infinitesimal users) wants to travel from vs to vt. E.g., simple case: • Nash equilibrium is flow f* such that all paths with positive flow have the same cost, and no path is cheaper. Nash is 2/3,1/3 • Cost(f) = e ce(fe)fe = cost of average user under f. • Costf(P) = e 2 P ce(fe) = cost of using path P given f. • So, at Nash, Cost(f*) = minP Costf*(P). • Whathappens if people use no-regret algorithms?

Consider Wardrop/Roughgarden-Tardos traffic model • These are “potential games” so Nash Equilibria are not that hard to find. • In fact, a number of distributed procedures are known that will approach Nash at a good rate. These even have property that ifeveryone else is using them, you might as well do so too. • But maybe you don’t trust {the others, the model,…}. Can’t hurt you to use a no-regret algorithm instead! Motivates studying what happens if everybody is minimizing regret for themselves. Are Nash Equilibria the inevitable result of users intelligently behaving in their own interest? Also further motivates “price of anarchy” results.

Global behavior of NR algs [B-EvenDar-Ligett] 2/3 vt vs 1/3 • On day t, have flow ft. • Average regret  by some time T. • So, avgt[Cost(ft)] · + minP avgt[Costft(P)]. • What we’d like to say is the time-average flow favg is -Nash: Cost(favg) · + minP Costfavg(P) • Or even better that most ft are -Nash: Cost(ft) · + minP Costft(P) • But problems if cost functions are too sharp.

Global behavior of NR algs 2/3 vt vs 1/3 • Interesting case to consider: • Pure greedy has cost 1 every day. • NR alg: cost approaches ½ per day, which is cost of best fixed path in hindsight. • But none of the individual days is an -Nash flow (a flow where only a small fraction of traffic has significant incentive to switch). Same for time-average flow favg.

But can show if bounded slope… Proof sketch: • For any edge e, time-avg cost · flow-avg cost. So, feavg¢ avgt[ce(ft)] · avgt[ce(ft) ¢ ft] • Summing over all edges, and applying the regret bound: avgt[Costft(favg)]· avgt[Cost(ft)]·+minPavgt[Costft(P)], which in turn is· + avgt[Costft(favg)]. • This means that actually, for each edge, the time-avg cost must be pretty close to the flow-avg cost, which (by the assumption of bounded slope) means the costs can’t vary too much over time. • This then lets you swap quantifiers (cost/avg) to get: Cost(favg) ·’ + minP Costfavg(P) where ’ = O(( ¢ max-slope ¢ n)1/2). Can also get bounds for “most” ft too.

Some extensions • Can extend to multi-commodity case (different sources/destinations). • Can extend to case of different allowable subgraphs: • So each commodity is a (vs, vt, G’) triple. • For simple case of parallel links, this is “restricted machines setting”.

Summary/Open problems • Regret-minimizing algorithms esp motivated by online learning and routing-type problems. • “sleeping experts” algorithm can handle different Si. • Swap-regret related to correlated equilibria. • No-external-regret property sufficient to converge to Nash in Wardrop model. Open problems: • Time-bounds sublinear in N for achieving  swap regret? • Other “price of minimizing regret / true-anarchy / adaptive self-interested behavior” results?

On decision-making without regret, routing games, and convergence to equilibria