Enum FedCommands 

pub enum FedCommands {
    Manifest {
        input: PathBuf,
        output: PathBuf,
        node_id: String,
        train_ratio: f64,
        seed: u64,
        format: String,
    },
    Plan {
        manifests: Vec<PathBuf>,
        output: PathBuf,
        strategy: String,
        train_ratio: f64,
        seed: u64,
        stratify_column: Option<String>,
        format: String,
    },
    Split {
        input: PathBuf,
        plan: PathBuf,
        node_id: String,
        train_output: PathBuf,
        test_output: PathBuf,
        validation_output: Option<PathBuf>,
    },
    Verify {
        manifests: Vec<PathBuf>,
        format: String,
    },
}

Federated split coordination commands.

Variants

Manifest

Generate a manifest from local dataset (runs on each node)

Fields

input: PathBuf

Input dataset file

output: PathBuf

Output manifest file

node_id: String

Unique node identifier

train_ratio: f64

Training set ratio

seed: u64

Random seed for reproducibility

format: String

Output format (json, binary)

Plan

Create a split plan from manifests (runs on coordinator)

Fields

manifests: Vec<PathBuf>

Manifest files from all nodes

output: PathBuf

Output plan file

strategy: String

Split strategy (local, proportional, stratified)

train_ratio: f64

Training set ratio

seed: u64

Random seed

stratify_column: Option<String>

Column for stratification (required for stratified strategy)

format: String

Output format (json, binary)

Split

Execute local split based on plan (runs on each node)

Fields

input: PathBuf

Input dataset file

plan: PathBuf

Split plan file

node_id: String

This node’s ID

train_output: PathBuf

Output training set file

test_output: PathBuf

Output test set file

validation_output: Option<PathBuf>

Output validation set file (optional)

Verify

Verify global split quality from manifests (runs on coordinator)

Fields

manifests: Vec<PathBuf>

Manifest files from all nodes

format: String

Output format (text, json)

Trait Implementations

impl FromArgMatches for FedCommands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for FedCommands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand