Data Sharing and Compression for Cooperative Networked Control
Year: 2021

Abstract:
Sharing forecasts of network timeseries data, such as cellular or electricity load patterns, can improve independent control applications ranging from traffic scheduling to power generation. Typically, forecasts are designed without knowledge of a downstream controller’s task objective, and thus simply optimize for mean prediction error. However, such task-agnostic representations are often too large to stream over a communication network and do not emphasize salient temporal features for cooperative control. This paper presents a solution to learn succinct, highly-compressed forecasts that are co-designed with a modular controller’s task objective. Our simulations with real cellular, Internet-of-Things (IoT), and electricity load data show we can improve a model predictive controller’s performance by at least 25% while transmitting 80% less data than the competing method. Further, we present theoretical compression results for a networked variant of the classical linear quadratic regulator (LQR) control problem.

heading: 1 Introduction
text: Cellular network and power grid operators measure rich timeseries data, such as city-wide mobility and electricity demand patterns. Sharing such data with external entities, such as a taxi fleet operator, can enhance a host of societal-scale control tasks, ranging from taxi routing to battery storage optimization. However, how should timeseries owners represent their data to limit the scope and volume of information shared across a data boundary, such as a congested wireless network?1
At a first glance, it might seem sufficient to simply share generic demand forecasts with any downstream controller. Each controller, however, often has a unique cost function and context-specific sensitivity to prediction errors. For example, cell demand forecasts should emphasize accurate peak-hour forecasts for taxi fleet routing. The same underlying cellular data should instead emphasize fine-grained throughput forecasts when a video streaming controller starts a download. Despite the benefits of customizing forecasts for control, today’s forecasts are mostly task-agnostic and simply optimize for mean or median prediction error. As such, they often waste valuable network bandwidth to transmit temporal features that are unnecessary for a downstream controller. Even worse, they might not minimize errors when they matter most, such as peak-hour variability.
Given the limitations of today’s task-agnostic forecasts, this paper contributes a novel problem formulation for learning task-driven forecasts for networked control. In our general problem (Fig.
1Uber processes petabytes of data per day [1] and a mobile operator can process 60 TB of daily cell metrics [2]. Even a fraction of such data is hard to send.
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
1), an operator measures timeseries st, such as electricity or cell demand, and transmits compressed representation φt, which is decoded to ŝt at the controller. Rather than simply minimize the prediction error for ŝt, we instead learn a representation that minimizes a modular controller π’s ultimate cost J . Our key technical insight is to compute a controller’s sensitivity to prediction errors, which in turn guides how we co-design and learn a concise forecast representation that is tailored to control. As such, our scheme jointly integrates data-driven forecasting, compression, and model-based control.
Related work: Our work is broadly related to information-theoretic compression for control as well as task-driven representation learning. The closest work to ours is [3], where task-driven forecasts are learned for one-step stochastic optimization problems. In stark contrast, we address compression of timeseries forecasts and focus on networked, multi-step control problems. Our work is also inspired by Shannon’s rate-distortion theory [4], which describes how to encode and transmit signals with a minimal bit-rate to minimize reconstruction error. In contrast, we work with real numbers rather than bits and focus on reducing the dimension of data while keeping task-specific control cost low.
Prior work has addressed rate-distortion tradeoffs for networked LQR control problems [5– 7]. However, these works focus on ensuring closed-loop stability for a remote controller and a physically-separated plant, such as in teleoperation. Our problem is fundamentally dif-
ferent, since we address how external timeseries forecasts can enhance a controller’s local decisions using full knowledge of its own internal state. While the term co-design appears in select work on networked LQR, it refers to a drastically different setting where a communication scheduler and tele-operated controller must be jointly designed [8–11]. Moreover, event-triggered control/learning [12–15] emphases temporal sparsity of communications, while in our setting the MPC controller consistently requires a forecast of timeseries. Finally, our work differs from deep neural network (DNN) compression schemes for video inference [16, 17] since we focus on control.
More discussions will follow in Sec. 2 after the technical problem is introduced in detail.
Contributions: In light of prior work, our contributions are three-fold. First, we introduce a novel problem for learning compressed timeseries representations that are tailored to control. Second, to gain insights into our problem, we contribute analytic compression results for LQR control. These insights serve as a foundation for our general algorithm that computes the sensitivity of a model predictive controller (MPC) to prediction errors, which guides learning of concise forecast representations. Third, we learn representations that improve control performance by > 25% and are 80% smaller than those generated by standard autoencoders, even for real IoT sensor data we captured on embedded devices as well as benchmark electricity and cell datasets.
Organization: In Sec. 2, we formalize a general problem of compression for networked control and provide analytical results for LQR. Then, in Sec. 3, we contribute an algorithm for task-driven data compression for general MPC problems. We demonstrate strong empirical performance of our algorithm for cell, energy, and IoT applications in Sec. 4 - 5 and conclude in Sec. 6.

