def federated_secure_sum(arg):
py_typecheck.check_type(arg, building_blocks.ComputationBuildingBlock)
summand_arg = building_blocks.Selection(arg, index=0)
summand_type = summand_arg.type_signature.member
max_input_arg = building_blocks.Selection(arg, index=1)
max_input_type = max_input_arg.type_signature
# Add the max_value as a second value in the zero, so it can be read during
# `accumulate` to ensure client summands are valid. The value will be
# later dropped in `report`.
#
# While accumulating summands, we'll assert each summand is less than or
# equal to max_input. Otherwise the comptuation should issue an error.
summation_zero = building_block_factory.create_generic_constant(
summand_type, 0)
aggregation_zero = building_blocks.Struct([summation_zero, max_input_arg],
container_type=tuple)
def assert_less_equal_max_and_add(summation_and_max_input, summand):
summation, original_max_input = summation_and_max_input
max_input = _ensure_structure(original_max_input, max_input_type,
summand_type)
# Assert that all coordinates in all tensors are less than the secure sum
# allowed max input value.
def assert_all_coordinates_less_equal(x, m):
return tf.Assert(
tf.reduce_all(
tf.less_equal(tf.cast(x, tf.int64), tf.cast(m, tf.int64))), [
'client value larger than maximum specified for secure sum',
x, 'not less than or equal to', m
])
assert_ops = structure.flatten(
structure.map_structure(assert_all_coordinates_less_equal, summand,
max_input))
with tf.control_dependencies(assert_ops):
return structure.map_structure(tf.add, summation,
summand), original_max_input
assert_less_equal_and_add = building_block_factory.create_tensorflow_binary_operator(
assert_less_equal_max_and_add,
operand_type=aggregation_zero.type_signature,
second_operand_type=summand_type)
def nested_plus(a, b):
return structure.map_structure(tf.add, a, b)
plus_op = building_block_factory.create_tensorflow_binary_operator(
nested_plus, operand_type=aggregation_zero.type_signature)
# In the `report` function we take the summation and drop the second element
# of the struct (which was holding the max_value).
drop_max_value_op = building_block_factory.create_tensorflow_unary_operator(
lambda x: type_conversions.type_to_py_container(x[0], summand_type),
aggregation_zero.type_signature)
return building_block_factory.create_federated_aggregate(
summand_arg, aggregation_zero, assert_less_equal_and_add, plus_op,
drop_max_value_op)
def federated_sum(x):
py_typecheck.check_type(x, building_blocks.ComputationBuildingBlock)
operand_type = x.type_signature.member
zero = building_block_factory.create_generic_constant(operand_type, 0)
plus_op = building_block_factory.create_tensorflow_binary_operator_with_upcast(
tf.add, computation_types.StructType([operand_type, operand_type]))
identity = building_block_factory.create_identity(operand_type)
return building_block_factory.create_federated_aggregate(
x, zero, plus_op, plus_op, identity)
def federated_sum(x):
zero = value_impl.ValueImpl(
building_block_factory.create_generic_constant(
x.type_signature.member, 0), context_stack)
plus_op = value_impl.ValueImpl(
building_block_factory.create_binary_operator_with_upcast(
computation_types.NamedTupleType(
[x.type_signature.member, x.type_signature.member]),
tf.add), context_stack)
return federated_reduce([x, zero, plus_op])
def federated_sum(x):
operand_type = x.type_signature.member
zero = value_impl.ValueImpl(
building_block_factory.create_generic_constant(operand_type, 0),
context_stack)
plus_op = value_impl.ValueImpl(
building_block_factory.
create_tensorflow_binary_operator_with_upcast(
computation_types.StructType([operand_type, operand_type]),
tf.add), context_stack)
return federated_reduce([x, zero, plus_op])
def federated_mean(arg):
one = value_impl.ValueImpl(
building_block_factory.create_generic_constant(
arg.type_signature, 1), context_stack)
arg = value_impl.to_value([arg, one], None, context_stack)
return federated_weighted_mean(arg)
def federated_mean(arg):
py_typecheck.check_type(arg, building_blocks.ComputationBuildingBlock)
one = building_block_factory.create_generic_constant(
arg.type_signature, 1)
mean_arg = building_blocks.Struct([(None, arg), (None, one)])
return federated_weighted_mean(mean_arg)
