secretflow.ml.nn.sl.backend.tensorflow#

secretflow.ml.nn.sl.backend.tensorflow.strategy

secretflow.ml.nn.sl.backend.tensorflow.sl_base#

sl model base

Classes:

`SLBaseModel`(builder_base[, builder_fuse])
`SLBaseModule`(args, *kwargs)
`SLBaseTFModel`(builder_base, builder_fuse, ...)
`ModelPartition`(model_fn, optim_fn, loss_fn, ...)
`PYUSLTFModel`	alias of `ActorProxy(PYUSLTFModel)`
`PYUModel`	alias of `ActorProxy(PYUModel)`

class secretflow.ml.nn.sl.backend.tensorflow.sl_base.SLBaseModel(builder_base: Callable, builder_fuse: Optional[Callable] = None)[source]#

Bases: ABC

Methods:

`__init__`(builder_base[, builder_fuse])
`base_forward`()
`base_backward`()
`fuse_net`(hiddens)

__init__(builder_base: Callable, builder_fuse: Optional[Callable] = None)[source]#

abstract base_forward()[source]#

abstract base_backward()[source]#

abstract fuse_net(hiddens)[source]#

class secretflow.ml.nn.sl.backend.tensorflow.sl_base.SLBaseModule(*args, **kwargs)[source]#

Bases: ABC, Module

Methods:

`forward`(x)	Defines the computation performed at every call.
`get_weights`()
`set_weights`(weights)
`get_gradients`([parameters])
`set_gradients`(gradients[, parameters])

Attributes:

abstract forward(x)[source]#

Defines the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

get_weights()[source]#

set_weights(weights)[source]#

get_gradients(parameters=None)[source]#

set_gradients(gradients: List[Union[Tensor, ndarray]], parameters: Optional[List[Tensor]] = None)[source]#

training: bool#

class secretflow.ml.nn.sl.backend.tensorflow.sl_base.SLBaseTFModel(builder_base: Callable[[], Model], builder_fuse: Callable[[], Model], dp_strategy: DPStrategy, compressor: Compressor, random_seed: Optional[int] = None, **kwargs)[source]#

Bases: SLBaseModel

Methods:

`__init__`(builder_base, builder_fuse, ...[, ...])
`fuse_op`(x, y)
`init_data`()
`set_steps_per_epoch`(steps_per_epoch)
`get_basenet_output_num`()
`build_dataset_from_numeric`(*x[, y, s_w, ...])	build tf.data.Dataset
`build_dataset_from_builder`(*x[, y, s_w, ...])	build tf.data.Dataset
`set_dataset_stage`(data_set[, stage, has_y, ...])
`base_forward`([stage, compress])	compute hidden embedding :param stage: Which stage of the base forward :param compress: Whether to compress cross device data.
`base_backward`(gradient[, compress])	backward on fusenet
`get_base_losses`()
`get_base_weights`()
`get_fuse_weights`()
`init_training`(callbacks[, epochs, steps, ...])
`get_stop_training`()
`on_train_begin`()
`on_epoch_begin`(epoch)
`on_train_batch_begin`([step])
`on_train_batch_end`([step])
`on_validation`(val_logs)
`on_epoch_end`(epoch)
`on_train_end`()
`set_sample_weight`(sample_weight[, stage])
`fuse_net`(*forward_data[, _num_returns, compress])	Fuses the hidden layer and calculates the reverse gradient only on the side with the label
`reset_metrics`()
`evaluate`(*forward_data[, compress])	Returns the loss value & metrics values for the model in test mode.
`wrap_local_metrics`()
`metrics`()
`predict`(*forward_data[, compress])	Generates output predictions for the input hidden layer features.
`save_base_model`(base_model_path, **kwargs)
`save_fuse_model`(fuse_model_path, **kwargs)
`load_base_model`(base_model_path, **kwargs)
`load_fuse_model`(fuse_model_path, **kwargs)
`export_base_model`(model_path[, save_format])
`export_fuse_model`(model_path[, save_format])
`get_privacy_spent`(step[, orders])	Get accountant of dp mechanism.
`get_skip_gradient`()

__init__(builder_base: Callable[[], Model], builder_fuse: Callable[[], Model], dp_strategy: DPStrategy, compressor: Compressor, random_seed: Optional[int] = None, **kwargs)[source]#

static fuse_op(x, y)[source]#

init_data()[source]#

set_steps_per_epoch(steps_per_epoch)[source]#

get_basenet_output_num()[source]#

build_dataset_from_numeric(*x: List[ndarray], y: Optional[ndarray] = None, s_w: Optional[ndarray] = None, batch_size=32, buffer_size=128, shuffle=False, repeat_count=1, stage='train', random_seed=1234)[source]#

build tf.data.Dataset

Parameters:

x – feature, FedNdArray or HDataFrame
y – label, FedNdArray or HDataFrame
s_w – sample weight, FedNdArray or HDataFrame
batch_size – Number of samples per gradient update
buffer_size – buffer size for shuffling
shuffle – whether shuffle the dataset or not
repeat_count – num of repeats
stage – stage of this datset
random_seed – Prg seed for shuffling

build_dataset_from_builder(*x: List[ndarray], y: Optional[ndarray] = None, s_w: Optional[ndarray] = None, batch_size=-1, shuffle=False, buffer_size=256, random_seed=1234, stage='train', dataset_builder: Optional[Callable] = None)[source]#

build tf.data.Dataset

Parameters:

x – feature, FedNdArray or HDataFrame
y – label, FedNdArray or HDataFrame
s_w – sample weight, FedNdArray or HDataFrame
stage – stage of this datset
dataset_builder – dataset build callable function of worker

set_dataset_stage(data_set, stage='train', has_y=None, has_s_w=None)[source]#

base_forward(stage='train', compress: bool = False) → ForwardData[source]#

compute hidden embedding :param stage: Which stage of the base forward :param compress: Whether to compress cross device data.

Returns: hidden embedding

base_backward(gradient, compress: bool = False)[source]#

backward on fusenet

Parameters:

gradient – gradient of fusenet hidden layer
compress – Whether to decompress gradient.

get_base_losses()[source]#

get_base_weights()[source]#

get_fuse_weights()[source]#

init_training(callbacks, epochs=1, steps=0, verbose=0)[source]#

get_stop_training()[source]#

on_train_begin()[source]#

on_epoch_begin(epoch)[source]#

on_train_batch_begin(step=None)[source]#

on_train_batch_end(step=None)[source]#

on_validation(val_logs)[source]#

on_epoch_end(epoch)[source]#

on_train_end()[source]#

set_sample_weight(sample_weight, stage='train')[source]#

fuse_net(*forward_data: List[ForwardData], _num_returns: int = 2, compress: bool = False)[source]#

Fuses the hidden layer and calculates the reverse gradient only on the side with the label

Parameters:

forward_data – A list of ForwardData containing hidden layers, losses, etc. that are uploaded by each party for computation.
compress – Whether to decompress/compress data.

Returns:

gradient Of hiddens

reset_metrics()[source]#

evaluate(*forward_data: List[ForwardData], compress: bool = False)[source]#

Returns the loss value & metrics values for the model in test mode.

Parameters:

forward_data – A list of data dictionaries containing hidden layers, losses, etc. that are uploaded by each party for computation.
compress – Whether to decompress input data.

Returns:

map of model metrics.

wrap_local_metrics()[source]#

metrics()[source]#

predict(*forward_data: List[ForwardData], compress: bool = False)[source]#

Generates output predictions for the input hidden layer features.

Parameters:

forward_data – A list of data dictionaries containing hidden layers, that are uploaded by each party for computation.
compress – Whether to decompress input data.

Returns:

Array(s) of predictions.

save_base_model(base_model_path: str, **kwargs)[source]#

save_fuse_model(fuse_model_path: str, **kwargs)[source]#

load_base_model(base_model_path: str, **kwargs)[source]#

load_fuse_model(fuse_model_path: str, **kwargs)[source]#

export_base_model(model_path: str, save_format: str = 'onnx', **kwargs)[source]#

export_fuse_model(model_path: str, save_format: str = 'onnx', **kwargs)[source]#

get_privacy_spent(step: int, orders=None)[source]#

Get accountant of dp mechanism.

Parameters:

step – The current step of model training or prediction.
orders – An array (or a scalar) of RDP orders.

get_skip_gradient()[source]#

class secretflow.ml.nn.sl.backend.tensorflow.sl_base.ModelPartition(model_fn, optim_fn, loss_fn, dataloader_fn)[source]#

Bases: object

Methods:

`__init__`(model_fn, optim_fn, loss_fn, ...)
`get_one_batch`([name])
`forward`([used_name, external_input])
`zero_grad`()
`backward`([used_name, gradients, external_input])
`apply_gradients`([gradients])
`optim_step`()
`get_weights`()
`set_weights`(weights)
`call_model_fn`(fn_name, args, *kwargs)

__init__(model_fn, optim_fn, loss_fn, dataloader_fn)[source]#

get_one_batch(name='train')[source]#

forward(used_name='train', external_input=None) → Tuple[Tensor, Tensor][source]#

zero_grad()[source]#

backward(used_name='train', gradients=None, external_input: Optional[Dict] = None)[source]#

apply_gradients(gradients=None)[source]#

optim_step()[source]#

get_weights()[source]#

set_weights(weights)[source]#

call_model_fn(fn_name, *args, **kwargs)[source]#

secretflow.ml.nn.sl.backend.tensorflow.sl_base.PYUSLTFModel[source]#

alias of ActorProxy(PYUSLTFModel) Methods:

`__init__`(args, *kwargs)	Abstraction device object base class.
`base_backward`(gradient[, compress])	backward on fusenet
`base_forward`([stage, compress])	compute hidden embedding :param stage: Which stage of the base forward :param compress: Whether to compress cross device data.
`build_dataset_from_builder`(*x[, y, s_w, ...])	build tf.data.Dataset
`build_dataset_from_numeric`(*x[, y, s_w, ...])	build tf.data.Dataset
`evaluate`(*forward_data[, compress])	Returns the loss value & metrics values for the model in test mode.
`export_base_model`(model_path[, save_format])
`export_fuse_model`(model_path[, save_format])
`fuse_net`(*forward_data[, _num_returns, compress])	Fuses the hidden layer and calculates the reverse gradient only on the side with the label
`get_base_losses`()
`get_base_weights`()
`get_basenet_output_num`()
`get_fuse_weights`()
`get_privacy_spent`(step[, orders])	Get accountant of dp mechanism.
`get_skip_gradient`()
`get_stop_training`()
`init_data`()
`init_training`(callbacks[, epochs, steps, ...])
`load_base_model`(base_model_path, **kwargs)
`load_fuse_model`(fuse_model_path, **kwargs)
`metrics`()
`on_epoch_begin`(epoch)
`on_epoch_end`(epoch)
`on_train_batch_begin`([step])
`on_train_batch_end`([step])
`on_train_begin`()
`on_train_end`()
`on_validation`(val_logs)
`predict`(*forward_data[, compress])	Generates output predictions for the input hidden layer features.
`reset_metrics`()
`save_base_model`(base_model_path, **kwargs)
`save_fuse_model`(fuse_model_path, **kwargs)
`set_dataset_stage`(data_set[, stage, has_y, ...])
`set_sample_weight`(sample_weight[, stage])
`set_steps_per_epoch`(steps_per_epoch)
`wrap_local_metrics`()

secretflow.ml.nn.sl.backend.tensorflow.sl_base.PYUModel[source]#

alias of ActorProxy(PYUModel) Methods:

`__init__`(args, *kwargs)	Abstraction device object base class.
`apply_gradients`([gradients])
`backward`([used_name, gradients, external_input])
`call_model_fn`(fn_name, args, *kwargs)
`forward`([used_name, external_input])
`get_one_batch`([name])
`get_weights`()
`optim_step`()
`set_weights`(weights)
`zero_grad`()

secretflow.ml.nn.sl.backend.tensorflow.utils#

Classes:

`custom_loss`(func)	Decorator to define a function with a custom loss.
`TensorInfo`([name, tensor_name, dtype, shape])
`ForwardData`([hidden, losses])	ForwardData is a dataclass for data uploaded by each party to label party for computation.

Functions:

`wrap_onnx_input_output`(io_pb)
`wrap_tf_input_output`(io_pb)

class secretflow.ml.nn.sl.backend.tensorflow.utils.custom_loss(func: Callable)[source]#

Bases: object

Decorator to define a function with a custom loss.

This decorator allows to define loss functions with additional keyword arguments. These keyword arguments must match the results of model’s forward pass.

Examples

>>> import tensorflow as tf
>>> # define model
>>> class MyModel(tf.keras.Model):
>>>     def call(self, inputs, **kwargs):
>>>         # do forward pass
>>>         return None, y_pred, {'kwarg1': kwarg1, 'kwarg2': kwarg2}
>>> # define loss function
>>> @custom_loss
>>> def my_loss(y_true, y_pred, kwarg1 = None, kwarg2 = None):
>>>     # cumpute loss
>>>     pass
>>> # compile model with custom loss function
>>> model = MyModel(...)
>>> model.compile(
>>>     loss=my_loss,
>>>     optimizer=tf.keras.optimizers.Adam(0.01),
>>>     metrics=['acc'],
>>> )

Note: custom_loss, my_loss and MyModel need to be added to custom_objects when loading the model.

Methods:

`__init__`(func)
`with_kwargs`(kwargs)
`get_config`()
`from_config`(config)

__init__(func: Callable)[source]#

with_kwargs(kwargs)[source]#

get_config()[source]#

classmethod from_config(config)[source]#

class secretflow.ml.nn.sl.backend.tensorflow.utils.TensorInfo(name: str = None, tensor_name: str = None, dtype: str = None, shape: List[int] = None)[source]#

Bases: object

Attributes:

`name`
`tensor_name`
`dtype`
`shape`

Methods:

__init__([name, tensor_name, dtype, shape])

name: str = None#

tensor_name: str = None#

dtype: str = None#

shape: List[int] = None#

__init__(name: Optional[str] = None, tensor_name: Optional[str] = None, dtype: Optional[str] = None, shape: Optional[List[int]] = None) → None#

secretflow.ml.nn.sl.backend.tensorflow.utils.wrap_onnx_input_output(io_pb)[source]#

secretflow.ml.nn.sl.backend.tensorflow.utils.wrap_tf_input_output(io_pb)[source]#

class secretflow.ml.nn.sl.backend.tensorflow.utils.ForwardData(hidden: Optional[Union[Any, List[Any]]] = None, losses: Optional[Any] = None)[source]#

Bases: object

ForwardData is a dataclass for data uploaded by each party to label party for computation.

hidden: base model hidden layers outputs losses: the sum of base model losses should added up to fuse model loss

Attributes:

`hidden`
`losses`

Methods:

__init__([hidden, losses])

hidden: Union[Any, List[Any]] = None#

losses: Any = None#

__init__(hidden: Optional[Union[Any, List[Any]]] = None, losses: Optional[Any] = None) → None#