def test_type_signature_with_structure_of_tensors_and_moduli(self):
np_array = np.ndarray(shape=(5, 37), dtype=np.int16)
value = intrinsics.federated_value((np_array, np_array),
placements.CLIENTS)
modulus = (2, 2)
result = intrinsics.federated_secure_modular_sum(value, modulus)
self.assert_value(result, '<int16[5,37],int16[5,37]>@SERVER')
def next_fn(state, value):
if self._symmetric_range:
# Sum in [-M+1, M-1].
# Delegation to `federated_secure_modular_sum` with modulus 2*M-1 is
# equivalent to modular clip to range [-M+1, M-1]. Then, represent `x`
# in that range as `(x + 2*M-1) % 2*M-1` which is congruent with `x`
# under the desired modulus, thus compatible with secure aggreagtion.
# This is reverted after summation by modular clip to the initial range.
summed_value = intrinsics.federated_secure_modular_sum(
value, 2 * self._modulus - 1)
summed_value = intrinsics.federated_map(
tensorflow_computation.tf_computation(
self._mod_clip_after_symmetric_range_sum),
summed_value)
else:
summed_value = intrinsics.federated_secure_modular_sum(
value, self._modulus)
empty_measurements = intrinsics.federated_value((),
placements.SERVER)
return measured_process.MeasuredProcessOutput(
state, summed_value, empty_measurements)
def next_fn(server_state, client_data):
"""The `next` function for `tff.templates.IterativeProcess`."""
del server_state # Unused
# No call to `federated_map` with prepare.
# No call to `federated_broadcast`.
client_updates = intrinsics.federated_map(work, client_data)
unsecure_update = intrinsics.federated_sum(client_updates[0])
secure_sum_bitwidth_update = intrinsics.federated_secure_sum_bitwidth(
client_updates[1], bitwidth=8)
secure_sum_update = intrinsics.federated_secure_sum(client_updates[2],
max_input=1)
secure_modular_sum_update = intrinsics.federated_secure_modular_sum(
client_updates[3], modulus=8)
new_server_state = intrinsics.federated_zip([
unsecure_update, secure_sum_bitwidth_update, secure_sum_update,
secure_modular_sum_update
])
# No call to `federated_map` with an `update` function.
server_output = intrinsics.federated_value([], placements.SERVER)
return new_server_state, server_output
def next_computation(arg):
"""The logic of a single MapReduce processing round."""
server_state, client_data = arg
broadcast_input = intrinsics.federated_map(mrf.prepare, server_state)
broadcast_result = intrinsics.federated_broadcast(broadcast_input)
work_arg = intrinsics.federated_zip([client_data, broadcast_result])
(aggregate_input, secure_sum_bitwidth_input, secure_sum_input,
secure_modular_sum_input) = intrinsics.federated_map(
mrf.work, work_arg)
aggregate_result = intrinsics.federated_aggregate(
aggregate_input, mrf.zero(), mrf.accumulate, mrf.merge, mrf.report)
secure_sum_bitwidth_result = intrinsics.federated_secure_sum_bitwidth(
secure_sum_bitwidth_input, mrf.secure_sum_bitwidth())
secure_sum_result = intrinsics.federated_secure_sum(
secure_sum_input, mrf.secure_sum_max_input())
secure_modular_sum_result = intrinsics.federated_secure_modular_sum(
secure_modular_sum_input, mrf.secure_modular_sum_modulus())
update_arg = intrinsics.federated_zip(
(server_state, (aggregate_result, secure_sum_bitwidth_result,
secure_sum_result, secure_modular_sum_result)))
updated_server_state, server_output = intrinsics.federated_map(
mrf.update, update_arg)
return updated_server_state, server_output
def test_returns_map_reduce_form_with_secure_modular_sum_modulus(self):
mrf = self.get_map_reduce_form_for_client_to_server_fn(
lambda data: intrinsics.federated_secure_modular_sum(data, 22))
self.assertEqual(mrf.secure_modular_sum_modulus(), (22, ))
def test_raises_type_error_with_different_structures(self):
value = intrinsics.federated_value([1, [1, 1]], placements.CLIENTS)
modulus = [8, 4, 2]
with self.assertRaises(TypeError):
intrinsics.federated_secure_modular_sum(value, modulus)
def test_raises_type_error_with_modulus_int_at_server(self):
value = intrinsics.federated_value(1, placements.CLIENTS)
modulus = intrinsics.federated_value(1, placements.SERVER)
with self.assertRaises(TypeError):
intrinsics.federated_secure_modular_sum(value, modulus)
def test_type_signature_with_one_tensor_and_modulus(self):
value = intrinsics.federated_value(
np.ndarray(shape=(5, 37), dtype=np.int16), placements.CLIENTS)
modulus = 2
result = intrinsics.federated_secure_modular_sum(value, modulus)
self.assert_value(result, 'int16[5,37]@SERVER')
def test_type_signature_with_structure_of_ints_scalar_modulus(self):
value = intrinsics.federated_value([1, [1, 1]], placements.CLIENTS)
modulus = 8
result = intrinsics.federated_secure_modular_sum(value, modulus)
self.assert_value(result, '<int32,<int32,int32>>@SERVER')
def test_type_signature_with_int(self):
value = intrinsics.federated_value(1, placements.CLIENTS)
modulus = 1
result = intrinsics.federated_secure_modular_sum(value, modulus)
self.assert_value(result, 'int32@SERVER')
def modular_sum_by_five(arg):
return intrinsics.federated_secure_modular_sum(arg, modulus)
def secure_modular_sum(x):
return intrinsics.federated_secure_modular_sum(
x, modulus=np.int64(iblt_lib.DEFAULT_FIELD_SIZE))