Multi-Input Models

One Graph, Several Predictions

A multi-input or multi-output model is easier to understand when you stop imagining it as one straight stack of layers. A Keras functional model can receive several streams of data, process each stream through its own branch, and merge the resulting representations. It can also share one representation and branch into several named prediction heads. The graph therefore has places where information is separate and places where it is shared.

Tracing Two Input Branches

A single-input model receives one stream of data. A multi-input model receives several streams and gives each stream its own path before combining the resulting representations. For example, a question-answering system can receive a question through one input and a text snippet through another. The question and text travel independently until a merge operation brings their branch representations together.

Building the Branch Structure

The main construction stages of a two-input functional model are input layers, independent branch encoders, a merge operation, and an output layer. Input names such as text and question identify the input nodes. Those names are useful later because dictionary-based training uses them to associate each array with the correct branch. The model construction is explicit: it receives both input tensors and produces the answer tensor.

The branches meet through a Keras merge operation such as concatenate or add. The merge line is not a minor implementation detail. It determines how the branch representations are brought together, so it is one of the first places to inspect when the model behaves unexpectedly.

Routing Training Data

Training data must preserve the model's input structure. With list-based training, input arrays are supplied in the same order as the model's inputs. This form is concise, but the order must remain correct. With dictionary-based training, arrays are supplied under the names of the input nodes. This makes the pairing explicit and requires named inputs.

Matching Heads to Losses

A multi-output model makes several predictions from the same input or shared internal representation. Each output can represent a different task, so each head needs a loss suited to what it predicts. The source example uses an age head for scalar regression, an income head for classification over income groups, and a gender head for binary classification. These tasks therefore use different kinds of losses rather than one loss reused blindly for every output.

During training, one target array is paired with each output. Keras accepts those targets as a list ordered like the model outputs or as a dictionary keyed by output names. The dictionary form makes the pairing explicit; the list form is shorter but depends on keeping the output order correct.

Forming the Global Loss

The separate output losses do not remain isolated during optimization. Keras combines the individual losses into one global loss used to optimize the model. Because the output heads share a representation, the combined result determines how the shared part of the network is trained.

A plain combination does not guarantee that every task influences learning equally. If one individual loss is numerically much larger than the others, optimization can be driven mainly by that task. Loss weights change each loss's contribution before the global loss is formed, helping balance outputs whose losses have different numerical scales.

Debugging the Data Path

A multi-input model can fail at several distinct boundaries. Treat it as a trace: data enters an input node, passes through its branch, reaches the merge operation, and contributes to the output. For a multi-output model, trace each prediction head to its loss, optional weight, and target data. The most useful debugging question is where the actual path first differs from the intended graph.

• Supplying list-based inputs in an order different from the model's input order.

  List-based training pairs arrays by position, so a changed order sends data to the wrong branch.

  Fix: Check the model's input order before supplying a list, or use named inputs with a dictionary.

• Using dictionary-based inputs without matching the model's input names.

  Dictionary-based training relies on input names to make the pairing explicit.

  Fix: Compare every dictionary key with the model's input names.

• Treating every output as if it represented the same task.

  The output heads represent different prediction tasks and need losses suited to those tasks.

  Fix: Trace each head to its task-appropriate loss.

• Assuming a plain combination of losses gives every task equal influence.

  Different numerical scales can make one loss contribute more strongly to the global optimization signal.

  Fix: Inspect the loss scales and consider loss weights.

• Inspecting only the final prediction when a multi-input model behaves unexpectedly.

  The model is a graph with several boundaries, not one undifferentiated object.

  Fix: Trace data mapping, each input branch, the merge operation, and the output path separately.

Practice the Trace

1. A multi-input Keras model gives each data source an independent branch before merging the branch representations. Named input nodes support dictionary-based training, while list-based training depends on preserving input order. A merge operation such as concatenate or add determines how branch outputs meet. A multi-output model can reuse a shared representation for several named prediction heads. Each head needs a task-appropriate loss and target data, and Keras combines the individual losses into one global optimization loss. Loss weights help when one loss has a much larger numerical scale. When debugging, trace the actual data path from mapping to branch, merge, output, target, loss, and optional weight.