process(data_ctx, app_ctx): Called to perform data processing :param data_ctx: the context that contains the data points transformed/generated :param app_ctx: the overall app context (e.g. current phase, round, task, …) :return:

class ModelDecryptor

Bases: fed_learn.components.data_processor.DataProcessor

process(data_ctx, app_ctx)

To decrypt the data_ctx.

Parameters

data_ctx –
app_ctx –

Returns

class ModelEncryptor

Bases: fed_learn.components.data_processor.DataProcessor

process(data_ctx, app_ctx)

To encrypt the data_ctx.

Parameters

data_ctx –
app_ctx –

Returns

fed_learn.components.dict_model_reader_writer module

class DictModelReaderWriter

Bases: fed_learn.components.model_reader_writer.ModelProcessor

This is a training-platform independent model reader-writer. - The local model is dict-based - The local model will be accommodated inside client local memory

apply_model(model_params, options=None)

Assign the local dict model with params from remote model.

Parameters

model_params – a ModelData message or dict of locally trained weights.
options – additional options when applying model. no_proto_convert: If this is set, then do not execute proto conversion.

Returns

True if any vars in model_params are successfully assigned.

extract_model(model_vars)

We build a dict of weights to return, whose name exists inside model_vars.

Parameters: model_vars – list of var names to get
Returns: which could be part or complete set of our local_model

get_local_models()

initialize(fitter=None)

We actually do not need a fitter here, but just to initialize our: local model to be an empty dict.

fed_learn.components.metadata_generator module

class BestMetricGenerator(field)

Bases: fed_learn.components.metadata_generator.MetadataGenerator

process(data_ctx: fed_learn.model_meta.FLContext, app_ctx): Called to perform data processing :param data_ctx: the context that contains the data points transformed/generated :param app_ctx: the overall app context (e.g. current phase, round, task, …) :return:

class InitialValidationMetricGenerator(field)

Bases: fed_learn.components.metadata_generator.MetadataGenerator

process(data_ctx: fed_learn.model_meta.FLContext, app_ctx): Called to perform data processing :param data_ctx: the context that contains the data points transformed/generated :param app_ctx: the overall app context (e.g. current phase, round, task, …) :return:

class IteratorNumberGenerator(field)

Bases: fed_learn.components.metadata_generator.MetadataGenerator

process(data_ctx: fed_learn.model_meta.FLContext, app_ctx): Called to perform data processing :param data_ctx: the context that contains the data points transformed/generated :param app_ctx: the overall app context (e.g. current phase, round, task, …) :return:

class MetadataGenerator(field)

Bases: fed_learn.components.data_processor.DataProcessor

get_field()

fed_learn.components.metric_manager module

class MetricManager(metric_map=None)

Bases: object

Manages metrics for federated learning.

add_group(group_name, metric_dict)

encode_metrics() → dict: Encodes metric map (2-level dict) into a single level dict.

get_group(group_name)

to_dict()

decode_metrics(encoded_metrics): Decodes encodec_metric (single level dict) back into 2 level dict.

validate_metrics(metric_map)

fed_learn.components.model_evaluator module

class ModelEvaluator

Bases: abc.ABC

abstract evaluate(): Runs the evaluation process.

abstract get_metric()

Gets the metric for selecting best model

Returns: An float number represents the metric.

initialize()

fed_learn.components.model_reader_writer module

class ModelProcessor

Bases: abc.ABC

abstract apply_model(model_params, options=None)

abstract extract_model(model_vars)

abstract get_local_models()

abstract initialize(fitter)

fed_learn.components.model_saver module

class ModelSaver

Bases: abc.ABC

initialize(builder=None)

abstract load_model()

abstract save_model(model, is_best)

fed_learn.components.model_validator module

class ModelValidator

Bases: abc.ABC

abstract close()

abstract validate_model(configer, checkpoint)

fed_learn.components.model_visualizer module

class ModelVisualizer

Bases: abc.ABC

abstract visualize(model_data)

fed_learn.components.pt_fed_utils module

feed_vars(model: torch.nn.modules.module.Module, model_params)

feed variable values from model_params to pytorch state_dict.

Parameters

model – the local pytorch model
model_params – a ModelData message

Returns

the assigned ops

fed_learn.components.pt_model_reader_writer module

class PTModelReaderWriter

Bases: fed_learn.components.model_reader_writer.ModelProcessor

apply_model(model_params, options=None)

Set the local model according to model_data

Parameters: model_params – a ModelData message
Returns: True if the local model changed

extract_model(model_vars)

get_local_models()

initialize(fitter): Set the fitter for pt model reader and writer.

fed_learn.components.pt_model_saver module

class PTModelSaver(exclude_vars=None, model_log_dir=None, ckpt_preload_path=None)

Bases: fed_learn.components.model_saver.ModelSaver

close()

initialize(builder=None)

load_model(): Convert initialised model into protobuf message. This function sets self.model to a ModelData protobuf message.

save_model(model, is_best)

fed_learn.components.rr_client_field_processor module

class RoundRobinClientFieldProcessor

Bases: fed_learn.components.data_processor.DataProcessor

This processor is called before the end of GetModel to handle round robin related fields assignment.

abort(app_ctx): Called to abort its work immediately :param app_ctx: :return:

process(data_ctx, app_ctx): Called to perform data processing :param data_ctx: the context that contains the data points transformed/generated :param app_ctx: the overall app context (e.g. current phase, round, task, …) :return:

fed_learn.components.rr_client_state_processor module

class RoundRobinClientStateProcessor

Bases: fed_learn.components.data_processor.DataProcessor

This processor is called durig the api get_client_state to pass round robin specific rr_train_steps

abort(app_ctx): Called to abort its work immediately :param app_ctx: :return:

process(data_ctx, app_ctx): Called to perform data processing :param data_ctx: the context that contains the data points transformed/generated :param app_ctx: the overall app context (e.g. current phase, round, task, …) :return: