Hadrien Hendrikx
email: hadrien.hendrikx@epfl.ch

A principled framework for the design and analysis of token algorithms

We consider a decentralized optimization problem, in which n nodes collaborate to optimize a global objective function using local communications only. While many decentralized algorithms focus on gossip communications (pairwise averaging), we consider a different scheme, in which a "token" that contains the current estimate of the model performs a random walk over the network, and updates its model using the local model of the node it is at. Indeed, token algorithms generally benefit from improved communication efficiency and privacy guarantees. We frame the token algorithm as a randomized gossip algorithm on a conceptual graph, which allows us to prove a series of convergence results for variance-reduced and accelerated token algorithms for the complete graph. We also extend these results to the case of multiple tokens by extending the conceptual graph, and to general graphs by tweaking the communication procedure. The reduction from token to well-studied gossip algorithms leads to tight rates for many token algorithms, and we illustrate their performance empirically.

Introduction

Modern machine learning relies on increasingly large models that train on increasingly large datasets: distributed optimization is thus crucial to scaling the training process. In the centralized paradigm, at the heart of Federated Learning [START_REF] Kairouz | Advances and open problems in federated learning[END_REF], the system relies on a server that aggregates models and gradients, and manages the nodes. Although quite efficient, this setting has several drawbacks: (i) nodes need to trust the server enough to send it sensitive data, (ii) there is a communication bottleneck at the server, which limits scaling and (iii) training stops if the server fails.

In the decentralized setting [START_REF] Boyd | Randomized gossip algorithms[END_REF][START_REF] Cassio | Incremental adaptive strategies over distributed networks[END_REF][START_REF] Shi | Extra: An exact first-order algorithm for decentralized consensus optimization[END_REF][START_REF] Nedic | Achieving geometric convergence for distributed optimization over time-varying graphs[END_REF], nodes are linked by a communication graph, and directly communicate with their neighbours in this graph instead of a central coordinator. This allows for better scaling, and is also more robust since the server is no longer the single point of failure. Yet, due to the lack of coordination, decentralized algorithms often require many peer-to-peer communications compared to centralized ones, and a gain in privacy is not always guaranteed.

Token, or random-walk algorithms [START_REF] Bertsekas | A new class of incremental gradient methods for least squares problems[END_REF][START_REF] Sundhar | Incremental stochastic subgradient algorithms for convex optimization[END_REF][START_REF] Johansson | A randomized incremental subgradient method for distributed optimization in networked systems[END_REF][START_REF] Suhail | Linearly convergent asynchronous distributed admm via markov sampling[END_REF][START_REF] Mao | Walkman: A communication-efficient random-walk algorithm for decentralized optimization[END_REF], work in the following way: a token owns an estimate of the model, "walks" over the graph, and sequentially visits nodes. When the token is held by a node, it updates its model, either by computing a gradient using the node's data, or by using the local model of the node. Then, the token is transmitted (or "jumps") to a new node. Some instanciations of these algorithms can be seen as a middle-point between centralized and decentralized algorithms. Indeed, the token plays the role of a server, since it owns the global model and receives updates from nodes. Yet, the token is no longer attached to a physical node as in the centralized case, but rather exchanged between computing nodes in a decentralized way.

Preprint. Under review.

arXiv:2205.15015v1 [math.OC] 30 May 2022

Besides, unlike standard centralized algorithms, each node may maintain a local parameter and update it using local updates. In that sense, some token algorithms (such as the ones developed in this work) closely resemble local methods, that are very popular in federated learning [START_REF] Mcmahan | Communication-efficient learning of deep networks from decentralized data[END_REF], Stich, 2018[START_REF] Lin | Don't use large mini-batches, use local SGD[END_REF]. The main difference is that instead of exchanging information through periodic exact averaging or gossip steps, communication is ensured through the roaming token. This allows to easily adapt the algorithms to the features of the system, by making either more local steps or more communication steps.

Related work

Many early works study token (or random-walk) algorithms [START_REF] Bertsekas | A new class of incremental gradient methods for least squares problems[END_REF][START_REF] Nedic | Incremental subgradient methods for nondifferentiable optimization[END_REF][START_REF] Sundhar | Incremental stochastic subgradient algorithms for convex optimization[END_REF][START_REF] Johansson | A randomized incremental subgradient method for distributed optimization in networked systems[END_REF]]. Yet, they focus on stochastic (sub)gradients algorithms, and thus lack linear convergence guarantees. The recent literature on token algorithms can be divided into two main lines of work that reflect the two main strengths of token algorithms: communication efficiency and privacy preservation.

Communication efficiency. [START_REF] Mao | Walkman: A communication-efficient random-walk algorithm for decentralized optimization[END_REF] introduce Walkman, a token algorithm based on an augmented Lagrangian method. Walkman works for general graphs and is shown to be communicationefficient provided graphs are well-connected enough. Yet, it only obtains linear convergence on least squares problems. When Walkman uses gradients (instead of proximal operators), it requires a step-size inversely proportional to the square of the smoothness constant of the problem, which is impractical. Variants of Walkman guarantee communication efficiency when walking over Hamiltonian cycles [START_REF] Mao | Walk proximal gradient: An energy-efficient algorithm for consensus optimization[END_REF]. [START_REF] Balthazar | Distributed linear estimation via a roaming token[END_REF] consider the problem of distributed linear estimation, and use a token algorithm to aggregate the measurements of all nodes.

Multiple tokens. When a single token walks the graph, there are no parallel communications. A natural fix to speed up algorithms is to allow multiple tokens to walk the graph in parallel, as recently done by Chen et al. [2022], whose approach is also based on an augmented Lagrangian method.

Privacy Preservation. The favorable privacy guarantees claimed by decentralized algorithms are actually mainly proven for token algorithms. For instance, the Walkman algorithm presented above has also been extended to guarantee privacy preservation [START_REF] Ye | Incremental admm with privacypreservation for decentralized consensus optimization[END_REF]. Besides, [START_REF] Cyffers | Privacy Amplification by Decentralization[END_REF] show that token algorithms satisfy a relaxation of local differential privacy, and match the guarantees offered by a trusted central server. They give a simple algorithm for ring and complete topologies. Similarly, [START_REF] Bellet | Who started this rumor? quantifying the natural differential privacy of gossip protocols[END_REF] study the privacy guarantees of a rumour spreading algorithm, and show that a single token spreading the rumour is optimal, while multiple tokens achieve optimal trade-offs between privacy and speed. In this work, we focus on the convergence guarantees of token algorithms, and leave the privacy preservation guarantees for future work.

