MT-GS: Multi-Timescale Gradient Sliding

• Multi-Timescale Gradient Sliding is a distributed optimization method that updates dual components at user-specified rates, managing heterogeneous communication costs.
• It employs a block-decomposable primal-dual framework to ensure efficient asynchronous updates and to lower synchronization overhead in large-scale networks.
• The approach achieves optimal convergence guarantees, with accelerated variants for strongly convex objectives, making it effective for applications like federated learning and multi-agent control.

Multi-Timescale Gradient Sliding (MT-GS) is a class of optimization algorithms designed for distributed convex (often non-smooth) problems with heterogeneous objective structures and variable communication costs. MT-GS generalizes gradient sliding by allowing different components of the algorithm (typically, dual variables corresponding to groups of agents, subnetworks, or consensus constraints) to be updated at distinct, user-specified rates. This approach enables flexible, communication-efficient optimization while retaining optimal convergence guarantees regarding both accuracy and communication complexity.

1. Problem Formulation and Algorithmic Structure

MT-GS addresses distributed convex optimization problems of the form

$\min_{x \in X} \sum_{v \in V} f_v(x)$

where each local function $f_v$ is convex and potentially non-smooth, and the feasible set $X$ is convex (possibly with structural constraints).

The algorithm is based on a block-decomposable primal-dual saddle-point formulation: $$\min_{X \in \overline{X}} \max_{Y \in \mathbb{R}^n} \left\{ F(X) + \sum_{s=1}^S \langle K_s X, y_s \rangle - \sum_{s=1}^S R_s^*(y_s) \right\}$$ where:

• $K_s$ are linear operators defining decomposition into blocks (e.g., local consensus constraints).
• $R_s$ are convex penalties or barrier terms.
• Dual variables $y_s$ correspond to blocks and are updated each at their own rate.

At each global step, all agent local variables $x_v$ are updated via (mirror) descent steps, but dual blocks $y_s$ are only updated according to their individual schedules (rates $r_s$), enabling asynchrony across blocks. Communication, which is typically expensive, is thus orchestrated across multiple timescales.

The accelerated variant, AMT-GS, extends this framework for $\mu$-strongly convex objectives by employing Nesterov-style acceleration, leveraging weighted averages of iterates and stronger regularization in the primal-dual updates.

2. Multi-Timescale and Block-Decomposable Primal-Dual Updates

The MT-GS framework achieves multi-timescale flexibility via its block-separable dual structure. Each dual block represents a constraint or consensus condition that might reflect a particular subnetwork, geographical region, or logical group within a distributed system.

• Dual updates: Each block $s$ updates its dual variable $y_s$ every $r_s$ iterations of the main loop. The step rate $r_s$ is specified by the user, and $\overline{r}$ (the weighted average update rate across blocks) appears in the algorithm's complexity bounds.
• Selective communication: Only agents involved in the current dual block communicate or synchronize during an update, reducing unnecessary network communication and allowing different network regions to progress asynchronously.
• Gradient sliding: The local variables $x_v$ are updated at each step using a "communication sliding" (CS) subalgorithm, a generalization of the standard gradient sliding method, to amortize expensive communication rounds over multiple computation steps.

This structure makes MT-GS well-suited for real-world distributed environments characterized by variable communication costs or agent/task heterogeneity, such as federated learning, power networks, or multi-robot systems.

3. Complexity Bounds: Communication and Oracle Steps

MT-GS and AMT-GS achieve optimal (or near-optimal) complexity with respect to both the target accuracy $\epsilon$ and the problem structure:

Method	Condition	Communication Rounds	Subgradient Steps
MT-GS	$\mu \geq 0$	$O\left(\tfrac{\overline{r}A}{\epsilon}\right)$	$O\left(\tfrac{\overline{r}}{\epsilon^2}\right)$
AMT-GS	$\mu > 0$	$$O\left(\tfrac{\overline{r}A}{\sqrt{\epsilon\mu}}\right)$$	$O\left(\tfrac{\overline{r}}{\epsilon \mu}\right)$

