Enum TrainingStrategy 

#[non_exhaustive]
pub enum TrainingStrategy {
    Local,
    DataParallel {
        num_replicas: usize,
        aggregation: GradientAggregation,
    },
    ModelParallel {
        partitions: Vec<Partition>,
        communication: CommunicationProtocol,
    },
    Federated {
        num_clients: usize,
        rounds: usize,
        aggregation: FederatedAggregation,
        client_selection: ClientSelection,
    },
    PopulationBased {
        population_size: usize,
        generations: usize,
        exploit: ExploitStrategy,
        explore: ExploreStrategy,
    },
    Custom {
        coordinator: String,
        config: Value,
    },
}

Training strategy — graph-level attribute, inherited by subgraphs.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Local

All nodes execute locally (default).

DataParallel

Replicate the entire graph on N workers, each sees a data shard. Gradients are aggregated after each step.

Fields

num_replicas: usize

Number of graph replicas — one worker and one data shard each.

aggregation: GradientAggregation

How the replicas’ gradients are combined after each step.

ModelParallel

Arbitrary model partitioning: each Partition maps a set of node IDs to a worker target. Any topology is supported.

Fields

partitions: Vec<Partition>

Which nodes run where. Nodes not covered by any Partition stay on the default (local) target.

communication: CommunicationProtocol

How activations and gradients move between partitions.

Federated

Federated learning: data stays on workers, only model updates are shared. The coordinator aggregates after each round.

Fields

num_clients: usize

Total number of participating clients (the pool ClientSelection draws from each round).

rounds: usize

Number of train→aggregate rounds to run.

aggregation: FederatedAggregation

How client updates are combined into the global model.

client_selection: ClientSelection

Which clients participate in each round.

PopulationBased

Population-Based Training: evolutionary hyperparameter optimization. Each generation trains a population, evaluates, then evolves.

Fields

population_size: usize

Number of concurrently trained population members.

generations: usize

Number of train→evaluate→exploit/explore cycles.

exploit: ExploitStrategy

How underperformers copy from top performers.

explore: ExploreStrategy

How copied hyperparameters are mutated afterwards.

Custom

User-defined strategy with a registered coordinator.

Fields

coordinator: String

Name identifying the user-provided coordinator. The built-in strategy executor refuses this variant outright — it never falls back to Local — so running it means supplying your own coordination logic.

config: Value

Opaque configuration passed through to the coordinator.

Trait Implementations

impl Clone for TrainingStrategy

fn clone(&self) -> TrainingStrategy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TrainingStrategy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TrainingStrategy

fn default() -> TrainingStrategy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TrainingStrategy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TrainingStrategy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.