heading: 2 Problem Formulation
text: We now describe the information exchange between a generator of timeseries data, henceforth called a forecaster, and a controller, as shown in Fig. 1. Both systems operate in discrete time, indexed by t, for a time horizon of T steps. The notation ya:b denotes a timeseries y from time a to b.
Forecast Encoder: The forecaster measures a high-volume timeseries st ∈ Rp. Timeseries s is drawn from a domain-specific distribution D, such as cell-demand patterns, denoted by s0:T−1 ∼ D.
A differentiable encoder maps the past W measurements, denoted by st−W+1:t, to a compressed representation φt ∈ RZ , using model parameters θe: φt = gencode(st−W+1:t; θe). Typically, Z p and is referred to as the bottleneck dimension since it limits the communication data-rate and how many floating-point values are sent per unit time.
Forecast Decoder: The compressed representation φt is transmitted over a bandwidth-constrained communication network, where a downstream decoder maps φt to a forecast ŝt:t+H−1 for the next H steps, denoted by: ŝt:t+H−1 = gdecode(φt; θd), where θd are decoder parameters. Importantly, we decode representation φt into a forecast ŝ so it can be directly passed to a model-predictive controller that interprets ŝ as a physical quantity, such as traffic demand. The encoder and decoder jointly enable compression and forecasting by mapping past observations to a forecast via bottleneck φt.
Modular Controller: The controller has an internal state xt ∈ Rn and must choose an optimal control ut ∈ Rm. We denote the admissible state and control sets by X and U respectively. The system dynamics also depend on external timeseries st and are given by: xt+1 = f(xt, ut, st), t ∈ {0, · · · , T − 1}. Importantly, while state xt depends on exogenous input st, we assume st evolves independently of xt and ut. This is a practical assumption in many networked settings. For example, the demand st for taxis might mostly depend on city commute patterns and not an operator’s routing decisions ut or fleet state xt. Ideally, control policy π chooses a decision ut based on fully-observed internal state xt and perfect knowledge of exogenous input st:t+H−1: ut = π(xt, st:t+H−1; θc), where θc are control policy parameters, such as a feedback matrix for LQR. However, in practice, given a possibly noisy forecast ŝt:t+H−1, it will enact a control denoted by ût = π(xt, ŝt:t+H−1; θc), which implicitly depends on the encoder/decoder parameters θe, θd via the forecast ŝ.
Control Cost: Our main objective is to minimize end-to-end control cost Jc, which depends on initial state x0 and controls û0:T−1, which in turn depend on the forecast ŝ0:T−1. For a simpler notation, we use bold variables to define the full timeseries, i.e., u := u0:T−1, s := s0:T−1, û := û0:T−1 and ŝ := ŝ0:T−1. The control cost Jc is a sum of stage costs c(xt, ût) and terminal cost cT (xT ): Jc(û;x0, s) = cT (xT )+ ∑T−1 t=0 c(xt, ût), where xt+1 = f(xt, ût, st), t ∈ {0, · · · , T −1}. Importantly, the above plant dynamics f evolve according to true timeseries st, but controls ût are enacted with possibly noisy forecasts ŝt.
Forecasting Errors: In practice, a designer often wants to visualize decoded forecasts ŝ to debug anomalies or view trends. While our principal goal is to minimize the control errors and cost associated with forecast ŝ, we allow a designer to optionally penalize mean squared prediction error (MSE). This penalty incentivizes a forecast ŝt to estimate the key trends of st, serving as a regularization term: JF(s, ŝ) = 1T ∑T−1 t=0 ||st − ŝt||22.
Overall Weighted Cost: Given our principal objective of minimizing control cost and optionally penalizing prediction error, we combine the two costs using a user-specified weight λF. Importantly, we try to minimize the additional control cost Jc(û;x0, s) incurred by using forecast ŝ instead of true timeseries s, yielding overall cost:
J tot.(u, û, s, ŝ;x0, λ F) =
1
T ( Jc(û;x0, s)− Jc(u;x0, s)︸ ︷︷ ︸
extra control cost
) + λFJF(s, ŝ). (1)
The total cost implicitly depends on controller, encoder, and decoder parameters via controls u and û and the forecast ŝ. Having defined the encoder/decoder and controller, we now formally define the problem addressed in this paper. Problem 1 (Data Compression for Cooperative Networked Control). We are given a controller π(; θc) with fixed, pre-trained parameters θc, fixed bottleneck dimension Z, and perfect measurements of internal controller state x0:T . Given a true exogenous timeseries s0:T−1 drawn from data distribution D, find encoder and decoder parameters θe, θd to minimize the weighted control and forecasting cost (Eq. 1) with weight λF:
θ∗e , θ ∗ d = argmin
θe,θd
Es0:T−1∼D[J tot.(u, û, s, ŝ;x0, λF)], where
φt = gencode(st−W+1:t; θe), φt ∈ RZ
ŝt:t+H−1 = gdecode(φt; θd),
ût = π(xt, ŝt:t+H−1; θc), ut = π(xt, st:t+H−1; θc), xt+1 = f ( xt, ût, st), and xt ∈ X , ût ∈ U , t ∈ {0, · · · , T − 1}.
Technical Novelty and Practicality of our Co-design Problem:
Having formalized our problem, we can now articulate how it differs from classical networked control and tele-operation [18–20, 6, 5], compressed sensing [21, 22], and certainty-equivalent control [23, 24]. First, we can not readily apply the classical separation principle [25] of Linear Quadratic Gaussian (LQG) control, which proscribes how to independently design a timeseries estimator, such as the Kalman Filter [26], and a “certainty-equivalent” controller (the linear quadratic regulator) for optimal performance. This is because the timeseries owner measures a non-stationary timeseries st (e.g. spatiotemporal cell demand patterns), without an analytical process model for standard Kalman Filtering, motivating our subsequent use of learned DNN forecasters. Second, due to data-rate constraints, we must prioritize task-relevant features as opposed to equally weighting and sending the full ŝt, which a classic state observer in LQG would do.
Moreover, even when the estimator and controller are separated by a bandwidth-limited network and the separation principle does not hold [27], our setting still differs from classical networked control [18–20, 6, 5]. These works assume that both the full plant state xt and controls ut are encoded and transmitted between a remote controller and plant. In stark contrast, the only transmitted data in our setting is external information st from a network operator, which can improve an independent controller’s local decisions ut based on its internal state xt. As such, simply grouping controller state xt and network timeseries st into a joint state for classical tele-operation is infeasible, since xt and st are measured at different locations by different entities. In essence, Prob. 1 formalizes how a network operator can provide significant value to an independent controller by judicious data sharing.