Parameters:

• $\overline{r}$ – average update rate of dual blocks (reflects asynchronicity/flexibility in the algorithm's schedule).
• $A$ – a function similarity/divergence measure between blocks; quantifies the network's heterogeneity and influences convergence rates.
• $\epsilon$ – accuracy parameter.
• $\mu$ – strong convexity parameter (AMT-GS only).

A key result is that the dependency of communication rounds on $A$ is linear, which matches the information-theoretic lower bounds for such problems and resolves an open question for non-smooth objectives [Arjevani and Shamir 2015].

4. Practical Implications: Flexibility and Optimality

The flexibility of MT-GS arises from its multi-timescale and block design:

• User-tunable schedules: Practitioners can assign update frequencies to different network regions or constraints according to resource availability, communication cost, or task urgency.
• Reduced communication: By updating only subsets of the network at each communication event, MT-GS avoids unnecessary synchronization.
• Deterministic and non-smooth capable: The method is fully deterministic and supports non-smooth (e.g., hinge loss, absolute value) objectives, a setting where many previous optimal algorithms require smoothness or incorporate randomization.
• Memory usage: Each agent (or active dual block) maintains a bounded number of vectors (proportional to its update period), and the total memory requirement is linear in the largest update rate per block.

5. Context Within Distributed Optimization and Comparison to Prior Work

MT-GS and AMT-GS extend and unify several strands of research:

• Gradient sliding for composite optimization: They build on sliding/communication-skipping paradigms [Lan 2016; Lan et al. 2020], adapting them to distributed and multi-block contexts with flexible timescales.
• Theoretical optimality for non-smooth objectives: Previous optimal methods for distributed non-smooth optimization [Arjevani and Shamir 2015] focused on global (synchronous) updates or required stochastic or smooth assumptions. MT-GS achieves the best-known communication and computation rates in a deterministic, multi-block, distributed, non-smooth setting.
• Function similarity exploitation: The linear dependency on $A$ allows MT-GS to adaptively exploit cases where local objectives are similar (reducing synchronization costs) without sacrificing optimal oracle complexity.

A plausible implication is that MT-GS is highly effective in large-scale, real-world distributed systems comprising heterogeneous agents, tasks, or subsystems, especially when communication costs, network topologies, or objective similarities differ across the system.

6. Applications and Future Directions

MT-GS is applicative in a range of large-scale distributed optimization scenarios:

• Federated learning and empirical risk minimization, especially with non-smooth losses or constraints.
• Multi-agent control and coordination in power systems, networks, and decentralized robotics, where communication topology is heterogeneous or hierarchical.
• Signal and sensor fusion, where groups of sensors, agents, or regions may synchronize at different frequencies or reliability levels.
• Resource scheduling and allocation in distributed cloud or edge computing.

Directions for future research include:

• Adaptive estimation or learning of the similarity measure $A$ and optimal update rates $r_s$.
• Further reductions in memory/storage requirements for agents with very large update periods.
• Extension to robustness under communication failures, adversarial settings, or random delays.

7. Summary Table of Key Features

Feature	MT-GS / AMT-GS Approach
Multi-timescale updates	Yes (user-specified, blockwise)
Block-separable dual	Yes
Deterministic, non-smooth	Yes
Optimal comm. complexity	Yes ($O(\overline{r}A/\epsilon)$, linear in similarity)
Acceleration (strong convexity)	Yes (AMT-GS; rate $O(\overline{r}A/\sqrt{\epsilon\mu})$)
Communication flexibility	Blockwise, asynchronous, user-controlled
Memory usage	$O(r_{\max})$ vectors per agent/block
Function similarity exploited	Yes

Multi-Timescale Gradient Sliding thus provides a rigorous, highly flexible, and communication-optimal methodology for distributed convex (possibly non-smooth) optimization, with practical relevance for modern, large, and heterogeneous networks.