tff.framework.Context

Represents the interface to the context that the API executes against.

The interfaces in Core API may be used in a variety of contexts, such as at a compile time or at runtime, during unit tests, nested inside a body of an outer computation being defined or at the top level (not nested), and in the former case potentially nested more than one level deep, either in a general orchestration scope or in a section of TensorFlow code, as well as potentially in an undecorated regular Python function or a tfe.defun. The context of usage potentially affects some of the API, determines which subset of the API is available, and it can influence the manner in which the API calls behave. This interface abstracts out interactions between the API and the underlying context for mechanisms that are context-dependent. The API only interacts with a given current context (instance). Manipulating a context stack is the responsibility of the implementation.

Methods

`ingest`

View source

@abc.abstractmethod
ingest(
    val, type_spec
)

Ingests value 'val' given the expected type type_spec.

This function is invoked on Python call arguments and/or their constituents to translate them into a form that can be used in the given context. This is performed in the process of handling a computation's __call__(), while bundling arguments together, and prior to calling invoke().

Args
`val`	An object that represents the value to ingest in the given context.
`type_spec`	The `tff.Type` of the value represented by this object.

Returns
The result of ingestion, which is context-dependent.

`invoke`

View source

@abc.abstractmethod
invoke(
    comp, arg
)

Invokes computation comp with argument arg.

Prior to calling invoke, the argument arg or its constituents must have been ingested by the context by calling ingest.

Args
`comp`	The computation being invoked. The Python type of `comp` expected here (e.g., `pb.Computation`. `ComputationImpl`, or other) may depend on the context. It is the responsibility of the concrete implementation of this interface to verify that the type of `comp` matches what the context is expecting.
`arg`	The optional argument of the call (possibly an argument tuple with a nested structure), or `None` if no argument was supplied. Computations accept arguments in a variety of forms, but those are first ingested by calling `ingest()` above, then bundled together into a single object before calling `invoke()` in the given context.

Returns
The result of invocation, which is context-dependent.