heading: 3 Forecaster and Controller Co-design
text: Prob. 1 is of wide scope, and can encompass both neural network forecasters and controllers. For intuition, we first provide analytical results for an input-driven LQR problem in Sec. 3.1. We then use such insights in a general learning algorithm that scales to DNN forecasters in Sec. 3.2.

heading: 3.1 Input-Driven Linear Quadratic Regulator (LQR)
text: We first consider a simple instantiation of Prob. 1 with linear dynamics2, no state or control constraints, and a quadratic control cost. Since the dynamics have linear dependence on the exogenous input s, we refer to this setting as an input-driven LQR problem. We first analyze the problem when controls are computed for the full-horizon from t = 0 to T = H and then extend to receding-horizon control (MPC) in Sec. 3.2. The dynamics and control cost are:
xt+1 = Axt +But + Cst, (2)
Jc = H∑ t=0 x>t Qxt + H−1∑ t=0 u>t Rut, (3)
where Q,R are positive definite. Our first step is to determine the optimal control. Given the linear dynamics, for all times i ∈ {0, · · · , H − 1}, each xi+1 is a linear function of initial condition x0 and the full future control vector u and s:
xi+1 = A i+1x0 + Miu + Nis, where (4)
Mi = [ AiB Ai−1B · · · B 0 ] ∈ Rn×mH ,Ni = [ AiC Ai−1C · · · C 0 ] ∈ Rn×pH .
Therefore, given x0 and vector s, control cost Jc is a quadratic function of u:
Jc(u;x0, s) = u >(R + H−1∑ i=0
M>i QMi︸ ︷︷ ︸ K )u + 2[
H−1∑ i=0
M>i Q(A i+1x0 + Nis)︸ ︷︷ ︸
k(x0,s)
]>u + constant,
(5)
2Transition noise is not added here due to certainty equivalence of input-driven LQR, as shown in Appendix Sec. A.2.
where the constant of ∑H−1 i=0 (A i+1x0 + Nis) >Q(Ai+1x0 + Nis) is independent of u, and R = blockdiag(R, · · · , R) ∈ RmH×mH . Clearly, K is positive definite and Jc is strictly convex. Given the convex quadratic cost, the optimal control is u∗, where u∗ = −K−1k(x0, s). However, given a possibly noisy forecast ŝ, we would instead plan and enact controls denoted by û, where û = −K−1k(x0, ŝ). Thus, the sensitivity of such controls to forecast errors is:
û− u∗ = −K−1(k(x0, ŝ)− k(x0, s)) = −K−1 ( H−1∑ i=0
M>i QNi)︸ ︷︷ ︸ L (̂s− s), (6)
and the sensitivity of the control cost to forecast errors is:
Jc(û;x0, s)−Jc(u∗;x0, s) = (û− u∗)>K(û− u∗) = (̂s− s)> L>K−1L︸ ︷︷ ︸ co-design matrix Ψ (̂s− s), (7)
where we term the positive semi-definite co-design matrix Ψ = L>K−1L. We now combine the extra control cost and prediction error to calculate the total cost as:
J tot. = 1
H ( (̂s− s)>Ψ(̂s− s)︸ ︷︷ ︸
extra control cost +λF (̂s− s)>(̂s− s)︸ ︷︷ ︸ prediction error
) = 1
H
( (̂s− s)>(Ψ + λFI)(̂s− s) ) . (8)
The above expression leads to an intuitive understanding of co-design. The co-design matrix Ψ in Eq. 7 essentially weights the error in elements of ŝ based on their importance to the ultimate control cost. Thus, our approach is fundamentally task-aware since the co-design matrix depends on LQR’s dynamics, control, and cost matrices as shown in Eq. 6 and 7. The optional weighting of prediction error with λF acts as a regularization term. Moreover, we now show that we can reduce input-driven LQR to a low-rank approximation problem, which allows us to find an analytic expression for an optimal encoder/decoder.
Input-Driven LQR is Low-Rank Approximation. Given the above expressions for the total cost, we now assume a simple parametric model for the encoder and decoder to formally write Prob. 1 for the toy input-driven LQR setting. Specifically, we assume a linear encoder E ∈ RZ×pH maps true exogenous input s to representation φ = Es, where φ ∈ RZ . Then, linear decoder matrix D ∈ RpH×Z yields decoded timeseries ŝ = Dφ = DEs. In practice, we often have a training dataset consisting of N samples of exogenous input s drawn from a data distribution s ∼ D. These samples can be arranged as columns in a matrix S ∈ RpH×N . To learn an encoder E and decoder D from N samples S at once, we can express our problem as:
argmin D,E N∑ i=1 (Ŝi − Si)>(Ψ + λFI)(Ŝi − Si), where
Ŝ = DES, rank(D) ≤ Z and rank(E) ≤ Z, (9)
where Si and Ŝi represent the i-th column vector of S and Ŝ. We now characterize the input-driven LQR problem. Proposition 1 (Linear Weighted Compression). Input-driven LQR (Eq. 9) is a low-rank approximation problem, which admits an analytical solution for an optimal encoder and decoder pair (E,D).
Proof. We first re-write the objective of the input-driven LQR problem (Eq. 9) as: ∑N i=1(Ŝi − Si) >(Y ΛY >)(Ŝi − Si) = ||Λ 1 2Y >Ŝ − Λ 12Y >S||2F , where Y ΛY > is the eigen-decomposition of the positive definite matrix Ψ + λFI and ||.||F represents the Frobenius norm of a matrix. Thus, the problem can be written as:
argmin D,E ||Λ 12Y >DES︸ ︷︷ ︸ approximation −Λ 12Y >S︸ ︷︷ ︸ original ||2F , where rank(D) ≤ Z and rank(E) ≤ Z, (10)
which is the canonical form of a low-rank approximation problem. By the Eckhart-Young theorem, the solution to the input-driven LQR problem (Eq. 10) is the rank Z truncated singular value decomposition (SVD) of original matrix Λ 1 2Y >S, denoted by UΣV >. In the truncated SVD,
U ∈ RpH×Z is semi-orthogonal, Σ ∈ RZ×Z is a diagonal matrix of singular values, and V ∈ RN×Z is semi-orthogonal. Further, an encoder of E = U>Λ 1 2Y > and decoder of D = (Λ 1 2Y >)−1U solve the problem since:
Λ 1 2Y >DES︸ ︷︷ ︸ approximation = Λ 1 2Y > (Λ 1 2Y >)−1U︸ ︷︷ ︸
D
U>Λ 1 2Y >︸ ︷︷ ︸ E S = U(U>Λ 1 2Y >S) = UΣV >︸ ︷︷ ︸ optimal rank Z approximation .
A similar analysis for a linear encoder-decoder structure for networked inference, not control, is presented in [17]. The key difference from our current paper is our problem setup is for control, not networked inference. Moreover, our result differs from existing LQR literatures with exogenous input, such as [28], since our exogenous input st is subject to to a network bottleneck and encoder/decoder, which is the crux of our Prob. 1; and our total cost includes the extra control cost due to mis-estimation of st, rather than simply the prediction error of st.
Compression benefits: Casting input-driven LQR as low-rank approximation provides significant intuition. As shown in Proposition 1, the optimal encoder/decoder depend on the truncated SVD of Λ 1 2Y >S, which takes into account the control task via the co-design matrix, importance of prediction errors via λF, and statistics of the input via S. We achieved strong compression benefits for simulations of input-driven LQR (provided in supplement Fig. 5 due to space limits).
Transitioning to Model Predictive Control (MPC). In practice, we often have forecasts for a short horizon H < T . Then, starting from any state xt, MPC will plan a sequence of controls ût:t+H−1, enact the first control ût, and then re-plan with the next forecast. If we replace the horizon to H < T in the input-driven LQR analysis in Sec. 3.1, u∗ = −K−1k(x0, s) gives the optimal control for a short-horizon H and we can encode/decode using a low rank approximation as in Prop. 1. While the performance is not necessarily optimal for the full duration T , MPC performs extremely well in practice, yielding even better compression gains, as shown in the supplement (Fig. 6).
Algorithm 1 Compression Co-design for Control
1: Set forecast weight λF, bottleneck size Z 2: Initialize encoder/decoder parameters θ0e , θ 0 d
randomly, and fix controller parameters θc 3: for τ ← 0 to Nepoch − 1 do 4: Initialize Controller State x0 ∈ X 5: for t ← 0 to T − 1 do 6: Encode φt = gencode(st−W+1:t; θτe ) 7: Decode ŝt:t+H−1 = gdecode(φt; θτd) 8: Enact ût = π(xt, ŝt:t+H−1; θc) 9: Propagate xt+1 ← f(xt, ût, st)
10: ut = π(xt, st:t+H−1; θc) (For Training Only) 11: end for 12: θτ+1e , θ τ+1 d ←
BACKPROP [ J tot.(u, û, s, ŝ;x0, λ F) ]
13: end for 14: Return learned parameters θNepoche , θ Nepoch d
We also note a practitioner can adopt a simple cost function based on MPC that complements Eq. 1. The MPC controller π will optimize the cost J tot. given a short-horizon forecast ŝt:t+H−1, but only enact the first control ût = π(xt, ŝt:t+H−1; θc). Meanwhile, the best first control MPC can take is ut = π(xt, st:t+H−1; θc) with perfect knowledge of s for horizonH . Thus, our insight is that we can penalize the errors in enacted controls ût during training and regularize for prediction error, using cost: 1T (∑T−1 t=0 ||ût−ut||22+λF||ŝt−st||22 ) . In our experiments, we observed strong performance by optimizing for the cost Eq. 1, as well as the above cost, which optimizes J tot. over a short-horizon for MPC. We now crystallize these insights from input-driven LQR into a formal algorithm that applies to data-driven MPC.
3.2 Algorithm to Co-design Forecaster and Controller
For more complex scenarios than LQR, it is challenging to provide analytical forms of an optimal encoder and decoder. Thus, we present
a heuristic algorithm to solve Prob. 1 in Algorithm 1. Our key technical insight is that, if the encoder, decoder, and controller are differentiable, we can write:
∇J tot.(u, û, s, ŝ;x0, λF) ∇θe = ∇J tot.(u, û, s, ŝ;x0, λF) ∇(̂s− s) × ∇(̂s− s) ∇θe , (11)
and likewise for θd. The first term captures the sensitivity of the control cost with respect to prediction errors and the second propagates that sensitivity to the forecasting model. Crucially, the gradient of J tot. can be obtained from recent methods that learn differentiable MPC controllers [29, 30].
In lines 1-2 of Alg.1, we randomly initialize the encoder and decoder parameters and set the latent representation size Z to limit the communication data-rate. Then, we enact control policy rollouts in lines 3-11 for Nepoch training epochs, each of duration T . We first encode and decode the forecast ŝ (lines 6-7) and pass them to the downstream controller with fixed parameters θc (lines 8-10). During training, we calculate the loss by comparing the optimal weighted cost with true input s and the forecast ŝ. In turn, this loss is used to train the differentiable encoder and decoder through backpropagation in line 12. Finally, the learned encoder and decoder (line 14) are deployed.
Co-design Algorithm Discussion: A few comments are in order. First, true input s is only needed during training, which is accomplished at a single server using historical data to avoid passing large gradients over a real network. Then, we can periodically re-train the encoder/decoder during online deployment. Second, our approach also applies when θc are parameters of a deep reinforcement learning (RL) policy. However, since the networked systems we consider have well-defined dynamical models, we focus our evaluation on model-based control.

heading: 4 Application Scenarios
text: We now describe three diverse application scenarios addressed in our evaluation. The scenarios are linear MPC problems with box control constraints:
xt+1 = xt + ut − st, (Dynamics) where umin ≤ ut ≤ umax. (Constraints) (12) Our scenarios have the same state and control dimensions m = n, and dynamics/control matrices A = B = In×n indicate uniform coupling between controls and the next state. Finally, we have actuation limits umin and umax. The cost function incentivizes regulation of the state xt to a set-point L. In practice, we often want to penalize states below the set-point, such as inventory shortages where xt < L, more heavily than those above, such as excesses. In the following cost, weights γe, γs, γu ∈ R+ govern excesses, shortages, and controls ut respectively:
Jc(x,u) = T∑ t=0 (γe||[xt − L]+||22 + γs||[L− xt]+||22) + T−1∑ t=0 γu||ut||22, (13)
where [x]+ represents the positive elements of a vector. We focus on linear MPC with box constraints and a flexible quadratic cost (Eq. 13) since it is a canonical problem [31, 32] with wide applications in networked systems. However, to show the generality of co-design, we provide strong experimental results for a mobile video streaming application with noisy, non-linear dynamics in Sec. 5.2. We evaluate diverse MPC settings coupled with an array of neural network forecasters.
Smart Factory Regulation with IoT Sensors: We consider an idealized scenario similar to datacenter temperature control [33], where xt ∈ Rn represents the temperature, humidity, pressure and light for n4 machines in a smart factory, each of whose 4 sensor measurements we want to regulate to a setpoint of L. External heat, humidity, and pressure disturbances s ∈ Rp add to state xt in the dynamics (Eq. 12). Disturbances are measured by p = n IoT sensors, such as from nearby heating units. Our objective is to select control inputs u ∈ Rm to regulate the environment anticipating disturbances s from the p IoT sensors. The cost function (Eq. 13) has γe = γs = γu = 1 to equally penalize deviation from the set-point and regulation effort. Finally, we collected two weeks of stochastic timeseries of temperature, pressure, humidity, and light from the Google Edge Tensor Processing Unit (TPU)’s environmental sensor board for our experiments, as detailed in the supplement.
Taxi Dispatch Based on Cell Demand Data: In this scenario, state xt ∈ Rn represents the difference between the number of free taxis and waiting passengers at n city sites, so xt > 0 represents idling taxis while xt < 0 represents queued passengers. Control ut ∈ Rm represents how many taxis are dispatched to serve queued passengers. Exogenous input st ∈ Rp represents how many new passengers join the queue at time t. Of course, the taxi service has a historical forecast of st, but the cellular operator can use city-wide mobility data to improve the forecast. Our goal is to regulate xt to L = 0 to neither have waiting passengers nor idling taxis. In the cost function (Eq. 13), we have γe = 1, γs = 100 and γu = 1 to heavily penalize customer waiting time for long queues. Our simulations use 4 weeks of stochastic cell demand data from Melbourne, Australia from [34].
Battery Storage Optimization: Our final scenario is inspired by a closely-related work to ours [3], who consider how a single battery must be charged or discharged based on electricity price forecasts. Since our setting involves a vector timeseries s, we consider electrical load forecasts from multiple markets. Thus, we used electricity demand data from the same PJM operator as in [3], but from multiple markets in the eastern USA [35]. Specifically, state xt ∈ Rn represents the charge on n batteries and control ut ∈ Rm represents how much to charge the battery to meet demand. Timeseries st ∈ Rp represents the demand forecast at the locations of the n batteries, where p = n. In the cost function (Eq. 13), we desire a battery of total capacity 2L to reach a set-point where it is half-full, which, as per [3], allows flexibly switching between favorable markets. Further, we set γe = γs = γu = 1.

