async def compute_federated_secure_sum( self, arg: federated_resolving_strategy.FederatedResolvingStrategyValue ) -> federated_resolving_strategy.FederatedResolvingStrategyValue: py_typecheck.check_type(arg.internal_representation, structure.Struct) py_typecheck.check_len(arg.internal_representation, 2) logging.warning( 'The implementation of the `tff.federated_secure_sum` intrinsic ' 'provided by the `tff.backends.test` runtime uses no cryptography.') server_ex = self._target_executors[placement_literals.SERVER][0] value = federated_resolving_strategy.FederatedResolvingStrategyValue( arg.internal_representation[0], arg.type_signature[0]) bitwidth = await arg.internal_representation[1].compute() bitwidth_type = arg.type_signature[1] sum_result, mask, fn = await asyncio.gather( self.compute_federated_sum(value), executor_utils.embed_tf_constant(self._executor, bitwidth_type, 2**bitwidth - 1), executor_utils.embed_tf_binary_operator(self._executor, bitwidth_type, tf.math.mod)) fn_arg = await server_ex.create_struct([ sum_result.internal_representation[0], mask.internal_representation, ]) fn_arg_type = computation_types.FederatedType( fn_arg.type_signature, placement_literals.SERVER, all_equal=True) arg = federated_resolving_strategy.FederatedResolvingStrategyValue( structure.Struct([ (None, fn.internal_representation), (None, [fn_arg]), ]), computation_types.StructType([fn.type_signature, fn_arg_type])) return await self.compute_federated_map_all_equal(arg)
async def _compute_intrinsic_federated_mean(self, arg): type_utils.check_federated_type( arg.type_signature, placement=placement_literals.CLIENTS) member_type = arg.type_signature.member async def _compute_total(): total = await self._compute_intrinsic_federated_sum(arg) total = await total.compute() return await self._parent_executor.create_value(total, member_type) async def _compute_factor(): cardinalities = await self._get_cardinalities() count = sum(cardinalities) return await executor_utils.embed_tf_scalar_constant( self._parent_executor, member_type, float(1.0 / count)) async def _compute_multiply_arg(): total, factor = tuple(await asyncio.gather(_compute_total(), _compute_factor())) return await self._parent_executor.create_tuple([total, factor]) multiply_fn, multiply_arg = tuple(await asyncio.gather( executor_utils.embed_tf_binary_operator(self._parent_executor, member_type, tf.multiply), _compute_multiply_arg())) result = await self._parent_executor.create_call(multiply_fn, multiply_arg) type_signature = type_factory.at_server(member_type) return CompositeValue(result, type_signature)
async def compute_federated_mean( self, arg: FederatedComposingStrategyValue ) -> FederatedComposingStrategyValue: type_analysis.check_federated_type( arg.type_signature, placement=placement_literals.CLIENTS) member_type = arg.type_signature.member async def _create_total(): total = await self.compute_federated_sum(arg) total = await total.compute() return await self._server_executor.create_value(total, member_type) async def _create_factor(): cardinalities = await self._get_cardinalities() count = sum(cardinalities) return await executor_utils.embed_tf_constant( self._server_executor, member_type, float(1.0 / count)) async def _create_multiply_arg(): total, factor = await asyncio.gather(_create_total(), _create_factor()) return await self._server_executor.create_struct([total, factor]) multiply_fn, multiply_arg = await asyncio.gather( executor_utils.embed_tf_binary_operator(self._server_executor, member_type, tf.multiply), _create_multiply_arg()) result = await self._server_executor.create_call( multiply_fn, multiply_arg) type_signature = computation_types.at_server(member_type) return FederatedComposingStrategyValue(result, type_signature)
async def _compute_intrinsic_federated_sum(self, arg): type_utils.check_federated_type( arg.type_signature, placement=placement_literals.CLIENTS) zero, plus, identity = tuple(await asyncio.gather(*[ executor_utils.embed_tf_scalar_constant(self, arg.type_signature.member, 0), executor_utils.embed_tf_binary_operator(self, arg.type_signature.member, tf.add), self.create_value( computation_factory.create_lambda_identity( arg.type_signature.member), type_factory.unary_op(arg.type_signature.member)) ])) aggregate_args = await self.create_tuple([arg, zero, plus, plus, identity]) return await self._compute_intrinsic_federated_aggregate(aggregate_args)
async def compute_federated_sum( self, arg: FederatedComposingStrategyValue ) -> FederatedComposingStrategyValue: type_analysis.check_federated_type( arg.type_signature, placement=placement_literals.CLIENTS) id_comp, id_type = tensorflow_computation_factory.create_identity( arg.type_signature.member) zero, plus, identity = await asyncio.gather( executor_utils.embed_tf_constant(self._executor, arg.type_signature.member, 0), executor_utils.embed_tf_binary_operator(self._executor, arg.type_signature.member, tf.add), self._executor.create_value(id_comp, id_type)) aggregate_args = await self._executor.create_struct( [arg, zero, plus, plus, identity]) return await self.compute_federated_aggregate(aggregate_args)
async def _compute_intrinsic_federated_mean(self, arg): arg_sum = await self._compute_intrinsic_federated_sum(arg) member_type = arg_sum.type_signature.member count = float(len(arg.internal_representation)) if count < 1.0: raise RuntimeError('Cannot compute a federated mean over an empty group.') child = self._target_executors[placement_literals.SERVER][0] factor, multiply = tuple(await asyncio.gather(*[ executor_utils.embed_tf_scalar_constant(child, member_type, float(1.0 / count)), executor_utils.embed_tf_binary_operator(child, member_type, tf.multiply) ])) multiply_arg = await child.create_tuple( anonymous_tuple.AnonymousTuple([(None, arg_sum.internal_representation[0]), (None, factor)])) result = await child.create_call(multiply, multiply_arg) return FederatingExecutorValue([result], arg_sum.type_signature)
async def compute_federated_sum( self, arg: FederatedResolvingStrategyValue) -> FederatedResolvingStrategyValue: py_typecheck.check_type(arg.type_signature, computation_types.FederatedType) zero, plus = await asyncio.gather( executor_utils.embed_tf_constant(self._executor, arg.type_signature.member, 0), executor_utils.embed_tf_binary_operator(self._executor, arg.type_signature.member, tf.add)) return await self.compute_federated_reduce( FederatedResolvingStrategyValue( structure.Struct([(None, arg.internal_representation), (None, zero.internal_representation), (None, plus.internal_representation)]), computation_types.StructType( (arg.type_signature, zero.type_signature, plus.type_signature))) )
async def _compute_intrinsic_federated_sum(self, arg): py_typecheck.check_type(arg.type_signature, computation_types.FederatedType) zero, plus = tuple(await asyncio.gather(*[ executor_utils.embed_tf_scalar_constant( self, arg.type_signature.member, 0), executor_utils.embed_tf_binary_operator( self, arg.type_signature.member, tf.add) ])) return await self._compute_intrinsic_federated_reduce( FederatingExecutorValue( anonymous_tuple.AnonymousTuple([ (None, arg.internal_representation), (None, zero.internal_representation), (None, plus.internal_representation) ]), computation_types.NamedTupleType( (arg.type_signature, zero.type_signature, plus.type_signature))) )
async def compute_federated_mean( self, arg: FederatedResolvingStrategyValue) -> FederatedResolvingStrategyValue: arg_sum = await self.compute_federated_sum(arg) member_type = arg_sum.type_signature.member count = float(len(arg.internal_representation)) if count < 1.0: raise RuntimeError('Cannot compute a federated mean over an empty group.') child = self._target_executors[placement_literals.SERVER][0] factor, multiply = await asyncio.gather( executor_utils.embed_tf_constant(child, member_type, float(1.0 / count)), executor_utils.embed_tf_binary_operator(child, member_type, tf.multiply)) multiply_arg = await child.create_struct( structure.Struct([(None, arg_sum.internal_representation[0]), (None, factor)])) result = await child.create_call(multiply, multiply_arg) return FederatedResolvingStrategyValue([result], arg_sum.type_signature)
async def _compute_intrinsic_federated_mean(self, arg): member_type = arg.type_signature.member ones = await self.create_value( 1, type_factory.at_clients(member_type, all_equal=True)) totals = (await self._compute_intrinsic_federated_sum( await self._compute_intrinsic_federated_zip_at_clients( await self.create_tuple([arg, ones])))).internal_representation py_typecheck.check_type(totals, executor_value_base.ExecutorValue) fed_sum, count = tuple(await asyncio.gather( self._parent_executor.create_selection(totals, index=0), self._parent_executor.create_selection(totals, index=1))) count_val = await count.compute() factor, multiply = tuple(await asyncio.gather(*[ executor_utils.embed_tf_scalar_constant( self._parent_executor, member_type, float(1.0 / count_val)), executor_utils.embed_tf_binary_operator(self._parent_executor, member_type, tf.multiply) ])) multiply_arg = await self._parent_executor.create_tuple([fed_sum, factor]) result = await self._parent_executor.create_call(multiply, multiply_arg) return CompositeValue(result, type_factory.at_server(member_type))