PiperOrigin-RevId: 390627213

PiperOrigin-RevId: 386503038

PiperOrigin-RevId: 380228493

This change unblocks the introduction of `federated_secure_sum` with
a maximum value rather than a bitwidth, as well as the introduction of
`federated_secure_modular_sum` with an integer modulus.

CL automatically created by:
```
    replace_string \
      'federated_secure_sum' \
      'federated_secure_sum_bitwidth'
```

PiperOrigin-RevId: 379380586

PiperOrigin-RevId: 371258358

PiperOrigin-RevId: 370596723

This change is intended reduce the depth of the package structure and make it easier to determine what is part of the public API by taking steps to removing the split in the `api` and `impl` packages.

PiperOrigin-RevId: 370373365

This change is intended reduce the depth of the package structure and make it easier to determine what is part of the public API by taking steps to removing the split in the `api` and `impl` packages.

PiperOrigin-RevId: 369718296

PiperOrigin-RevId: 367721827

PiperOrigin-RevId: 367525911

Remove the `tff.utils` package now that it contains nothing.

PiperOrigin-RevId: 367275852

This change introduces federated_select and its secure counterpart
as new intrinsics. As of this change, federated_select is still not
supported by any TFF backend (mapreduce, reference, or execution).
The purpose of this change is to solidify the API for federated_select
and unblock efforts to begin simulating federated_select for research
use.

Note that federated_select and federated_secure_select are
exposed as separate intrinsics rather than a single intrinsic whose
behavior is configurable in the backend, or as a single intrinsic with
a boolean parameter. The former approach would not allow for easy
simultaneous use of federated_select and federated_secure_select in
the same computation, which may be useful when selecting based on
private data in some places and non-private data in others. The latter
approach (a boolean parameter) could suggest to users that they should
parameterize their own code based on a "secure" boolean, which is
undesirable; such indirection could make it harder to tell whether
secure selection is being used in a particular location. Additionally,
keeping `federated_secure_select` as a separate function will make it
easier to modify if it turns out that `federated_secure_select` or
`federated_select` should offer additional non-shared parameters.

PiperOrigin-RevId: 367265514

* Deleted the `api/placement` module.
* Updated to use the `impl/types/placements` module.

PiperOrigin-RevId: 366320097

There was a not-insignificant amount of code involved
in providing this intrinsic. However, it isn't being
used at all, in particular because it isn't possible
to use in production (where multi-layered aggregation
is a requirement). Instances of federated_reduce that
use an associative binary accumulate operator can be
easily transitioned to federated_aggregate, as was
already done in the _federated_reduce_with_func helper
in federated_aggregations.py.

PiperOrigin-RevId: 365091411

and clarify that it supports more than just tf.Tensor leaf values.

PiperOrigin-RevId: 363722140

PiperOrigin-RevId: 362566458

This function allows users to create values of a given tensor type structure,
wrapping correctly in the desired Python container. This can be used to,
for example, create a structure of zeroes for a given TFF type.

PiperOrigin-RevId: 362177848

PiperOrigin-RevId: 348084727

PiperOrigin-RevId: 344310585

PiperOrigin-RevId: 342128507

`tff.type_at_server` and `tff.type_at_clients` are a proposed solution
to the ergonomic issues of `tff.FederatedType(..., tff.CLIENTS)`
and `tff.FederatedType(..., tff.SERVER)`.

PiperOrigin-RevId: 334260423

PiperOrigin-RevId: 331651419

This was requested in order to ensure that TFF computations
return the correct type.

PiperOrigin-RevId: 331248988

PiperOrigin-RevId: 328146354

PiperOrigin-RevId: 326773993

* Removed duplicate symbols.
* Moved initializing a default execution context to the top level package.
* Removed the circular Python import guards.

PiperOrigin-RevId: 326065490

PiperOrigin-RevId: 323066096

This change moves and renames `AnonymousTuple` and its `Type`-based
brethren. It re-exports the new types under the old names to allow
for a more gradual transition to the new API.

PiperOrigin-RevId: 322477504

PiperOrigin-RevId: 313409513

Added a new `tensorflow_docs` public filter and removed the `_allowed_symbols` variables from the TFF packages.

PiperOrigin-RevId: 306446724

PiperOrigin-RevId: 305688076

This package contains functions and utilities that can make testing usage of TFF
easier or more convenient and parallels the `tf.test` package.

PiperOrigin-RevId: 305108997

PiperOrigin-RevId: 295827969

* Moved class and tests to `templates` package.
* Renamed usage of `computation_utils.IterativeProcess` in TFF to the new module.

PiperOrigin-RevId: 294680342

PiperOrigin-RevId: 293915901

This intrinsic is similar to federated_value, but accepts a no-argument lambda
rather than an unplaced value. This will clarify the behavior of the intrinsic
(eval on all clients separately rather than eval and then broadcast), and
unblocks the effort to ban unplaced values.

PiperOrigin-RevId: 293898477

This change is part one of three:

1. Add `secure_sum` intrinsic to TFF.
2. Update transformations to support the `secure_sum` intrinsic.
3. Update canonical form to support the `secure_sum` intrinsic.

Here is an example using the API:

```python
  @computations.federated_computation
  def init_fn():
    """The `init` function for `computation_utils.IterativeProcess`."""
    return intrinsics.federated_value([0, 0], placements.SERVER)

  @computations.tf_computation(tf.int32, tf.int32], tf.int32]])
  def work(client_data, client_input):
    del client_data  # Unused
    del client_input  # Unused
    return [1, 1]

  @computations.federated_computation([
      computation_types.FederatedType([tf.int32, tf.int32], placements.SERVER),
      computation_types.FederatedType(tf.int32, placements.CLIENTS),
  ])
  def next_fn(server_state, client_data):
    """The `next` function for `computation_utils.IterativeProcess`."""
    client_input = intrinsics.federated_broadcast(server_state)
    c3 = intrinsics.federated_zip([client_data, client_input])
    client_updates = intrinsics.federated_map(work, c3)
    federated_update = intrinsics.federated_sum(client_updates[0])
    secure_update = intrinsics.secure_sum(client_updates[1], 8)
    new_server_state = intrinsics.federated_zip([federated_update, secure_update])
    server_output = intrinsics.federated_value([], placements.SERVER)
    return new_server_state, server_output

  ip = computation_utils.IterativeProcess(init_fn, next_fn)
```

PiperOrigin-RevId: 290988239

PiperOrigin-RevId: 288970729

PiperOrigin-RevId: 287599572

PiperOrigin-RevId: 281648811