heading: 5 Evaluation
text: The goal of our evaluation is to demonstrate that our co-design algorithm achieves near-optimal control cost, but for much smaller representations Z compared to task-agnostic methods.
Metrics. We evaluate the following metrics: 1) We quantify the control cost for various bottleneck sizes Z, relative to the optimal cost when ground-truth input s is shared without a network bottleneck. 2) To quantify the benefits of sending a representation of size Z compared to the full forecast ŝt:t+H−1 of size pH , we define the compression gain as pHZ . We also compare the minimum bottleneck Z required to achieve within 5% of the optimal cost for all benchmarks. 3) Since the objective of Prob. 1 also incorporates prediction error, we quantify the MSE forecasting error for various Z.
Algorithms and Benchmarks. We test the above metrics on the following algorithms, which represent various instantiations of Alg. 1 for different λF as well as today’s prevailing method of optimizing for prediction MSE. Our algorithms and benchmarks are: 1) Fully Task-aware (λF = 0): We co-design with λF = 0 according to Alg. 1 to assess the full gains of compression. 2) Weighted: We instantiate Alg. 1 with λF > 0 to assess the benefits of task-aware compression as well as forecasting errors induced by compression. In practice, λF is user-specified. For visual clarity, we show results for λF = 1 in Fig. 2 since the trends for other λF mirror those in Fig. 5. 3) Task-agnostic (MSE): Our benchmark learns a forecast ŝ to minimize MSE prediction error, which is directly passed to the controller without any co-design.
Forecaster and Controller Models. We compared forecast encoder/decoders with long short term memory (LSTM) DNNs [36] and simple feedforward networks. We observed similar performance for all models, which we hypothesize is because co-design needs to represent only a small set of control-relevant features. We used standard DNN architectures, hyperparameters, and the Adam optimizer, as further detailed in the supplement. Our code and data are publicly available at https: //github.com/chengjiangnan/cooperative_networked_control.

