def federated_secure_modular_sum(arg): py_typecheck.check_type(arg, building_blocks.ComputationBuildingBlock) arg.type_signature.check_struct() if arg.type_signature.is_struct_with_python(): container_type = arg.type_signature.python_container else: container_type = None summand_arg = building_blocks.Selection(arg, index=0) raw_summed_values = building_block_factory.create_federated_sum(summand_arg) unplaced_modulus = building_blocks.Selection(arg, index=1) placed_modulus = building_block_factory.create_federated_value( unplaced_modulus, placements.SERVER) modulus_arg = building_block_factory.create_federated_zip( building_blocks.Struct([raw_summed_values, placed_modulus], container_type=container_type)) def map_structure_mod(summed_values, modulus): modulus = _ensure_structure(modulus, unplaced_modulus.type_signature, raw_summed_values.type_signature.member) return structure.map_structure(tf.math.mod, summed_values, modulus) modulus_fn = building_block_factory.create_tensorflow_binary_operator( map_structure_mod, operand_type=raw_summed_values.type_signature.member, second_operand_type=placed_modulus.type_signature.member) modulus_computed = building_block_factory.create_federated_apply( modulus_fn, modulus_arg) return modulus_computed
def federated_sum(self, value): """Implements `federated_sum` as defined in `api/intrinsics.py`.""" value = value_impl.to_value(value, None, self._context_stack) value = value_utils.ensure_federated_value(value, placements.CLIENTS, 'value to be summed') type_utils.check_is_sum_compatible(value.type_signature) value = value_impl.ValueImpl.get_comp(value) comp = building_block_factory.create_federated_sum(value) return value_impl.ValueImpl(comp, self._context_stack)
def test_finds_aggregate_dependent_on_aggregate(self): aggregate = building_block_test_utils.create_whimsy_called_federated_aggregate( ) broadcasted_aggregate = building_block_factory.create_federated_broadcast( aggregate) second_aggregate = building_block_factory.create_federated_sum( broadcasted_aggregate) with self.assertRaises(ValueError): tree_analysis.check_aggregate_not_dependent_on_aggregate( second_aggregate)
def create_whimsy_called_federated_sum(value_type=tf.int32): r"""Returns a whimsy called federated sum. Call / \ federated_sum data Args: value_type: The type of the value. """ federated_type = computation_types.FederatedType(value_type, placements.CLIENTS) value = building_blocks.Data('data', federated_type) return building_block_factory.create_federated_sum(value)
def federated_sum(self, value): """Implements `federated_sum` as defined in `api/intrinsics.py`.""" value = value_impl.to_value(value, None, self._context_stack) value = value_utils.ensure_federated_value(value, placements.CLIENTS, 'value to be summed') if not type_utils.is_sum_compatible(value.type_signature): raise TypeError( 'The value type {} is not compatible with the sum operator.'. format(value.type_signature)) value = value_impl.ValueImpl.get_comp(value) comp = building_block_factory.create_federated_sum(value) return value_impl.ValueImpl(comp, self._context_stack)
def federated_sum(value): """Computes a sum at `tff.SERVER` of a `value` placed on the `tff.CLIENTS`. To sum integer values with stronger privacy properties, consider using `tff.federated_secure_sum_bitwidth`. Args: value: A value of a TFF federated type placed at the `tff.CLIENTS`. Returns: A representation of the sum of the member constituents of `value` placed on the `tff.SERVER`. Raises: TypeError: If the argument is not a federated TFF value placed at `tff.CLIENTS`. """ value = value_impl.to_value(value, None) value = value_utils.ensure_federated_value(value, placements.CLIENTS, 'value to be summed') type_analysis.check_is_sum_compatible(value.type_signature) comp = building_block_factory.create_federated_sum(value.comp) comp = _bind_comp_as_reference(comp) return value_impl.Value(comp)