Building Complex Models with the Keras Functional API
The Functional API describes a model as a connected route of tensor transformations.
A Route Through Transformations
A Keras model can be understood as a route: data enters through an input tensor, passes through connected tensor transformations, and leaves through an output tensor. The Functional API makes this route explicit. Rather than focusing only on a list of layers, focus on how each layer receives one tensor and produces the next tensor in the route.
The central idea is connection. A layer matters to the Functional API model because a tensor is passed into it and the resulting tensor is retained as part of the route.
Following the Tensor Handoff
In the Functional API, layers are used as functions. The input to a layer is a tensor, and the result is another tensor. This creates a handoff: the tensor produced by one transformation can become the tensor accepted by the next transformation. The sequence is therefore not merely a visual ordering of layer names. It is a chain of relationships between tensors and layers.
Tracing a Three-Step Route
Suppose a model begins with an input tensor, sends it through Layer A, then sends the result through Layer B. Which objects form the route?
Start with the input: Name the tensor that represents data entering the model. This is the beginning of the route.
Apply Layer A: Use Layer A with the input tensor. The returned tensor becomes the next saved point in the route.
Apply Layer B: Use Layer B with the tensor returned by Layer A. The newly returned tensor becomes the end of this example route.
Inspect each handoff: Check that the input to Layer B is the tensor produced by Layer A, rather than an unrelated tensor.
The route is input tensor to Layer A to an intermediate tensor to Layer B to output tensor.
This tracing method is useful because it follows the actual assembly relationship. For every layer, ask two questions: Which tensor enters this layer? Which tensor is saved after the layer returns? Those answers reveal whether the intended route continues from one transformation to the next.
Defining the Model Boundaries
The Keras Model class uses an input tensor and a related output tensor to assemble the model.
The input and output tensors act as the two boundaries of the model description. The input tensor identifies where data enters. The output tensor identifies where data leaves. Keras uses the connected path between these related tensors to form the Model.
Verifying the Assembly Path
To check whether a Functional API model matches its intended design, trace the layer path one step at a time. Begin at the selected input tensor. For each layer, identify the tensor entering it, then follow the tensor returned by that layer. Continue until you reach the selected output tensor.
The important check is whether every handoff follows the intended route. A model is assembled from the connected transformations between the chosen input and output tensors. Therefore, a wrong endpoint or a broken relationship matters more than the visual order of lines in the file.
Disconnected Endpoints
Choosing an input tensor and output tensor that are not related by a connected route.
The Model class depends on a related input and output tensor pair. A disconnected pair causes a RuntimeError.
Fix:
Trace the tensor handoff from the input and select an output tensor reached through the intended connected transformations.Treating the visual order of layer lines as proof that the model is connected.
The Functional API describes relationships between tensors and layers, not merely the order in which lines appear.
Fix:
For each layer, record which tensor enters it and which tensor is saved as its result.Inspecting layer names without identifying the model endpoints.
The Model constructor uses the input tensor and related output tensor to assemble the model.
Fix:
Locate the tensor that begins the route and the tensor that ends it before judging the assembly.
Route-Checking Practice
Imagine a Functional API design with an input tensor, Layer A, an intermediate tensor, Layer B, and an output tensor. Explain the tensor handoff at each stage and state which two tensors should define the Model boundaries.
Hints
- Start by naming the tensor that data enters.
- After each layer, identify the tensor returned by that layer.
- The model boundaries are the related tensor at the start and the related tensor at the end.
What do you think happens?
What should you investigate first if the selected input and output tensors are disconnected?
Reveal answer
Answer: The tensor handoff between each layer
The Functional API assembles a model from connected transformations between the selected input and output tensors. Inspecting each handoff reveals where the intended relationship is missing.
Essential Takeaways
- The Functional API represents a model as a connected route of tensor transformations.
- A layer is used as a function: it accepts a tensor and returns a tensor.
- The Keras Model class uses a related input tensor and output tensor to define the model boundaries.
- To verify assembly, trace which tensor enters and leaves each layer.
- A disconnected input and output pair causes a RuntimeError, so endpoint relationships must be checked directly.
Key Takeaways
- The Keras Functional API makes the route of tensor transformations explicit.
- Layers connect the route by accepting input tensors and returning output tensors.
- A Keras Model is assembled from related input and output tensors.
- Tracing tensor handoffs is more reliable than relying on the visual order of code lines.
- Disconnected endpoints cause a RuntimeError and should prompt a route inspection.