heading: 5.1 Linear Dynamics
text: We now evaluate our algorithms on the IoT, taxi scheduling, and battery charging scenarios described in Sec. 4. Our results on a test dataset are depicted in Fig. 2, where each column corresponds to a real dataset and each row corresponds to an evaluation metric, as discussed below.
How does compression affect control cost? The first row of Fig. 2 quantifies the control cost Jc for various compressed representations Z. The optimal cost, in a dashed black line, is an unrealizable lower-bound cost when the controller is given the true future st:t+H−1 without any forecast error. The vertical bars show the distribution of costs across several test rollouts, each with different timeseries s. Our key result is that our task-aware scheme (orange) achieves within 5% of the optimal cost, but with a small bottleneck size Z of 4, 4 and 2 for the IoT, traffic, and battery datasets, respectively. This corresponds to an absolute compression gain of 15×, 15×, and 96× for each dataset. In contrast, with the same bottleneck sizes, a competing task-agnostic scheme (blue) incurs at least 25% more control cost than our method.
Moreover, for the IoT and battery datasets, the task-agnostic benchmark requires a large bottleneck of Z = 35 and Z = 11, leading our approach to transmit 88% and 82% less data respectively. Strikingly, even for a large representation of Z = 60, a task-agnostic scheme incurs 100% more cost than the optimal for the cell traffic dataset. This is because the cost function is highly sensitive to shortages with γs γe, which is not captured by simply optimizing for mean error. To clearly see the trend
in Fig. 2, we only plot until Z = 9, but ran the experiments until Z = 60. Our weighted approach (green) requires a marginally larger representation than the purely task-aware approach (λF = 0) since it should minimize both control and forecast error.
Does co-design reduce control errors? We now investigate how the compression benefits of codesign arise. Given the stochastic nature of all our real world datasets, all prediction models inevitably produce forecasting error, which in turn induce errors in selecting controls. However, the key benefit of co-design methods is they explicitly model and account for how MPC chooses controls based on noisy forecasts ŝ, and are thus able to minimize the control error, which we now quantify.
As defined in Sec. 3.1, for any state xt, ut is the optimal first MPC control given perfect knowledge of st:t+H−1, while ût is MPC’s actual enacted control given a noisy forecast. Then, the control errors across various control dimensions i are the MSE error ||ut(i) − ût(i)||22 between optimal control ut(i) and ût(i). The second row of Fig. 2 clearly shows that our task-aware and weighted methods (orange and green) achieve lower control error on all three datasets.
Why does co-design yield task-relevant forecasts? To further show that our co-design approach reduces forecasting error for the purposes of an ultimate control task, we show forecasting errors across various time horizons in the third row of Fig. 2. As argued in the previous section, all forecasting models produce prediction error. However, a task-agnostic forecast (blue) roughly equally distributes prediction error across the time horizon t to t+H − 1. In stark contrast, the weighted co-design approach (green) drastically reduces prediction errors in the near future since MPC enacts
the first control ut and then re-plans on a rolling horizon. Of course, the full forecast ŝt:t+H−1 matters to enact control plan ût:t+H−1, but the cost is most sensitive to the initial forecast and control errors in our MPC scenarios. For visual clarity, we present forecast errors of the fully task-aware approach (λF = 0) in the supplement, since the errors are much larger than the other two methods.