Dual Decentralized algorithms. Our framework is based on applying the dual approach for decentralized algorithms [START_REF] Jakovetić | Linear convergence rate of a class of distributed augmented lagrangian algorithms[END_REF][START_REF] Boyd | Distributed optimization and statistical learning via the alternating direction method of multipliers[END_REF] to the analysis of token algorithms. This dual approach leads to very fast algorithms, and in particular [START_REF] Scaman | Optimal algorithms for smooth and strongly convex distributed optimization in networks[END_REF], [START_REF] César A Uribe | A dual approach for optimal algorithms in distributed optimization over networks[END_REF] used it to develop optimal decentralized algorithms. Then, Hendrikx et al. [2019a] showed that it can also be used to accelerate randomized gossip, and used an augmented graph formulation to obtain decentralized variance-reduced extensions [Hendrikx et al., 2019b[START_REF] Hendrikx | An optimal algorithm for decentralized finite sum optimization[END_REF][START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF].

Our contributions

As discussed in the previous section, token algorithms are still rare, and very few algorithms offer linear convergence guarantees, let alone integrating more advanced optimization tricks such as variance reduction or acceleration. Besides, most of the literature focuses on only one token, which is communication-efficient but very slow. In this work, we pave the way for the design and analysis of new efficient token algorithms, and in particular we:

1. Introduce a general framework for designing and analyzing token algorithms.

2. Give a simple algorithm with linear convergence guarantees on complete graphs that match those of both centralized and decentralized (gossip) optimization.

3. Speed up this simple algorithm by using multiple tokens.

4.

Leverage the general framework to analyze variants of the simple token algorithm, such as stochastic gradients with variance reduction and acceleration. The general framework is based on the dual approach for decentralized algorithms [START_REF] Jakovetić | Linear convergence rate of a class of distributed augmented lagrangian algorithms[END_REF][START_REF] Scaman | Optimal algorithms for smooth and strongly convex distributed optimization in networks[END_REF], and in particular [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], and so the algorithmic core similar, namely Bregman coordinate descent (with some adaptations) for the simple and variance-reduced algorithms, and Accelerated Proximal Coordinate Descent [START_REF] Lin | An accelerated randomized proximal coordinate gradient method and its application to regularized empirical risk minimization[END_REF] for the accelerated one.

2 Conceptual graph approach for token algorithms.

Building the conceptual graph

We consider the following distributed problem, where each f i is a local function at node i:

min θ∈R d n i=1 f i (θ) + σ 2 θ 2 . (1)
We assume that each f i is convex and L-smooth over R d , which writes if f i is twice differentiable as 0 ∇ 2 f i (x) L I d , where I d ∈ R d×d is the identity matrix of dimension d. The condition number of this problem is κ = 1 + L/σ. The key idea of this paper is to reduce the analysis of token algorithms to that of standard decentralized gossip algorithms on conceptual graphs. We follow the dual approach for building decentralized optimization algorithms, and rewrite Problem (1) as:

min θ∈R n×d , u∈R n×d , v∈R d , ∀i, θ (i) =u (i) , and u (i) =v i=1 f i (θ (i) ) + nσ 2(n + 1) u (i) 2 + nσ 2(n + 1) v 2 . ( 2
)
To write this reformulation, we have applied the consensus constraints (equality constraints for neighbours) given by the conceptual graph represented in Figure 1 (right). To build this conceptual graph, we add a conceptual node (with its own parameter) corresponding to the token, with local objective nσ • 2 /2(n + 1), and we split all local nodes into a computation part (that contains f i ), and a communication part (that contains nσ • 2 /n(n + 1). Node that the total regularization weight is still nσ/2. Then, all computation nodes are linked to their respective communication nodes, which are themselves linked to the token. Splitting each node between communication and computation part has two benefit: (i) it allows us to use the dual-free trick from [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], and obtain primal updates despite the dual approach, and (ii) it allows to decouple communications and computations. In particular, nodes can perform local steps even when they don't hold the token.

Now that we have defined the framework, it is important to make sure that this corresponds to a token algorithm. Updating the edge between the token and node i at time t in the conceptual graph means that the token jumped to node i at team t. Thus, to ensure the token aspect, we must enforce that if the edge between the token and node i is updated at time t, and the edge between the token and node j is updated at time t + 1, then node j has to be a neighbour of node i (since the token jumped from i to j at time t + 1). We apply the dual approach to Problem (2), which is inherited from the conceptual graph, but the sampling of the edges is ruled by the actual communication graph. In a complete graph, this does not impose any additional constraints, and this is why our convergence results are initially derived in this setting. In arbitrary graphs, this means that the sampling of the edges (and so the coordinate descent algorithm applied to the dual formulation) must follow a Markov Chain,

1 1 3 2 t = 0 t = 0 t = 3 t = 3 t = 1 t = 1 t = 2 t = 2 2 2 3 3 1 1 Computation updates
Communication updates Figure 2: An example execution of the token algorithm on the base graph (left), and the corresponding edges updated in the conceptual graph (right). The sequence is: t = 0: local computation at node 2, t = 1: the token jumps to node 2, t = 2: the token jumps to node 3, t = 4: local computation at node 0. Note that the updates at t = 2 and t = 3 can actually be performed in parallel since they affect different nodes, and that the token updates its estimate with the node it arrives at after each jump.

which leads to considerably harder analyses. In Section 3.4, we present a trick to circumvent this difficulty, which consists in not performing the update step every time the token jumps to a new node.

We will now show that this conceptual graph view allows to efficiently design fast algorithms, by making clear links with dual approaches for decentralized optimization. This will prove especially useful in the next section, when we introduce multiple tokens, variance-reduction and acceleration.

In the basic case (one token, full gradients), Equation (2) resembles the consensus formulation of Walkman [START_REF] Mao | Walkman: A communication-efficient random-walk algorithm for decentralized optimization[END_REF], which is also obtained through a (primal-)dual formulation. Yet, we split each node into two subnodes to allow for local steps, and we can then harness the power of the dual approach for decentralized optimization to significantly improve the base algorithm, as done in Section 3.

Deriving the single token algorithm

Following [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], we take a dual formulation of Problem (2), and apply Bregman block coordinate descent to obtain the simple token algorithm, which corresponds to Algorithm 1 with K = 1. This leads to dual-free updates [START_REF] Lan | An optimal randomized incremental gradient method[END_REF], which are simple to implement. Yet, in [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], all communication edges are sampled at once, which would mean that the token receives updates from all nodes at the same time. This is not possible in our case, so we adapted the Bregman block coordinate descent algorithm to better fit the structure of Problem (2), as detailed in Appendix A.

Algorithm 1 Token Gradient Descent(z 0 )

1: σ = n n+K σ, α = 2K L , η = min σpcomm 2nK , pcomp nα(1+L/σ) , ρ comm = nKη pcomm σ , ρ comp = nαη pcomp . // Init 2: ∀i ∈ [n], θ (i) 0 = -∇f i (z (i) 0 )/σ; ∀k ∈ [K], θ token,k 0 = 0 . // z 0 is arbitrary but not θ 0 . 3: for t = 0 to T -1 do // Run for T iterations 4:
if communication step (with probability p comm ) then

5: Pick i ∼ U([n]), k ∼ U([K])
// Choose next node and token uniformly at random 6:

θ token,k t+1 = θ token,k t -ρ comm (θ token,k t -θ (i) t ) // Token update 7: θ (i) t+1 = θ (i) t + ρ comm (θ token,k t -θ (i) t ) // Local
z (i) t+1 = (1 -ρ comp ) z (i) t + ρ comp θ (i) t // Virtual node update 11: θ (i) t+1 = θ (i) t -1 σ ∇f i (z (i) t+1 ) -∇f i (z (i) t ) // Local update using f i 12: return θ K
Theorem 1 (Token algorithm). For ε > 0, the number of steps required by Algorithm 1 with a single token (K = 1) and p comp = p comm = 1 2 to reach error θ t -θ 2 ≤ ε is of order:

T comp = O κ log ε -1 and T comm = O nκ log ε -1 , ( 3
)
where T comp is the expected number of gradient steps performed by each node, and T comm is the expected number of communication updates (jumps) performed by the token.

Proof sketch. This result follows from the guarantees of Bregman Coordinate Descent applied to a dual reformulation of Problem (2). We need to evaluate the relative strong convexity and directional smoothness constants of the problem, and link them with spectral properties of the conceptual graph, as well as the regularity of the local functions. Details can be found in Appendix B.

Implementation. Algorithm 1 requires sampling updates uniformly at random over the whole system. This can be implemented in a decentralized fashion by sharing a random seed between all nodes. An alternative is that all nodes wake up and perform updates following a Poisson point process.

Communication complexity. The total number of communications is of order O(nκ). This matches the complexity of centralized algorithms, in which the server communicates once with each node at each round, and there are O(κ) rounds in total. Yet, in terms of time, the O(n) centralized communications can take place in parallel provided there is enough bandwidth, whereas when K = 1, the O(n) communications from Algorithm 1 must be sequential.

Computation complexity. In average, each node performs O(κ) local computations, which is the "right" complexity for non-accelerated algorithms. Algorithm 1 is as computationally efficient as standard centralized or decentralized algorithms in this sense. Besides, unlike token exchanges that need to be sequential, nodes can compute local gradient updates in parallel. Therefore, the computation time of Algorithm 1 matches the centralized time. Instead, when using gradients, Walkman [START_REF] Mao | Walkman: A communication-efficient random-walk algorithm for decentralized optimization[END_REF] Theorem 1] requires a step-size proportional to L -2 just for convergence, which would lead to a significantly worse computation complexity of at least O(Lκ).

Sampling variants.

In Algorithm 1, one computation update corresponds to one node performing a gradient update, without any communication involved. Note that by changing the sampling of the dual coordinates, it is possible to design other algorithms algorithms. For instance, we can choose to have nodes perform a local computation only when they receive the token, similarly to Walkman. This would yield a similar rate as the one in Theorem 1, but does not allow for local steps. It would thus not be possible for instance to perform a lot of fast communications, while slow computations take place in parallel. Yet, our framework can also handle this variant (and many others), including with the tricks developed in the next section.

3 Extensions of the single token algorithm

In the previous section, we have introduced the conceptual graph, and showed how it allows to leverage the existing tools from (dual) decentralized optimization to analyze a simple yet already efficient token algorithm. We now demonstrate the flexibility and generality of this framework by introducing, analyzing and combining three important variants of the token algorithm: multiple tokens, variance reduction, and acceleration.

The case of several tokens

When there is a single token walking on the graph, resources are used in an efficient way, and privacy guarantees are strong, but mixing is very slow (up to n times slower in a complete graph for instance). This is due to the fact that there are no parallel communications. One natural solution is to use multiple tokens that walk the graph in parallel. Yet, this is generally harder to analyze and, to the best of our knowledge, there only limited theory on multi-token algorithms, with convergence rates that show actual improvement over single tokens. Our conceptual graph framework allows us to directly extend Theorem 1 to the case of multiple tokens.

To do so, we build a different conceptual graph. Namely, we add one new node for each token, and link all "token nodes" to the actual nodes of the network, as shown in the right part of Figure 3. Then, we apply the dual approach to this new conceptual graph, which has a different topology but which we know how to handle. This is how we obtain Algorithm 1 for the general case of K ≥ 1. Theorem 2 (Multiple tokens). For ε > 0, the number of steps required by Algorithm 1 with 1 ≤ K ≤ n and p comp = p comm = 1 2 to reach error θ token,k t -θ 2 ≤ ε is of order:

T comp = O κ log ε -1 and T comm = O n K κ log ε -1 , ( 4
)
where T comp is the expected number of gradient steps performed by each node, and T comm is the number of jumps performed per token. In particular, the total communication complexity is the same as in Algorithm 1, but now the burden is shared by K tokens that walk the graph in parallel.

Token interactions. In the formulation inherited from Figure 3, tokens interact with nodes, but not between themselves. We can change the formulation to add interactions between tokens by adding edges between them in the conceptual graph. This would mean that the tokens would mix information when they meet. Yet, this would only marginally increase the connectivity of the conceptual graph, and would thus not speedup the algorithm by more than constant factors.

Variance reduction in the finite sum case

We have seen that changing the conceptual graph on which the dual formulation is applied changes the resulting token algorithm. In the previous section, we used this to speed-up communications by having several tokens walk the graph in parallel. We now leverage it to speed-up computations by avoiding local full gradient computations at each node. We now assume that each local objective writes

f i (x) = m j=1 f ij (x).
In this case, each full gradient requires m stochastic gradient ∇f ij computations, so Algorithm 1 requires O(mκ) stochastic gradient in total. Instead, variance reduction techniques [START_REF] Schmidt | Minimizing finite sums with the stochastic average gradient[END_REF][START_REF] Johnson | Accelerating stochastic gradient descent using predictive variance reduction[END_REF][START_REF] Defazio | SAGA: A fast incremental gradient method with support for non-strongly convex composite objectives[END_REF][START_REF] Shalev-Shwartz | Sdca without duality, regularization, and individual convexity[END_REF] only require m + κ s stochastic gradients, where κ s = m j=1 (1 + L ij /σ), where L ij is the smoothness of function f ij . Although mκ = κ s in the worst case (where the ∇f ij are all orthogonal), κ s is generally smaller than mκ, leading to the practical superiority of finite-sum methods.

In our case, we introduce the finite-sum aspect by combining the conceptual graph with an augmented graph formulation [Hendrikx et al., 2019b[START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF]. Instead of splitting each node into 2 parts, containing respectively f i and the regularization part, as in Figure 1, we split it into a star subnetwork, with each f ij linked to the regularization part, as shown if the left part of Figure 3. This new conceptual graph leads to a new algorithm, Token Variance Reduction (TVR), that has the following convergence guarantees: Theorem 3 (Variance Reduction). For ε > 0, the number of steps required by TVR with 1 ≤ K ≤ n and p comp = κs m-1+κs to reach error θ t -θ 2 ≤ ε is of order:

T comp = O (m + κ s ) log ε -1 and T comm = O n K κ s log ε -1 , ( 5
)
where T comp is the expected number of stochastic gradient steps performed by each node, and T comm the number of jumps performed per token. Compared to Theorem 2, the computation complexity goes from mκ stochastic gradients (κ full gradients) to m + κ s , which is generally much smaller.

TVR performs the same communication steps as Algorithm 1, with slightly different computation steps, adapted for the stochastic case: there are now m functions f ij (and so parameters z (ij) ), instead of just one. The full algorithm and the proof of Theorem 3 are detailed in Appendix B.2.

Acceleration

We have seen that the conceptual graph view of token algorithms allows to naturally extend the simple single-token batch algorithm to a multi-token variance-reduced algorithm. We now show that by applying a different optimization algorithm to the same dual formulation, we obtain an accelerated algorithm from the same framework. We refer the reader to Appendix C for details and derivations.

Theorem 4 (Token Accelerated Variance-Reduced). For ε > 0, the number of steps required by Accelerated TVR with 1 ≤ K ≤ n to reach error θ token,k t -θ 2 ≤ ε is of order:

T comp = O (m + √ mκ s ) log ε -1 and T comm = O n K √ κ s log ε -1 (6)
In particular, the dependences on the objective regularity are replaced by their accelerated versions. This matches the optimal complexities from Hendrikx et al. [2021].

Proximal oracles. This algorithm is based on Accelerated Proximal Coordinate Gradient [START_REF] Lin | An accelerated randomized proximal coordinate gradient method and its application to regularized empirical risk minimization[END_REF], Hendrikx et al., 2019b], and thus uses proximal operators of the functions f ij instead of gradients. Yet, this is also the case of Walkman, and it is quite cheap in case the f ij are generalized linear model of the form f ij (θ) = (x ij θ), where : R → R.

Continuized framework. TAVR requires each node to perform local convex combinations at each step. This introduces global synchronization constraints, that we can get rid of using a continuized version of the algorithm [START_REF] Mathieu Even | Continuized accelerations of deterministic and stochastic gradient descents, and of gossip algorithms[END_REF].

General graphs

All the results presented so far are for the complete communication graph, meaning that the token can directly jump from any node to any other, allowing to prove strong convergence rates. We now show how to extend these results to general graphs. To do so, we analyze a slightly different communication procedure: instead of just one jump, each token performs N jumps jumps before averaging with the node it lands at according to Algorithm 1 (lines 6-7). If enough steps are taken, and the underlying Markov Chain is irreducible and aperiodic, then the probability that the token lands at node j from node i after N jumps steps is approximately equal to π (j), where π is the stationary distribution of a random walk over the communication graph. In particular, by allowing multiple steps before performing the actual communication update, all nodes can be reached from all nodes, as in the complete graph case. The actual sampling probabilities pi,t depend on the node at which the token is at time t. Yet, if pi,t is close enough to π (i), we can just adapt the step-sizes in coordinate descent, and obtain convergence regardless. Details can be found in Appendix 3.4 Theorem 5. Assume that matrix W ∈ R n×n defining the token transitions is such that for any π 0 ,

W t π 0 -π ∞ ≤ C(1-γ) t .
Then, if the token jumps O(γ -1 log(C/ηµ)) times before performing an averaging step, the communication complexity of Algorithm 1 (ignoring log factors) is O( nκ γ log ε -1 ). Theorem 3 can be adapated in the same way.

Note that these rates are for uniform stationary distribution π (i) = n -1 for all i ∈ [n]. Rates for non-uniform stationary distributions can also be obtained, and would depend on max i π i /L i , so that the algorithm is still fast if nodes that are visited less frequently have better smoothness.

Comparison with existing decentralized algorithms. Note that decentralized algorithms such as EXTRA [Shi et al., 2015, Li and[START_REF] Li | Revisiting extra for smooth distributed optimization[END_REF] require a total of O(E(κ+γ -1 ) log ε -1 ) communications, where E is the number of edges in the graph. In particular, our token algorithm is more communication efficient even in general graphs as long as either κ or γ -1 is small compared to E/n, the average node degree. Note that this complexity is also better than that of Walkman [START_REF] Mao | Walkman: A communication-efficient random-walk algorithm for decentralized optimization[END_REF], which depends on γ 2 instead of γ, besides proving linear convergence only in limited settings.

Directed graphs time-varying graphs. With the communication-skipping variant, all that matters is that the probability of being at node j after taking O(γ -1 log(ηµ)) steps from node i is close to some π (j) > 0. In particular, this does not imply the reversibility of the Markov Chain used for communications (and so can be used for directed graphs), or even its stationarity.

Experiments

In the previous section, we leveraged the conceptual graph framework to design and analyze several (multi-)token algorithms. We now illustrate their differences in Figure 4. We use a step-size β = 1/L for Walkman, which is much higher than the one from [START_REF] Mao | Walkman: A communication-efficient random-walk algorithm for decentralized optimization[END_REF]. The communication complexity is the total number of token jumps (regardless of the number of tokens), and the computation complexity is the total number of gradients (on single f ij ) computed. Time is obtained by setting τ comp = 1 for computing one individual gradient and τ comm = 10 3 for one communication, so that one communication is faster than computing one full local gradient. For gradient descent (GD), we present 2 variants of the allreduce protocol: all-to-all , which has a high number of communications n(n -1) but small time (1) per step, and ring (sequentially averaging over a directed ring), which has a small number of communication(2n) but high time (2n) per step. Note that a fully centralized implementation would get both small communication complexity (2n) and time (2). Token and TVR respectively refer to the algorithms analyzed in Theorems 2 and 3. EXTRA is a standard decentralized algorithm [START_REF] Shi | Extra: An exact first-order algorithm for decentralized consensus optimization[END_REF]. Additional details can be found in Appendix D.

For the complete graph, all token algorithms have similar communication complexity. This is consistent with our theory, and confirms that using multiple token does not hurt efficiency. We also confirm that the communication complexity of token algorithms is lower than that of all-to-all gradient descent (GD), and comparable to that of the efficient ring GD. Similarly, all batch algorithms have similar computation complexities, with GD and Walkman performing slightly better. TVR is more computationally efficient thanks to the stochastic variance-reduced updates.

In terms of time, the fastest algorithm is all-to-all gradient descent, since it performs all communications in parallel. Algorithm 1 is as fast as ring GD, since both algorithms require O(n) sequential communications, but perform computations in parallel. Walkman is the slowest algorithm in this setting, because it needs to perform both communications and computations sequentially (since it does not use local updates). Note that it would be as fast as the single token algorithm for τ comm ≥ m.

TVR is faster than Algorithm 1 thanks to variance reduction. We also see that using several tokens speeds up TVR (since the communication time dominates), but not Algorithm 1 (for which communication and computation times are of the same order).

For the ring graph, we find that the same token algorithms as for the complete graph are stable (consistently across a wide range of m and n), and so we do not use the skip variant presented in Section 3.4. We observe similar results to the complete graph case, although using multiple tokens now accelerates Algorithm 1 since they allow to compensate for the worse graph connectivity. GD and EXTRA have the same rate in this case (since κ > γ -1 ), and their curves are thus almost indistinguishable.

Conclusion

We have presented a general framework for analyzing token algorithms, and derived several variants such as variance-reduction and acceleration from it. All these token algorithms are competitive with their centralized counterparts in terms of computation and communication complexities. Multiple tokens can be used to increase the level of parallelism, and reduce the communication time.

We have also discussed a reduction from the general case to the complete communication graph case, in which our results are proven. We claim this reduction leads to efficient algorithms for general graphs, although these algorithms seem to waste communications. An important research direction would be to formalize these claims, and directly analyze versions of these algorithms in which tokens exchange information with all the nodes they visit. This would involve tight analyses of coordinate descent with Markov Chain sampling.

Acknowledgements

This work was supported by the Swiss National Foundation (SNF) project 200020_200342.

A Revisiting Bregman Coordinate Descent

The algorithmic core for the non-accelerated methods is based on Bregman Coordinate descent. Yet, the existing theory from [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF] was not satisfactory, as it did not allow to consider stochastic communications: the communication block was sampled all at once, which is not possible in the token approach.

Similarly, in general graphs, we do not know the exact sampling probability pi,t , but an upper bound p i of it. We thus changed the coordinate descent algorithm to also take that into account.

We adapt the result from [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF] to tackle these two problems in this section. First of all, for two vectors x, y ∈ R d , define the Bregman divergence:

D h (x, y) = h(x) -h(y) -∇h(y) (x -y). (7)
In order not to worry about further regularity assumptions, we assume throughout this paper that all the functions we consider are twice continuously differentiable and strictly convex on dom h, and that ∇h(x) = min y h(y) -x y is uniquely defined. This is not very restrictive for typical machine learning objectives. The Bregman divergence has some interesting properties. In particular, D h (x, y) ≥ 0 for all x, y ∈ R d as soon as h is convex.

For i ∈ [d],
we denote e i ∈ R d the unit vector corresponding to coordinate i. Consider the following Bregman coordinate descent algorithm, in which the iterates are given by:

x t+1 = arg min x V i,t (x) = η t p i ∇ i f (x t ) A † Ax + D h (x, x t ) , (8)
where ∇ i f (x t ) = e i e i ∇f (x t ), and A † A is some projection matrix, which is such that A † A∇f (x) = ∇f (x) for all x ∈ R d . An equivalent way to write these iterations is:

∇h(x t+1 ) = ∇h(x t ) - η t p i A † A∇ i f (x t ) (9)
Although we use some p i for the learning rate, we assume that coordinates are sampled according to another distribution, namely, pi,t . In order to make the training stable, we assume that for all i, t, there exist δ i,t > 0 which are such that for all i,

pi,t (1 + δ i,t ) = p i . (10)
In particular, this means that the p i are not a proper probability distribution, since they don't sum to one. We denote ∆ = d i=1 pi,t δ i,t , which is such that 1 + ∆ is normalizing factor of the p i . Similarly, we denote δ = min i,t δ i,t . We denote R i = (A † A) ii and R p = min i R -1 i pi,t . We make the following assumptions on f and h.

Assumption 1 (Regularity assumptions). Function f is µ-relatively strongly convex and L i -relatively smooth in the direction i with respect to h, meaning that for all x, y ∈ R d , and some v i supported by e i :

µD h (x, y) ≤ D f (x, y), and D f (x + v i , x) ≤ L i D h (x + v i , x). ( 11
)
We also make some technical assumptions, that are verified for our problem. In particular, we assume that h and A † A are such that:

∇ i f (x t ) A † A(x t -x (i) t+1 ) = R i ∇f (x t ) (x t -x (i) t+1 ). ( 12
)
Using this assumption, we first prove a technical lemma, which ensures that each step reduces the function value:

Lemma 1 (Monotonicity). Under Assumption 1, if η t ≤ pi LiRi the iterates of Equation ( 8) verify for all i ∈ [d]:

f (x (i) t+1 ) ≤ f (x t ). ( 13
)
Proof. Using Assumption 1 , we have that:

D h (x (i) t+1 , x t ) + D h (x t , x (i) t+1 ) = ∇h(x (i) t+1 ) -∇h(x t ) (x (i) t+1 -x t ) = η t p i ∇ i f (x t ) A † A(x t -x (i) t+1 ) = η t R i p i ∇f (x t ) (x t -x (i) t+1 ) = η t R i p i D f (x (i) t+1 , x t ) -f (x (i) t+1 ) + f (x t ) ≤ η t p i R i L i D h (x (i) t+1 , x t ) -f (x (i) t+1 ) + f (x t ) ≤ D h (x (i) t+1 , x t ) - η t R i p i f (x t ) -f (x (i) t+1 ) ,
where the last line uses that η t ≤ pi LiRi . In particular:

f (x (i) t+1 ) ≤ f (x t ) -D h (x t , x (i) t+1 ) ≤ f (x t ).
Theorem 6. Consider two functions f and h that verify Assumption 1. If the iterates are given by Equation (8), and denoting for any x ∈ dom h,

L t = (1 + δ)D φ (x, x t ) + ηt Rp [f (x t ) -f (x)]
, we obtain for η t ≤ pi LiRi :

L t+1 ≤ max 1 + ∆ -η t µ 1 + δ , 1 -R p L t Note that 1+∆-ηµ 1+δ ≥ 1 -ηµ ≥ 1 -pi Ri µ Li ≥ 1 - (1+δi,t)µ Li
R p , so the first term generally dominates since we generally have (1 + δ i,t )µ ≤ L i unless the condition number is very small, or δ i,t very large.

Proof of Theorem 6. For any x ∈ domh We start by writing the 3 points inequality:

D h (x, x t+1 ) + D h (x t+1 , x t ) -D h (x, x t ) = [∇h(x t ) -∇h(x t+1 )] (x -x t+1 ) = η t p i ∇ i f (x t ) A † A(x -x t+1 ) = η t p i ∇ i f (x t ) (x -x t ) + η t p i ∇ i f (x t ) A † A(x t -x t+1 ).
We now multiply everything by 1 + δ i,t , leading to:

(1 + δ i,t ) [D h (x, x t+1 ) + D h (x t+1 , x t ) -D h (x, x t )] = η t (1 + δ i,t ) p i ∇ i f (x t ) A † A(x -x t ) + η t (1 + δ i,t ) p i ∇ i f (x t ) A † A(x t -x t+1 ),
which we rewrite as:

(1 + δ)D h (x, x t+1 ) ≤ (1 + δ i,t )D h (x, x t ) + η t pi,t ∇ i f (x t ) A † A(x -x t ) + η t pi,t ∇ i f (x t ) A † A(x t -x t+1 ) -(1 + δ i,t )D h (x (i) t+1 , x t ),
In particular, when taking an expectation with respect to the sampling distribution, we obtain:

(1 + δ)E [D h (x, x t+1 )] ≤ d i=1 p i D h (x, x t ) - d i=1 p i D h (x (i) t+1 , x t ) + η t ∇f (x t ) (x -x t ) + d i=1 η t ∇ i f (x t ) A † A(x t -x (i) t+1 ).
Using Assumption 1 leads to:

η t ∇ i f (x t ) A † A(x t -x (i) t+1 ) = η t R i ∇f (x t ) (x t -x (i) t+1 ) = η t R i D f (x (i) t+1 , x t ) -f (x (i) t+1 ) + f (x t ) ≤ η t R i L i D h (x (i) t+1 , x t ) -f (x (i) t+1 ) + f (x t )
Using that η t ≤ pi LiRi , we obtain:

(1 + δ)E [D h (x, x t+1 )] ≤ (1 + ∆)D h (x, x t ) + η t ∇f (x t ) (x -x t ) + d i=1 η t R i -f (x (i) t+1 ) + f (x t ) .
Note that by monotonicity of the iterations (Lemma 1), f (x

(i) t+1 ) ≤ f (x t )
for all t, i, and so, with

R p = min i R -1 i pi,t : d i=1 R i pi,t pi,t -f (x (i) t+1 ) + f (x t ) ≤ R -1 p - d i=1 pi,t f (x (i) t+1 ) + f (x t ) ≤ -R -1 p (E [f (x t+1 )] -f (x t )) (14)
Finally, the µ-relative strong convexity of f gives:

∇f (x t ) (x -x t ) = -[f (x t ) -f (x)] -D f (x, x t ) ≤ -µD h (x, x t ) -f (x t ) + f (x) (15)
Combining everything leads to:

(1 + δ)E [D h (x, x t+1 )] + η t R p [f (x t+1 -f (x)] ≤ 1 + ∆ -ηµ 1 + δ (1 + δ)D h (x, x t ) + η t R p (1 -R p ) [f (x t ) -f (x)]
B Convergence results

B.1 Introducing the problem

In this section, we introduce the consensus problem derived from the conceptual graph, and take its dual formulation. This section follows the same framework as [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF]. Denoting σ = nσ n+K , this problem writes:

min θ∈R n×d , u∈R n×d , v∈R d ∀i, ∀j, θ (ij) =u (i) , ∀k, u (i) =v (j) n i=1 m j=1 f ij (θ (ij) ) + σ 2 u (i) 2 + K k=1 σ 2 v (k) 2 . ( 16
)
Introducing Lagrangian multipliers y for each consensus constraint in the virtual part of the graph (between center nodes u (i) and computation nodes θ (ij) ), and multipliers x for the communication part of the graph, (between center nodes u (i) and tokens v (k) ), the dual problem writes:

min x∈R nKd , y∈R nmd q A (x, y) + n i=1 m j=1 f * ij ((Ay) (ij) ), with q A (x, y) 1 2σ (x, y) A A(x, y), (17)
where A ∈ R (n(m+1)+K)d×n(K+m)d is the (weighted) incidence matrix of the augmented conceptual graph, which is such that Ae 1 2 = µ 1 2 (e 1 -e 2 ), for any two nodes 1 and 2 (and an arbitrary orientation), where e 1 2 is the unit vector corresponding to edge ( 1 , 2 ), and e 1 , e 2 are the unit vectors corresponding to nodes 1 and 2 . Note that we abused notations and wrote (Ay) (ij) instead of (A(x, y)) (ij) , since (A(x, y)) (ij) does not actually depend on x.

Matrix A has a very special structure, since it is the incidence matrix of a tripartite graph between computation nodes, communication nodes, and token nodes. We now have to choose the weights of matrix A. For communication edges (between communication nodes and tokens), we make the simple choice µ ik = 1. For computation edges (between communication nodes and computation nodes), we choose:

µ 2 ij = αL ij , with α = 2σK κ s , (18)
where L ij is the smoothness of function f ij and κ s = max i 1 + m j=1 L ij /σ. These choices follow from [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], where we used that the "communication part" of the conceptual graph used to derive the token algorithm is quite specific (complete bipartite graph), and so λ min (A comm A comm ) = K, the number of tokens, as long as K ≤ n [START_REF] Andries | Spectra of graphs[END_REF].

B.2 The TVR algorithm

We now proceed to the derivation of the DVR algorithm, and to proving its theoretical guarantees. To achieve this, we use the Bregman coordinate descent iterations defined in the previous section, which are of the form:

(x, y) t+1 = arg min x,y η t p i ∇ i [q A ((x, y) t ) + F * (Ay t )] A † Ax + D h ((x, y), (x, y) t ), (19)
where ij) ). We now need to define the reference function h, which we define, following [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], as h(x, y) = h x (x) + h y (y), with: ∀i, j, h (ij) y (y

F * (λ) = i,j f * ij (λ (
(ij) ) = L ij µ 2 ij f * ij (µ ij y (ij) ), and h x (x) = 1 2 x 2 A † comm Acomm , (20)
where n(m+K) is the restriction of A to communication nodes (and tokens). In order to avoid notations clutter, we slightly abuse notations and use A † A instead in the remainder of this section.

A comm ∈ R (n+K)d×(
Algorithm 2 Token Variance Reduced (z 0 )

1: σ = σ n n+K α = 2K σ κs , p comp = 1 + κs m-1+κs -1 , p comm = 1 -p comp
θ token,k t+1 = θ token,k t -ρ comm (θ token,k t -θ (i) t ) // Token update 8: θ (i) t+1 = θ (i) t + ρ comm (θ token,k t -θ (i) t ) //
z (i,j) t+1 = (1 -ρ comp ) z (i,j) t + ρ comp θ (i) t // Virtual node update 12: θ (i) t+1 = θ (i) t -1 σ ∇f ij (z (i,j) t+1 ) -∇f ij (z (i,j) t ) // Local update using f ij 13: return θ K
For the computation part, the algorithm can be recovered by following the exact same steps as Hendrikx et al. [2020, Section 2], which are themselves inspired by the dual-free updates from [START_REF] Lan | An optimal randomized incremental gradient method[END_REF].

For the communication part, there is a small difference in the fact that we do not sample all coordinates at once anymore. Instead, we sample edges of the communication graph one by one. The other difference is that communication edges are not between node i and node k anymore, but between node i and token k. In particular, the communication step writes:

A † Ax t+1 = A † Ax t - η σp ik A † Ae ij e ik A A(x t , y t ). (21)
Multiplying by A on the left and defining θ t = A comm (x t , y t ) leads to:

θ t+1 = θ t - η σp ik A comm e ik e ik A θ t , (22)
where we used the fact that the update only affects communication nodes. Therefore, when we sample an edge between node i and token k, this leads to:

θ t+1 = θ t - ηnK p comm σ W ik θ t , (23)
where W ik = (e i -e k )(e i -e k ) , thus leading to the form obtained in Algorithm 2. From there, we can prove the following convergence theorem, from which all the non-accelerated results from the main text are derived. Theorem 7. The iterates of Algorithm 2 verify:

θ t -θ 2 ≤ 1 - ηK σ κ s t C 0 , (24)
where C 0 = 2σL 0 , with L 0 the Lyapunov function from Theorem 6 instantiated on the dual problem, which thus depends on the initialization. In particular, ignoring log factors in C 0 , if p comm = p comp = 1 2 and for any ε > 0,

T comp = O((m + κ s ) log ε -1 ) and T comm = O(nκ s log ε -1 ) (25
) are required in total in order to obtain θ t -θ 2 ≤ ε.

The proof of this algorithm follows several steps, that we detail in the next subsections. We first show that the objective function defined in Equation ( 16), together with the reference function h defined in Equation ( 20) satisfies Assumption 1, so that we can apply Theorem 6. Then, we show how to choose the remaining parameters (and in particular p comm and p comp ) optimally, and evaluate the rate in terms of constants of the problem (number of nodes, number of tokens, smoothness and strong convexity of the local functions...).

B.3 Verifying Assumption 1

We start by showing that Assumption 1 is verified in this case, which includes three parts: Equation (12), relative strong convexity, and directional relative smoothness.

B.3.1 Verifying Structural assumptions.

We first verify that the updates of our problem verify Equation (12) from Assumption 1.

1 -Computation coordinates. Computation coordinates corresponding to the edge between computation and communication subnodes in Figure 1. In particular, the graph becomes disconnected if they are removed, thus implying that A † Ae i = e i . In particular,

∇h(x t+1 ) = ∇h(x t ) - η t p i ∇ i f (x t ). (26)
Yet, for our specific choice of h (which is such that h

comp (x) = i h comp (i) (x (i) )), this implies that x (i)
t+1 -x t = v i for some v i that only has support on coordinate i, and in particular:

∇ i f (x t ) A † A(x t -x (i) t+1 ) = R i ∇ i f (x t ) v i = R i ∇f (x t ) v i = R i ∇f (x t ) (x t -x (i) t+1 ) (27) 2 -Network coordinates.
Network coordinates have a different structure. In this case, the reference function h comm is the quadratic form induced by A † A, which facilitates analysis. The updates write:

A † Ax t+1 = A † Ax t -A † A η t p i ∇ i f (x t ) (28)
Although h comm is not separable, we can leverage the presence of A † A to write:

∇ i f (x t ) A † A(x t -x (i) t+1 ) = η t p i ∇ i f (x t ) A † A∇ i f (x t ) = η t p i R i ∇f (x t ) ∇ i f (x t ).
We then use that ∇f (x t ) = A † A∇f (x t ), leading to:

∇ i f (x t ) A † A(x t -x (i) t+1 ) = η t p i R i ∇f (x t ) A † A∇ i f (x t ) = R i ∇f (x t ) A † A(x t -x (i) t+1
). Now that we have proven that h and f verify the structural assumptions given by Equation ( 12), it remains to evaluate the relative strong convexity and directional smoothness constants µ and L i .

B.3.2 Relative Strong Convexity.

Since the structure of the dual problem and the reference function h are the same, we directly have from Hendrikx et al. [2020, Appendix B.1] that the relative strong convexity constant is equal to

µ = α 2 = K σ + m j=1 L ij , (29)
since the smallest eigenvalue of the communication graph is equal to K (the number of tokens) in this case.

B.3.3 Directional Relative Smoothness.

We now evaluate the relative smoothness constants.

1 -Computation edges. In the computation case, similarly to strong convexity, we directly get from Hendrikx et al. [2020, Appendix B.1] that Lij , the relative directional smoothness for virtual node i, j (or just Li if there is only one virtual node), can be obtained as:

Lij = α 1 + L ij σ i , (30)
Plugging in the value of α, this leads to:

Lij = 2K σ σ + L ij σ + m j=1 L ij (31)
2 -Communication edges. In this case, we cannot use the results from DVR directly because the sampling of communication coordinates is different. While DVR sampled all communication edges at once, we only sample one at each step. In this case, we have that the directional relative smoothness is equal to:

D f (x+∆ uv , x) = ∆ uv 2 A ΣA = µ 2 uv (σ -1 u +σ -1 v ) ∆ uv 2 = µ 2 uv (σ -1 u + σ -1 v ) e uv A † Ae uv ∆ uv 2 A † A . (32)
In particular, for communication edges, and with the choice that µ 2 uv = 1 and σ u = σ v = σ:

D f (x + ∆ uv , x) ≤ Luv D h (x + ∆ uv , x), with Luv = 2 σR uv (33)

B.4 Convergence guarantees

We have shown in the previous subsection that we can apply Theorem 6 to obtain convergence guarantees for our token algorithms. For the communication edges, the step-size constraint leads to:

η t ≤ p uv R uv Luv = p comm σ 2nK (34)
For the computation edges, we can set (as in the DVR article) p ij ∝ 1 + L ij /σ. In particular, the normalizing factor is equal to

n i=1 m j=1 1 + L ij /σ = n(m + m j=1 L ij /σ) = n(m -1 + κ s )
, where we recall that κ s = 1 + m j=1 L ij /σ. Therefore, we obtain:

η t ≤ p ij Lij ≤ p comp σκ s 2nK(m -1 + κ s ) . ( 35
)
We want to balance p comm and p comp such that these two constraints match, leading to:

p comm = κ s m -1 + κ s p comp . (36)
Since p comm = 1 -p comp , this leads to:

p comp = 1 + κ s m -1 + κ s -1 . ( 37
)
Assuming δ ≥ 0 and ∆ < ηtµ 2 , the rate of convergence of Algorithm 2 is ρ = η t µ -∆ ≥ η t µ/2. In particular, we directly have that the computation complexity is equal to:

p comp ρ = 4(m -1 + κ s ). (38)
Similarly, the communication complexity is equal to:

p comm ρ = 2nκ s . (39)
B.5 Special cases

B.5.1 Complete graphs

All the theorems in the main paper are actually direct corollaries of Theorem 7. We provide below how they can be derived in each case.

Theorem 3: We apply Theorem 7 with δ = 0 (since the graph is complete, so we know the true sampling distribution).

Theorem 2: When m = 1, all the derivations remain the same, but we now have that κ s = 1+L i /σ = κ, and so the computation complexity is equal to m -1 + κ s = κ.

Theorem 1: This result can be recovered by simply taking K = 1.

B.5.2 General graphs.

Consider that the transitions between nodes are ruled by matrix W , which is such that W t π 0π ∞ ≤ C(1 -γ) t for any starting distribution π 0 , with C > 0 a constant, π the stationary distribution of the random walk, and γ > 0 a constant which can be interpreted as the inverse of the mixing time of the Markov Chain with transition matrix W . This is true as long as the underlying Markov Chain is irreducible and aperiodic. In this case, then after O(γ -1 log(C/(ηµ)) steps, we have that for all i:

|p i,t -(π ) i | ≤ ηµ 4 , (40)
so in particular by taking p i = (π ) i + ηµ 4 satisfies pi,t (1 + δ i,t ) = p i , with 0 ≤ δ i,t ≤ ηµ 2 . Then, using Theorem 6, we recover the same result as in Theorem 7, with ηµ replaced by ηµ -∆ ≥ ηµ 2 . Note that the value of η depends on ∆, which itself depends on η, so the above derivations technically result in a circular argument. To avoid this, one can simply use a slightly different η = min i (π )i LiRi ≤ η to set the number of token jumps. In practice, we do not need to precisely evaluate these log factors, and taking Cγ -1 jumps with a small constant C is enough.

C Acceleration

In the accelerated case, the theory does not follow directly from Theorem 7, since the algorithmic core is different. Indeed, we use a variant of Accelerated Proximal Coordinate Gradient [START_REF] Lin | An accelerated randomized proximal coordinate gradient method and its application to regularized empirical risk minimization[END_REF] instead of Bregman coordinate descent on the dual formulation. Yet, we can directly reuse the convergence results for ADFS [Hendrikx et al., 2019b, Theorem 1], which we (informally) state below:

Theorem 8. ADFS has iteration complexity O(ρ log ε -1 ), with

ρ 2 ≤ min k λ + min (A Σ -1 A) Σ -1 kk + Σ -1 ll p 2 k µ 2 k R k . ( 41
)
Batch smoothness. Since the smoothness of the full functions f i is hard to compute, we approximated it by taking L batch = 0.02 × max ij L ij . Note that, following [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], we implemented TVR with this batch smoothness instead of j L ij (which corresponds to taking α = 2σK/κ instead of α = 2σK/κ s ). In particular, the communication complexity of TVR is thus proportional to κ (similarly to that of Algorithm 1) instead of κ s . We proved Theorem 3 with κ s since it is simpler and less restrictive.

Code. We provide the code used to run the experiments from Figure 4 in supplementary material. All algorithms are coded in Python, using MPI for communications. This code has not been optimized for efficiency, but rather aims at providing an actual implementation of token algorithms that can be used out of the box. Due to the similarities between algorithms, we based this code on the code in the supplementary material from [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF].

Figure 1 :

 1 Figure 1: Left: base communication graph. Right: Conceptual graph, with modified local objectives.

Figure 3 :

 3 Figure 3: Conceptual graph of size n = 3 with finite-sum local objectives (m = 3) and multiple tokens (K = 2).

Figure 4 :

 4 Figure 4: Convergence results for a logistic regression task on the RCV1 dataset [Lewis et al., 2004] (d = 47236), with n = 20 nodes, and m = 9841 samples per node.

  1+κs) , ρ comm = nKη pcomm σ , ρ comp = mnαη pcomp . // z 0 is arbitrary but not θ 0 . 4: for t = 0 to T -1 do // Run for T iterations 5:if communication step (with probability p comm ) then6: Pick i ∼ U([n]), k ∼ U([K])// Choose next node and token uniformly at random 7:

  node update

	8:	else
	9:	Pick i ∼ U([n])	// Choose one node at random
	10:

  Local node update

	9:	else
	10:	Pick i ∼ U([n]), j ∼ U([m])	// Choose one node and data point at random
	11:

For our problem (conceptual graph), we obtain the following values for the parameters involved in the computation of ρ when a communication edge (k, ) between a node and the token is sampled:

In the end, this leads to

Similarly, we have (just like in the ADFS paper, since the computation part of the graph is the same):

We now fix p comm and p comp so that ρ comm = ρ comp , similarly to Section B.4. This leads to

and so the communication and computation complexities are respectively:

Theorem 4 is obtained by expressing these complexities in terms of per-node and per-token quantities.

D Experiments

For the experiments, we use the same setting as [START_REF] Hendrikx | Dual-free stochastic decentralized optimization with variance reduction[END_REF], meaning that we solve the following logistic regression problem:

where the pairs (X ij , y ij ) ∈ R d × {-1, 1} are taken from the RCV1 dataset, which we downloaded from https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary.html. We choose the regularization parameter as σ = 10 -5 . All experiments were run on a standard laptop, but using MPI to communicate between nodes.

Time. We choose to report ideal times: to get the execution time of an algorithm, we compute the minimum time it takes to execute its sequence of updates, given fixed communication and computation delays τ comm and τ comp . More specifically, we draw a sequence of actions S, and denote S the -th action from this sequence, and T i ( ) the time at which node i finishes executing update . All nodes start from T i (0) = 0.

• If S is a local computation at node i, then node i increases its local time by τ comp , i.e., T i ( ) = T i ( -1) + τ comp . For j = i, T j ( ) = T j ( -1).

• If S is a token jump from node j to node i, then T i ( ) = max(T i ( -1), T j ( -1)+τ comm ).

The sequence S is implemented by simply sharing a random seed between nodes. Token algorithms could also be implemented without executing this shared schedule, but this would not strictly correspond to Algorithm 2 since the sampling of the edges would not be i.i.d.