A R EGRET M INIMIZATION A PPROACH TO M ULTIA GENT C ONTROL
A BSTRACT
We study the problem of multi-agent control of a dynamical system with known dynamics and adversarial disturbances.
Our study focuses on optimal control without centralized precomputed policies, but rather with adaptive control policies for the different agents that are only equipped with a stabilizing controller.
We give a reduction from any (standard) regret minimizing control method to a distributed algorithm.
The reduction guarantees that the resulting distributed algorithm has low regret relative to the optimal precomputed joint policy.
Our methodology involves generalizing online convex optimization to a multi-agent setting and applying recent tools from nonstochastic control derived for a single agent.
We empirically evaluate our method on a model of an overactuated aircraft.
We show that the distributed method is robust to failure and to adversarial perturbations in the dynamics.
I NTRODUCTION
In many real-world scenarios it is desirable to apply multi-agent control algorithms, as opposed to a centralized designed policy, for a number of practical reasons.
First is increased robustness: agents, serving as control actuators may be added or removed from an existing set without change to the distributed policies.
This also allows for fault-tolerance; agents can adapt on the fly to faulty actuators.
Second, limited computational resources and/or system information may limit applicability of a sophisticated centralized policy, whereas simple distributed policy agents are feasible and can adapt to the underlying dynamics.
Third, multi-agent control allows robustness to noisy state and control observations by the individual agents.
These advantages motivate the study of distributed control, and indeed a vast literature exists on the design and analysis of such methods.
In this paper we propose a novel game-theoretic performance metric for multi-agent control (MAC), which we call multi-agent regret .
This metric measures the difference between the total loss of the joint policy of individual agents vs. the loss of the best joint policy in hindsight from a certain reference class of policies.
Vanishing multi-agent regret thus implies competitive performance with respect to that of the optimal policy in a certain policy class.
We study a mechanism for MAC that takes individual controllers and merge them into a MAC method with vanishing regret.
For this purpose, we make use of recent advances in online learning for control and specifically the framework of nonstochastic control .
This methodology was recently proposed for the study of robust adaptive control algorithms through the lens of online convex optimization.
As opposed to optimal and robust control, nonstochastic control studies adaptive control algorithms that minimize regret , or the difference in loss/reward of the controller vs. the best policy in hindsight from a reference class.
This is a game-theoretic performance metric, which is naturally applicable to agents interacting in a multi-agent environment.
1. O UR RESULT AND TECHNIQUES
Our main result is a reduction from single agent to multi-agent control with provable regret guarantees.
More precisely, we assume that we have access to single-agent controllers with the following guarantees:
Each agent has sublinear regret vs. a class of policies under adversarial perturbations/costs.
Each agent should be able to evaluate their policy given the controls of the other agents.
The policy that each agent uses is independent of the controls that the other agents play.
The joint cost function over all agents needs to be jointly convex.
This set of assumptions is well motivated: we review several well-studied control settings in the literature which provide agents with such guarantees.
Under these assumptions we give a reduction that takes regret minimizing control agents and guarantees low multi-agent regret of the joint control policy, w.r.t.
the optimal joint policy in hindsight.
Let A be a single agent control algorithm 1 that, given a state x t , produces a control u t , and suffers cost c t ( x t , u t ) .
The average (policy) regret of A w.r.t.
policy class Π is defined to be the difference between its total cost and that of the best policy in hindsight, namely
[Equation]
Notice that the comparator are the states x πt and controls u πt that would have been played by policy π .
Then algorithm C , described in Algorithm 3, takes as an input k such controllers, and under the aforementioned assumptions, controls a multi-agent system with the guarantee that
[Equation]
where A is the control algorithm for agent i , which is not necessarily the same for every agent, and ε is an upper bound on the error of each agent’s policy evaluation.
Here R T ( C ) is the multi-agent regret of the joint policy, namely the difference between the cost of C , and that of the best jointpolicy in hindsight.
The reference policy class we use for comparison is the Cartesian product of the individual agent policy classes.
This is defined precisely in Section 4.
In order to obtain this result we study a generalization of online convex optimization to the multiagent setting.
Specifically, we propose a reduction from online convex optimization (OCO) to multiagent OCO, such that the overall multi-agent regret is guaranteed to be the sum of the individual agents’ regret on an induced loss function.
1. R ELATED WORK
Multi-agent RL.
Multi-agent RL (Sutton & Barto, 2018) considers the problem of finding globally optimal joint policies through optimizing local policies.
Common approaches for finding optimal policies in RL includes dynamic programming, Monte-Carlo methods (Williams, 1992), temporal difference learning (Watkins & Dayan, 1992), combining temporal difference and Monte-Carlo learning, evaluation strategies (Salimans et al., 2017), and policy gradient methods (Williams, 1992;
Mnih et al., 2016).
Policy gradient methods, which are closest to our algorithm, compute stochastic gradients from trajectories (Sutton et al., 2000; Sutton & Barto, 2018).
More recently, Jin et al.
(2021) provide a decentralized value-based method with game-theoretic equilibrium guarantees.
Performance in multi-agent coordination significantly improves with agents’ ability to predict the behaviour of other agents.
In opponent modeling methods, wherein agents learn to model the behaviours of their partners, (Foerster et al., 2018) agents use counterfactual policies of other agents to update their policy parameters.
In contrast, our approach decouples the agents’ policies, forgoing the need to deal with counterfactuals of other agents.
Decentralized and Distributed control.
Communication-free decentralized control is the earliest multi-agent control model considered in the literature.
In this model, each agent observes a different partial observation of the state and each agent provides its own control input to the system.
This classic setting is well understood with exact characterizations of stabilizability (Wang & Davison, 1973) and controllability (Lefebvre et al., 1980).
More recently, decentralized control, also called distributed control, has been generalized to include a network layer of communication among the controllers, modeled by a network graph.
Coordinated and cooperative control over a communication network has been studied using a wide range of approaches, such as distributed optimization (Nedi´c et al., 2018), model predictive control (Christofides et al., 2013; St¨urz et al., 2020), and for a wide variety of problems, including stabilization of formations, coverage, and search (Olfati-Saber et al., 2007;
Bullo et al., 2009; Cao et al., 2013; Knorn et al., 2016).
One particular direction in this setting is on designing distributed observers, using information from neighbors to provide local estimates of the global state (Olfati-Saber, 2005; Carli et al., 2008; Matei & Baras, 2010; Das & Moura, 2017; Park & Martins, 2017).
Such distributed observers can be applied to produce end-to-end control laws.
One such approach stabilizes systems when the neighbor graph is strongly connected and the joint system is stabilizable (Wang et al., 2020).
In contrast to the present work, approaches to this problem are decentralized from an information perspective, but not a game theoretic perspective as controllers are designed centrally.
Exploiting input redundancy in control.
Input redundancy in overactuated systems enables efficient responses (Sobel & Shapiro, 1985) and robustness to failures (Oppenheimer et al., 2006;
Tohidi et al., 2017).
A number of optimization methods have been developed for redistributing desired control input under different faulty conditions.
Our approach does not tackle this directly, but the action-centric rather than policy-centric philosophy of the algorithm leads to some robustness in such settings.
Online learning and online convex optimization.
The framework of learning in games has been extensively studied as a model for learning in adversarial and nonstochastic environments (CesaBianchi & Lugosi, 2006).
Online learning was infused with algorithmic techniques from mathematical optimization into the setting of online convex optimization , see (Hazan, 2019) for a comprehensive introduction.
We particularly make use of the property that no-regret algorithms converge to equilibrium, a phenomenon originally proposed by (Hart & Mas-Colell, 2000).
Online and nonstochastic control.
The starting point of our study are algorithms which enjoy sublinear regret for online control of dynamical systems; that is, whose performance tracks a given benchmark of policies up to a term which is vanishing relative to the problem horizon.
(AbbasiYadkori & Szepesv ´ ari, 2011) initiated the study of online control under the regret benchmark for
Linear Time-invariant (LTI) dynamical systems.
Our work instead adopts the nonstochastic control setting (Agarwal et al., 2019), that allows for adversarially chosen (i.e. non-Gaussian and potentially adaptively chosen (Ghai et al., 2021)) noise and costs that may vary with time.
The nonstochastic control model was extended to consider nonlinear and time-varying dynamics in (Gradu et al., 2020;
Minasyan et al., 2021; Chen et al., 2021).
See (Hazan & Singh, 2021) for a comprehensive survey of results and advances in online and nonstochastic control.
P ROBLEM S ETTING 2. N OTATION
The norm ∥ · ∥ refers to the ℓ 2 norm for vectors and spectral norm for matrices.
For any natural number n , the set [ n ] refers to the set { 1 , 2 . . .
n } .
We use the window notation z a : b :=
[ z a , . . .
, z b ] to represent a sequence of vectors.
We use the convention where indices i, j refer to agents, with superscripts (typically) denoting an agent-specific quantity, while lack of a superscript denotes something global.
We use the index − i to represent information for all agents except i , for example
[Equation]
2. M ULTI -A GENT N ONSTOCHASTIC C ONTROL P ROBLEM
We consider the following multi-agent control problem.
Let f t : R d x × R d u
→
R d x and g
i : R d x → R d yi define known time varying dynamics.
Now, starting from state x 0 , the system follows
[Equation]
where x t is the state, u t is the joint control consisting of u it ∈ R d ui for each i ∈ [ k ] , y it is a partial observation, and e it , w t are adversarial chosen disturbance terms.
After committing to a control u it , agent i observes the controls of all other players u − i t along with a convex cost c t : R d x × R d u → R .
Together, the k agents suffer cost c t ( x t , u t ) .
It should be noted that while each agent shares its action with other agents, it does not directly share its policy or its observation.
A control policy for agent i , π i : (cid:83) s ∈ N R sd yi × R ( s − 1)
d u → R d u is a mapping from all available information to a control u
it =
π i ( y 1: t , u 1: t − 1 ) .
A joint policy for the multi-agent setting is a collection of policies for each agent π
= π 1: k .
Policy classes are defined analogously with Π i being a set of agent i policies and Π being a set of joint policies.
We often consider policies parameterized by vectors θ i ⊆
Θ i , where Θ i is some bounded convex domain and use the parameterizations and policies interchangeably.
Performance of joint policy π is measured by the average cost along the trajectory ( x π 1 , u π 1 . . . ) ,
[Equation]
For a set of online control algorithms for each agent C = C 1: k , we are interested in the average (policy) regret relative to some joint policy class Π , defined as
[Equation]
2. A SSUMPTIONS
Converging towards optimal play for an online control algorithm may not happen immediately, so our system cannot explode too quickly.
In order to bound the cost during this stage, x t must not explode in the absence of control.
The corresponding outputs in the absence of any controller is a concept called Nature’s y ’s in (Simchowitz et al., 2020), which are an integral part of DAC policies, defined below.
We analogously define Nature’s x ’s here.
Definition 2.1 (Nature’s x ’s and y ’s) .
Given a sequence of disturbances ( w t , e t ) t> 1 we define Nature’s x ’s and Nature’s y ’s respectively as the sequences x nat ,i t , y nat ,i t where y nat ,i t
= g i ( x t ) + e it , x nat t +1 = f t ( x t , 0) + w t .
Assumption 2.2 (Bounded Nature’s x ’s) .
We assume that w t and e t are chosen by an oblivious adversary, and that ∥ x nat t ∥ ≤ R nat for all t .
We also need well behaved cost functions for learning:
Assumption 2.3.
The costs c t ( x, u ) are convex and if ∥ x ∥ , ∥ u ∥ ≤ D then there exists constant C such that 0 ≤ c t ( x, u )) ≤ CD 2 .
In control, the most ubiquitous cost functions are quadratics, which satisfy this assumption.
Finally, we must restrict our joint policy class Π in order to obtain global regret guarantees.
We make the following assumption about each agent’s policy class:
Assumption 2.4 ( Decoupling).
For any policy π i ∈ Π i , the policy can always be represented as a function of the disturbances e it , w t .
In particular, there exists a function ¯ π : (cid:83) s ∈ N R ( s − 1) d x ×
R sd yi → R d u for any set of controls u 1: t − 1 and the resultant set of observations y 1: t , such that
[Equation] 1 , e i 1: [Equation]
Note, that if Assumption 2.4 holds for each agent’s policy class, then the joint policy class Π will depend implicitly on only w 1: t − 1 , e 1: t .
Policies that satisfy this assumption are special in that the controls played by one agent’s policy are completely independent of another agent’s policy, given the disturbances are chosen obliviously.
2. P OLICY C LASSES
We now introduce a few important policy classes that satisfy Assumption 2.4.
Disturbance-action Control.
For fully observed linear systems, disturbances w t can be derived from states and joint controls.
This allows us to use Disturbance Action Control, a policy parameterization that is linear in the disturbance history.
Definition 2.5.
A Disturbance-action Controller (DAC)
(Agarwal et al., 2019), π ( M ) , is specified by parameters M ∈ R d ui × md x where the control u
it =
Mw t − m : t − 1 .
A comparator policy class Π i can be defined as a bounded convex set M ⊂ R d u × md x of policy matrices.
It has been shown that DACs can approximate stable Linear Dynamic Controllers (LDCs), a powerful generalization of linear controllers that encompasses H 2 and H ∞ optimal controllers under partial observation, and is a mainstay in control applications (see Definition A.1 in Appendix A.2).
Furthermore, when costs are quadratic, it can be shown that a DAC also approximates the offline optimal policy (Goel & Hassibi, 2021).
Disturbance-response Control.
Another policy class that suits our needs, especially if the system is partial observed, is that of Disturbance-Response Control (DRC).
Unlike in the fully observed setting, with partial observations it is generally impossible for an agent to calculate w t for use in a policy.
Instead, DRC controllers are a linear function of a window of previous Nature’s y ’s defined as follows:
Definition 2.6.
A Disturbance-response Controller (DRC) (Simchowitz et al., 2020), π ( M ) , is specified by parameters M ∈ R d u × md y where the control u it
=
My nat t − m : t − 1 .
Like DAC, DRC is a powerful control law which also can approximate stable LDCs.
Furthermore,
Nature’s y ’s are just a function of w ’s and e ’s
so DRC policy classes satisfy Assumption 2.4.
Neural Network Policies We also consider neural network policies.
In particular, fully-connected neural-networks with ReLU activations that act on normalized windows of w ’s or Nature’s y ’ were explored in (Chen et al., 2021).
While there are more restrictions for this class, neural-networks are a richer policy class than the linear counterparts DAC and DRC.
M ULTIAGENT O NLINE C ONVEX O PTIMIZATION
Our derivation henceforth for the multi-agent control problem hinges upon a generalization of OCO to the multi-agent setting.
Now we describe this generalization, explain the challenge, and give a reduction from vanilla OCO, as well as OCO with Memory (OCO-M), to the multi-agent settings.
In multiplayer OCO we have k players and the i th learner iteratively chooses a vector from a convex set K i ⊆
R d .
We denote the total number of rounds as T .
In each round, the i th learner commits to a decision x it ∈ K i .
We define the joint decision x t = x 1: k t ∈ K = K 1: k .
Afterwards, the learner incurs a loss ℓ t ( x t ) where ℓ t is a convex loss function ℓ t : K → R .
The learner observers ℓ it : K i → R defined by ℓ it ( x ) =
ℓ t ( x, x − i t ) , where we use the notation ( x, x − i t ) to represent ( x 1 t , . . .
x i − 1 t , x, x i +1 t , . . .
x kt ) .
Regret is defined to be the total loss incurred by the algorithm with respect to the loss of the best fixed single prediction found in hindsight for each player.
Formally, the average multi-agent regret of a set of learning algorithms
A 1: k
=
A 1 , . . .
A k is defined as
[Equation]
Our goal is to create a black-box mechanism that takes as input regret minimizing strategies, and allows for joint-regret minimization with minimal or no central coordination.
C HALLENGES OF MULTI - AGENT OCO
A natural first attempt for joint regret minimization in multi-agent OCO is to allow each regret minimizing agent to operate on its own on the given loss function.
In this subsection we show that this naive strategy fails.
As an example, consider the simple scalar two player game.
Let ℓ t ( x 1 , x 2 ) =
( x 1 − x 2 ) 2 + 0 .
1 ∥ ( x 1 , x 2 ) ∥ 22 for all t .
Now we consider A 1 and
A 2 to be algorithms that each alternate between playing 1 on odd t and − 1 on even t .
In this setup, the online learners see losses:
[Equation]
By design of A 1 and A 2 , predictions alternate between (1 , 1) and ( − 1 , − 1) and ℓ 1 t ( x 1 t ) =
ℓ 2 t ( x 2 t ) = 0 .
In contrast, the best fixed decision in hindsight is 0 for both players, suffering loss ℓ 1 t (0) =
ℓ 2 t (0) = 1 . 1 for all t , so each player has negative regret.
However, for the multiplayer game, the best loss in hindsight is 0 by playing x 1 t = x 2 t = 0 for all t , so the multi-agent regret is 0 .
2 T .
We note that this phenomenon is well known in the game theory literature, where failure of no-regret algorithms to converge to Nash equilibrium has been studied (Blum et al., 2008).
Our study extends this observation to the dynamic games setting.
3. R EDUCTION FROM OCO TO MULTI - AGENT OCO
To overcome the lower bound of the previous section, we choose to apply the reduction from multiagent to single agent OCO via the instantaneous linearization.
This simple change makes all the difference, and allows for provable sublinear multi-agent regret (See Appendix.
A.1 for proof).
Input: OCO algorithm A
i , convex domain
K i ⊆
R d for t = 1 to T do
Learner A i predicts x it
Calculate g
it = ∇ ℓ it ( x it )
Feed A i linear loss function ⟨ g it , ·⟩ end for
Input: OCO-M algorithm
A
i , convex domain
K i ⊆
R d and memory length h for t = 1 to T do
Learner A i predicts x it
Calculate g
it = ∇ ℓ it ( x it − h : t )
Feed A i linear loss function ⟨ g it , ·⟩ end for
Theorem 3.1.
Suppose for each i ∈ [ k ] ,
OCO algorithm A i has regret R T ( A i ) over K i ⊆
R d with linear loss functions provided by Alg.
1, then the multi-agent regret of Alg.
1 is upper bounded by
R T ( A 1: k ) ≤ (cid:80) ki
=1 R T ( A i ) .
3. M ULTIPLAYER OCO WITH M EMORY
The control setting which motivates our whole study is inherently state-based.
Therefore we need to extend the multi-agent OCO to allow for memory.
This is similar to the previous section but the loss functions now have memory of the h previous controls.
After each of the k online learners commits to the joint decision x t as defined in the previous section.
The learners incur a loss ℓ t ( x t − h : t ) where ℓ t is a convex loss function ℓ t : K h +1 →
R .
The learner observers ℓ it :
K h
+1 i
→ R by ℓ it ( z ) =
ℓ t ( z, x − i t − h : t ) .
Regret is defined to be the total loss incurred by the algorithm with respect to the loss of the best fixed single prediction found in hindsight for each player.
Formally, the average regret of a set of learning algorithms
A 1: k is
[Equation]
where ¯ ℓ t ( x ) =
ℓ t ( x, . . .
x ) .
The main result of this section is given by the following theorem, which is formally proved in the appendix.
The proof (See Appendix A.1) follows the memoryless setting.
Theorem 3.2.
Suppose for each i ∈ [ k ] OCO-M algorithm with memory A
i has regret R T ( A i ) over K i ⊆
R d with linear loss functions provided by Alg. 2, then the regret of Alg.
2 has regret upper bounded by R T ( A 1: k ) ≤ (cid:80)
ki =1 R T ( A i ) .
T HE M ETA -A LGORITHM AND ITS A NALYSIS
This section contains our main result: a meta-algorithm for multi-agent nonstochastic control.
We start by defining the precise requirements from the single agent controllers that are given as input, and assumptions on them.
We then proceed to describe the meta-algorithm and its main performance guarantee on the multi-agent regret.
We describe a few special cases of interest in Appendix B.
4. A SSUMPTIONS AND DEFINITIONS
The single agent control algorithms that are the basis for the reduction need to satisfy following requirements:
• Each agent should be able to evaluate their policy given the controls of the other agents.
• The joint cost function over all agents is jointly convex.
• Agent policies need to be decoupled in the sense of Assumption 2.4.
We now specify these requirements more formally.
We introduce two related notions of a ( ε, h ) -policy evaluation oracle (PEO) for a multi-agent control problem.
A joint PEO allows us to counterfactually evaluate a complete multi-agent policy, while a local PEO allows us to counterfactually evaluate the policy of a single agent, fixing the remainder of the controls.
ε is the accuracy required of this oracle, while h is something like a mixing time such that the cost of the t th state can be well approximated regardless of the history before t − h .
Given the available control information u 1: t − 1 , observations y i 1: t , and cost function c t , a loss function ℓ t is a joint ( ε, H ) -PEO, if ℓ t ( θ 1: k 1: H ) provides an ε approximate estimate of c t (˜ x t , ˜ u t ) where ˜ x t is the counterfactual state had ˜ u t − r +1 been played according to joint policy π θ 1: k r .
Likewise, ℓ it is the local PEO of the i th agent, if ℓ it ( θ 1: h ) provides an ε approximate estimate of c t (˜ x t , ˜ u t ) where ˜ u t and ˜ x t are the counterfactual state and observation had u it − r +1 been played according to policy π θ r while all other controls u − i 1: t − 1 remain the same.
These oracles are defined formally in Appendix A.3.
Remark 4.1 .
In order for a local agent to be able to provide an accurate estimate of the cost using only partial observations and controls, intuitively the cost may need to be restricted in in its dependence on the fully observed state.
For example, if all agents’ partial observations contain certain features from the state (e.g. the x - y - z position of the center of gravity of drone but no other velocity or angular features), the cost can depend on these and an agent PEO may exist.
A key observation is that for policies satisfying Assumption 2.4, if u − i t − h
+1: t are generated by policies θ − i t − h
+1: t respectively, then a local PEO and a joint PEO can be related via ℓ it =
ℓ t ( · , θ − i t : t − h +1 ) .
Because all controls are determined directly from the disturbances, changes in agent i ’s controls have no impact on the controls of other agents.
We now assume that beyond an initial burn-in time T b , we have the information to construct such an ( ε, h ) -local PEO.
We also must guarantee that the PEOs we use are convex in order to use OCO.
Assumption 4.2 (Information) .
For t ≥ T b > h , for each agent i , there exists a functional L i such that ℓ it
=
L i ( c t , u 1: t , y i 1: t ) is a ( ε, h ) -local PEO for policy class
Θ i .
Assumption 4.3 (Convexity) .
There exists a ( ε, h ) joint PEO ℓ t that is convex such that ℓ it =
L i ( c t , u 1: t , y i 1: t ) satisfies ℓ it =
ℓ t ( · , θ − i t − h
+1: t ) .
4. M ULTI -A GENT C ONTROL M ETA -A LGORITHM AND A NALYSIS
Our reduction is described in Algorithm 3.
It accepts as input OCO-M algorithms
A i and applies them sequentially using the linearization technique of the previous section.
policy parameterization
policy evaluation
policy control 0 . t > T b then 8: Construct policy evaluation oracle ℓ it =
L i ( c t , u 1: t , y i 1: t ) and compute g it = ∇ ℓ it ( θ it − h,t ) 9:
Feed A i linear loss function ⟨ g it , ·⟩ and receive policy parameterization θ it +1 .
10: end if 11: end for Pay c t ( x t , u t ) 12: end for
The inner loop of the algorithm starting at Line 5 is what is performed by a local agent.
The information available in this scope is the local observation and the controls of the other agents.
We note that Alg.
3 only uses ℓ it instead of ℓ t , which is only used for analysis.
This is fundamental as each agent is unaware of the policies of other agents.
The performance guarantee for this meta-algorithm is given by:
Theorem 4.4.
Suppose Assumptions 2.2, 2.3, 2.4 hold and Assumptions 4.2, 4.3 holds with burnin T b , horizon h and error ε .
If A i are OCO-M algorithms with regret R T ( A i ) on linear loss functions provided by Algorithm 3 over policy parameterization class Θ i , then the multi-agent regret of Algorithm 3 is bounded by
[Equation]
See Section A.4 for proof.
Algorithm 3 leaves most of the technical challenge to a policy evaluation oracle.
It’s not immediately obvious that such a function exists and is efficient to compute.
Fortunately, recent work from nonstochastic control provides exactly what we need for Linear Dynamical
Systems with a variety of policy classes.
Appendix B contains a thorough discussion of applications for Linear Dynamical Systems.
E XPERIMENTS 5. R OBUSTNESS TO S YSTEM F AILURES
Our algorithm guarantee can also be extended to handle situations where certain agents no longer are locally regret minimizing (e.g. an actuator breaks).
Because Algorithm 3 is agnostic to the policy played by other players, if we want to bound the regret for a subset I ⊂ [ k ] of controllers, we can just view the policy class of the remaining agents as singleton open-loop policies that always play the same controls and so Theorem 4.4 will be a regret guarantee with respect to just the agents I with the remaining controls obliviously fixed.
Such robust guarantees are not achieved with existing approaches in nonstochastic control.
Typically, as in the Gradient Perturbation Controller (GPC) (Agarwal et al., 2019), a PEO ℓ t ( θ 1: h ) is passed to an online learning algorithm.
If the system breaks down and certain controls are not played according to the chosen policy, there will be a mismatch between the true cost and the PEO.
In contrast, because ℓ it uses the actual controls played by the algorithm, for an agent i that is not experiencing failure, the oracle accuracy remains unchanged and provides the correct gradient signal.
Algorithm 3 may be useful to provide robustness even for a single agent system with some failures.
5. ADMIRE EXPERIMENTS
In Fig.
1 we run GPC, LQR control, and a linear H inf control policy, along with Multi-Agent GPC (MAGPC), which is Algorithm 3 using gradient descent as the online learners A i .
These are used to stabilize the ADMIRE overactuated aircraft model (H ¨ arkeg ˚ ard & Glad, 2005) in the presence of 3 different disturbance profiles: Gaussian noise, a random walk, and a sinusoidal disturbance pattern.
We run the algorithms on the complete system, and with the 4 th controller forced inactive by zeroing out the control to demonstrate the robustness of our approach.
Figure 1 demonstrates the
GPC failure described in Section 5.1.
In the random walk experiment, GPC explodes, but MAGPC stabilizes the system.
See Appendix C for full details.
We note that, when a control failure does not occur and learning rates are sufficiently small, GPC and MAGPC are essentially the same algorithm.
This is because the policies change slowly so ℓ it ( θ t − h : t )
≈ ℓ it ( θ t . . .
θ t ) , which is GPC’s proxy loss.
[Figure]
D ISCUSSION AND C ONCLUSIONS
Conclusions We have described a new approach for regret minimization in multi-agent control that is based on a new proposed performance metric: multi-agent regret.
This measures the difference in cost between that of a distributed control system and that of the best joint policy from a reference class.
We give a reduction that takes any regret minimizing controller and converts it into a regret minimizing multi-agent distributed controller.
Future directions
The most interesting question is whether similar metrics of performance and ideas can be applied to general multi-agent reinforcement learning (MARL), since here we exploit full knowledge of the dynamics.
It will be interesting to see if our information model can be relaxed and still allow sublinear multi-agent regret.
It also remains to explore the extent of robustness obtained from a multi-agent regret minimizing algorithm.
A D EFERRED T ECHNICAL M ATERIAL A. P ROOF OF T HEOREMS 3.1 AND 3.
We provide a proof of Theorem 3.1, for the multi-agent regret of an OCO algorithm.
Proof.
Let ¯ x ∈ arg min x ∈K (cid:80)
Tt =1 ℓ t ( x ) with ¯ x i the component corresponding to player i .
By the convexity of ℓ t ,
[Equation]
Now we note that we can decompose ∇ ℓ t by player, so
[Equation]
Now we note that, R T ( A i )
=
(cid:80) Tt =1 ∇ ℓ it ( x it ) ⊤ ( x it − ¯ x i ) and the result follows.
Following the same ideas, we provide a proof of Theorem 3.2, for the multi-agent regret of an
OCO-M algorithm.
Proof.
Let ¯ x ∈ arg min x ∈K (cid:80)
Tt =1 ℓ t ( x ) with ¯ x i the component corresponding to player i .
Now by the convexity of ℓ t ,
[Equation]
Now we note that we can decompose ∇ ℓ t by player (after reorganizing coordinates), so ∇ ℓ t ( x t − h : t ) =
[ ∇ ℓ 1 t ( x 1 t − h : t ) ⊤ , ∇ ℓ 2 t ( x 2 t − h : t ) ⊤ , . . .
∇ ℓ kt ( x kt − h : t ) ⊤ ] ⇒ ∇ ℓ t ( x t − h : t ) ⊤ ( x t − h : t − (¯ x, . .
, ¯ x ))
=
k (cid:88) i = ∇ ℓ t ( x it − h : t ) ⊤ ( x it − h : t − (¯ x i , . .
, ¯ x i )) .
Now we note that, R T ( A i )
=
(cid:80) Tt =1 ∇ ℓ t ( x it − h : t ) ⊤ ( x it − h : t − (¯ x i , . .
, ¯ x i )) and the result follows.
A. L INEAR D YNAMICAL C ONTROLLER
Definition A.1 (Linear Dynamic Controller) .
A linear dynamic controller π is a linear dynamical system ( A π , B π , C π , D π ) with internal state s t ∈ R d π , input x t ∈ R d x , and output u t ∈ R d u that satisfies
[Equation]
Linear dynamical controllers involve an internal linear dynamical system to produce a control.
The combination of a Kalman Filter with Optimal control on the state estimates is a classic example.
A. T ECHNICAL D ETAILS FROM S ECTION
Below are the formal definition of joint and local policy evaluation oracles:
Definition A.2.
ℓ t : Θ h
→ R is an ( ε, h )
-joint
PEO if | ℓ t ( θ 1: k 1: h ) − c t (˜ x t , ˜ u t ) | ≤ ε where (˜ x 1: t − h , ˜ y 1: t − h , ˜ u 1: t − h − 1 ) =
( x 1: t − h , y 1: t − h , u 1: t − h − 1 ) and for s > t − h ˜ u s = π θ 1: k t − s +
(˜ y 1: s , ˜ u
1: s − 1 ) , (2) ˜ x s +
= f s (˜ x t , ˜ u s ) + w s , ∀ i ∈ [ k ] , ˜ y
i s +
=
g i (˜ x s +1 )
+ e i s +1 .
ℓ it : Θ hi → R is an ( ε, h ) -local PEO for agent i if | ℓ it ( θ 1: h ) − c t (˜ x t , ˜ u t ) | ≤ ε where (˜ x 1: t − h , ˜ y i 1: t − h , ˜ u 1: t − h − 1 ) =
( x 1: t − h , y i 1: t − h , u 1: t − h − 1 ) , ˜ u − i t − h
+1:
t = u − i t − h
+1:
t and for s > t − h ˜ [Equation]
[-π θ it − s +
-]is [Equation]
(˜ y i 1: s , ˜ u 1:
[Equation]
− 1 ) , (3) ˜ x s [-+
-]+1 =
f s (˜ x t , ˜ u s ) + w s , ˜ y
i s +
=
g i (˜ x s +1 )
+ e i s +1 .
A. P ROOF OF M AIN T HEOREM
We provide a complete proof of Theorem 4.4:
Proof.
In order to analyze the regret we begin with the following regret decomposition.
We first let θ ∗ =
arg min θ ∈ Θ (cid:80)
Tt =1 c t ( y π θ t , u π θ t ) and let π ∗ =
π θ ∗ denote offline optimal joint policy from our comparator policy class.
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
+
[Equation]
[Table]
The first term of the decomposition is exactly the cost of the first T b iterations because the Alg.starts with T b zero controls so by definition x C t are Nature’s x ’s. By Assumption 2.3, losses are nonnegative so we have − (cid:80) T b t =1 c t ( x π θ ∗ t , u π θ t ) ≤
so we drop these terms.
By combining Assumptions 2.3 and 2.2 we bound the burn-in cost as
[Equation]
The comparator truncation error is bounded by ε because for t > T b , | ℓ t ( θ ∗ , . .
, θ ∗ ) − c t ( x π θ ∗ t , u π θ ∗ t ) | ≤ ε by definition of an ( ε, h ) joint PEO.
Similarly, since C produces x C t with controls u s from joint policy θ s for the preceding h controls, the algorithm truncation error is also bounded by ε .
To bound the ℓ t multi-agent policy regret term, we note that Algorithm 3 chooses θ t exactly by the mechanism in Algorithm 2 with loss functions ℓ it .
By Assumption 4.2, ℓ it =
ℓ t ( · , θ − i t − h : t − 1 ) and by
Assumption 4.3, ℓ t is convex as desired.
As such, we bound the ℓ t multi-agent policy regret term using Theorem 3.2 as
[Equation]
i =
R T ( A i ) .
The result follows after combining the above bounds.
B A PPLICATIONS TO L INEAR D YNAMICAL S YSTEMS
For simplicity of presentation, we consider only stable systems.
However, we note that in settings with a single shared observation y t , these algorithms can be extended to work for unstable systems.
In order to do this, all agents must be aware of baseline stabilizing controllers employed by each agent, and Algorithm 3 can then be applied on the stable closed-loop system including the stabilizing component.
For a thorough treatment of this approach, we refer the reader to Appendix G of (Simchowitz et al., 2020).
We assume strong stability, which guarantees spectral radius of A strictly less than 1 .
Strong stability assures us that impact of disturbances and controls from the far history have a negligible impact on the current state.
This geometric decay enables the construction of PEO’s with horizon h just logarithmic in T while providing ε = 1 T approximation error.
Fully Observed LDS with Disturbance Action Control
We consider the case of a fully observed
LDS defined as follows:
[Equation]
with bounded adverserial disturbances w t , known strongly stable dynamics, and well behaved convex costs c t satisfying Assumption 2.3 2 .
We now show that a linear system with a DAC policy class M can satisfy assumptions required for Theorem 4.4.
We already saw that Assumption 2.4 holds for DAC policies.
Next we show that Assumption 2.2 holds.
By fully unrolling dynamics, Nature’s x ’s can be written as a linear combination of disturbances x nat t
=
(cid:80)
[Equation]
s =
A s w t − s .
Now because w t are bounded, and A is strongly stable, ∥ x nat t ∥ can be bounded by a convergent geometric series.
The last piece is constructing a PEO for a DAC policy.
Unrolling dynamics, we express states in terms of controls:
[Equation]
The truncation follows from strong stability of the dynamics.
Decomposing ˆ G , our Markov operator by agent, we can write x t ≈ x nat t + (cid:80) k
i =
1 ˆ G
i u it − 1: t − h .
Now to compute ℓ it ( M 1: h )
=
c t (˜ x
( M 1: h ) , Mw t − m : t − 1 ) we hold u − i s fixed while changing the policies for agent i .
Because the counterfactual state ˜ x ( M 1: h ) is affine in u it − 1: t − h and by the DAC policy parameterization agent i ’s controls are linear, the counterfactual state can be approximated as linear in M 1: h .
Composing with a convex cost c t gives a convex PEO ℓ it .
A complete analysis in the single agent setting can be found in (Agarwal et al., 2019).
In order to compute ℓ it ( M 1: h ) , the disturbances w t are needed.
Because agent i has access to the joint control u t , disturbances can be computed as w t = x
t +1 − Ax t − Bu t .
Once T b = m + h disturbances are observed, ℓ it can be computed.
Similar ideas can be applied using Nature’s y ’s and DRC to handle partial observations.
Furthermore, Theorem 4.4 can be applied with richer neural network policy classes as well.
For a more complete discussion, see Appendix B.
Partially Observed LDS with Disturbance Response Control
Another setting that we can capture with out meta-algorithm is partially observed linear dynamical systems, where all agents share the same partial observation.
In this case, the dynamics are as follows,
[Equation]
with bounded adversarial disturbances e t , w t and known strongly stable dynamics.
For a partially observed system with adversarial disturbances, it is known that many states can be consistent with the observations and so costs must be restricted to be well defined for the agents.
This is solved by using convex costs of the observation c t : R d y × R d u , so at time t the cost incurred is c t ( y t , u t ) .
Because y t is an affine function of x t , this cost is still convex in x to fit the general setting.
A policy class, that suits our needs is that of Disturbance-Response Control (DRC).
The satisfaction of the assumptions of Algorithm 3 follows from similar arguments to DAC in the fully observable case.
In particular, to compute PEO ℓ it , the following approximate Markov operator is used
[Equation]
In the above equation ˆ G i is the block of the Markov operator ˆ G corresponding to the i th agents controls.
Beyond this, the core ideas are the same, just replacing disturbances with Nature’s y ’s.
The last piece necessary is computing Nature’s y ’s.
This is not challenging given we have access to all agent’s controls, so we can let y nat t ≈ y t − ˆ G i u it − 1: t − h .
For a complete analysis of this approach in the single agent setting, refer to (Simchowitz et al., 2020).
Locally Partially Observed LDS with Disturbance Response Control
An extension of the prior setting of interest is for each agent to have it’s own local partial observation without needing to share it in the protocol.
In particular, consider the multi-agent system
[Equation]
with bounded adversarial disturbances e it , w t and known strongly stable dynamics.
As noted in
Remark 4.1, in order for each agent to have a local PEO, the cost c t ( x t , u t ) needs to be computable with only local information at each agent.
Therefore, we assume there are local cost functions
c it : R d yi × R d u for each agent such that for all i ∈ [ k ] , c t ( x, u )
=
c it ( C i x + e it , u t ) .
With access to the global loss in each agent, agent i can use DRC with y nat ,i t to satisfy all assumptions required for our meta-algorithm.
Each observation matrix C i produces a different markov operator
G i =
[ C i B, . . .
, C i
A h − 1 B ] , such that y it
=
y nat ,i t + G i u t − 1: t − h .
Using G i agent i can compute y
nat ,i t and build a PEO in the same way as the single partial observation setting.
Linear Dynamics with Neural Network Policies All the previous policy parameterizations were linear in some feature representation.
Recent work shows that nonstochastic control can extend beyond linear policies using analysis from deep learning theory (Chen et al., 2021).
The authors consider the fully observed setting with fully-connected ReLU neural network policies that act on normalized windows of disturbances.
A regret bound for online episodic control is shown by proving that under some technical conditions, a PEO is ε - nearly-convex , which means
[Equation]
It can be readily shown that Theorem 3.2 can be extended to nearly convex functions using nearconvexity in place of convexity, so we can get a multi-agent control regret guarantee for two-layer neural nets that act on normalized windows of disturbances.
In addition, the proof that a PEO is nearly convex can be extended to neural net policies that act on normalized windows of Nature’s y ’s, so neural net policies can also be used in the partial observation settings described above.
C R OBUSTNESS TO S YSTEM F AILURES : O VERACTUATED A IRCRAFT
In this section we provide the mathematical model of an overactuated aircraft based on ADMIRE (H ¨ arkeg ˚ ard & Glad, 2005), and demonstrate the robustness of our controller to system failures.
Let α, β, p, q, r be angle of attack, slideslip angle, roll rate, pitch rate and yaw rate respectively.
State space can be given as x =
[ α β p q r ] T and input space consists of 4 one-dimensional controllers, (cid:2) uuuu 4 (cid:3) .
Discrete linear dynamics of the system can be given as x ( t + 1) =
Ax ( t ) + (cid:80) 4 i =1 B
i u i ( t ) + W ( t )
where,
A =    1 .0 .0 .0 .
− 0 .
− 0 .0 . − 0 .
− 3 .
1070 − 0 .
5439 − 0 . 0 .0 .
0 .


B =
[ B
B B
B 4 ] =   0 .
6981 − 0 .
5388 − 0 .0 .
− 0 .0 .0 .
− 2 .2 .−
[Table]
 and W ( t ) is the disturbance.
C. E XPERIMENTAL S ETUP
Controller details:
GPC has a decaying learning rate of 0 .
001 t , a rollout length h of 5 and uses DACs with windows of size 5 . 2.
MAGPC is split into 4 1 -d controllers, each using decaying learning rate of 0 .
001 t , a rollout length 5 and a DAC with window length 5 .
We use a linear H ∞ controller and standard infinite horizon LQR linear controller.
Disturbance details:
Random walk chooses w t = w t − 1 + X t where X t is a standard Gaussian random variable.
Gaussian noise is iid.
and has variance 1 . 3.
Sinusoidal noise is chosen via w i = sin(2 t + ϕ i ) where ϕ
= [12 . 0 , 21 . 0 , 3 . 0 , 42 . 0 , 1 . 0] , picked arbitrarily once.
Fourth control is set to 0 in one experiment and otherwise controls are left unchanged.