heading: 5.2 Nonlinear Dynamics with Transition Noise
text: To illustrate that our co-design approach works well for systems with nonlinear and stochastic dynamics, we also provide a nonlinear example concerning an idealized mobile video streaming scenario. In this application, a mobile video client stores a buffer of video segments and must choose a video quality to download for the next segment of video. The goal is to maximize the quality of video while minimizing video stalls, which occur when the buffer under-flows while waiting for a segment to be downloaded. Here, state xt represents the buffer of stored video segments, control ut is segment quality, and st is network throughput. The nonlinear dynamics are xt+1 = [xt − ut st]+ + Lx + ηt, where represents element-wise division, Lx is the increase in stored video for each download, and ηt is Gaussian transition noise. The cost aims to keep a positive buffer and have high video quality: Jc(x,u) = ∑T t=0 γx||xt − Lx||22 +
∑T−1 t=0 γu||ut − Lu||22.
Fig. 3 clearly shows our approach works quite well for a nonlinear scenario with transition noise, which complements the three linear examples in Sec. 5.1. In the above experiments, the parameters are: T = 60, W = H = 15, m = n = p = 4, γx = 0.25, γu = 1, Lx = 0.5× 1n, Lu = 0.2× 1m. Limitations: Our work does not automatically learn the optimal bottleneck size Z that minimizes control cost nor necessarily learn a human-interpretable latent representation.

