Event-Triggered DIGing

Clean Python implementations of event-triggered distributed optimization algorithms based on gradient tracking:

• DIGing for connected undirected weighted networks.
• An improved event-triggered DIGing rule for weighted communication graphs.
• Push-DIGing for strongly connected directed weighted networks.
• An event-triggered Push-DIGing extension using push-sum normalization.

The repository is intentionally code-only: no notebooks, thesis files, generated figures, local file paths, or personal metadata are included.

Motivation

Distributed convex optimization lets a network of agents solve a shared optimization problem while each agent keeps only its local objective. DIGing and Push-DIGing can converge linearly for strongly convex smooth objectives, but their standard forms require every agent to broadcast state information at every iteration.

In many networked systems, communication costs more energy and time than local computation. The event-triggered mechanism implemented here reduces unnecessary broadcasts: an agent communicates only when its current local drift is large enough compared with the last broadcast disagreement stored from its neighborhood.

Core Idea

Each agent stores the most recently broadcast neighbor states. Between events, updates use these stored values instead of requiring fresh real-time communication. For DIGing, the trigger monitors the measurement errors of:

• the decision estimate x
• the gradient-tracking variable y

For Push-DIGing, the trigger also monitors the push-sum normalization state.

The key weighted-graph idea is to scale the neighborhood disagreement threshold by communication weights. This keeps the simple local-trigger structure of earlier event-triggered DIGing rules while making the rule better suited to weighted communication networks.

What This Project Highlights

• Local event decisions: agents can decide whether to broadcast using local measurement errors and the last event-time states of neighbors.
• Weighted graph support: the DIGing trigger incorporates channel weights instead of treating every edge as unweighted.
• Simpler parameter behavior: the trigger avoids a time-decaying threshold that is highly sensitive to global time and initial measurement errors.
• Communication reduction: default simulations show far fewer broadcasts than the fully communicated baselines.
• Convergence-oriented implementation: default examples target smooth strongly convex quadratic objectives, matching the theoretical setting where linear convergence is expected.
• Directed-network extension: the same event-triggering principle is adapted to Push-DIGing on strongly connected directed graphs.

Default Problem

The bundled examples solve a five-agent scalar quadratic optimization problem:

minimize mean_i a_i + b_i * (x - c_i)^2

For the default coefficients, the optimizer is:

x* = 1.25
f(x*) = 0.55

Install

python -m venv .venv
. .venv/bin/activate
python -m pip install -e ".[dev]"

Quick Start

from event_triggered_diging import DigingConfig, DigingEventConfig, run_diging

result = run_diging(
    DigingConfig(
        iterations=2500,
        event=DigingEventConfig(mode="weighted_max", gamma_x=1.0, gamma_y=1.0),
    )
)

print(result.x)
print(result.objective_value)
print(result.complete_iteration)
print(result.communication_count)

Run the default experiments:

python examples/run_default_experiments.py

Run tests:

pytest

Example Output

On the default five-agent problem, the example script reports convergence near x* = 1.25 and f(x*) = 0.55. The event-triggered variants reduce the number of communication events relative to fully communicated baselines, with the usual tradeoff that larger trigger parameters may reduce communication further while changing convergence speed.

Project Layout

src/event_triggered_diging/
  configs.py        Default matrices and objective parameters
  objectives.py     Quadratic objective helpers
  diging.py         DIGing and event-triggered DIGing
  push_diging.py    Push-DIGing and event-triggered Push-DIGing
  results.py        Shared result container
tests/
  test_algorithms.py
examples/
  run_default_experiments.py

Notes

The implementation is intended as a readable research reference and simulation scaffold. It focuses on deterministic NumPy implementations of the algorithmic updates, event-triggered communication logic, and default reproducible experiments.