heading: 6 Conclusion
text: Society is rapidly moving towards “smart cities” [37, 38], where smart grid and 5G wireless network operators alike can share forecasts to enhance external control applications. This paper presents a preliminary first step towards this goal, by contributing an algorithm to learn task-relevant, compressed representations of timeseries for a control objective. Our future work will center around privacy guarantees that constrain learned representations to filter personal features, such as individual mobility patterns. Further, we want to certify our algorithm does not reveal proprietary control logic or private internal states of the downstream controller. While recent work has addressed how to value datasets for supervised learning [39, 40], a promising extension of our work is to price timeseries datasets for cooperative control in a data-market. Indeed, our ability to gracefully trade-off control cost with data exchange lends itself to an economic analysis.

heading: 7 Funding Disclosure
text: This material is based upon work supported by the National Science Foundation under Grant No. 2133481 and 2133403. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.

Review summaries:
This paper proposes an architecture and gradient-based training for an encoder/decoder scheme to reduce communication of an exogenous signal to a remote optimization-based controller. Such scenarios are given, for example, when a remote location has forecast information (e.g., traffic) that is relevant for an optimization-based controller (e.g., optimal scheduling of taxis). The goal of the paper is to reduce communication of the exogenous, while maintaining reasonable performance. The main idea is to take the control objective into account when training the compression scheme, so that the encoder/decoder is optimized for the task at hand. The claimed contributions are (i) introduction of a novel problem, (ii) analytical results for the LQR case, and (iii) improved performance and compression on real-world data sets.

This paper studies sending compressed representations for cooperative control by creating task-driven representations that are co-designed with the control task. They present theoretical compression results (of LQR being low-rank compression in prop 1) and go on to study non-linear cellular, IoT, and electricity load data settings. The idea, summarized in Algorithm 1, is to parameterize encoders/decoders, use the decoded signal for optimization, and optimize the loss in Eq 8 that includes the control loss and a prediction component.

This paper presents a solution to learn succinct, compressed time-series embeddings, which also considers downstream modular controller’s task objective.  Contributions: 1. novel problem: learning compressed time series representations which are also tailored to the downstream control tasks. 2. Analytic compression results on LQR control for illustrations on the problem. 3. Experiments on real-world datasets