Classification with Softmax Outputs

From Separate Data to One Answer

A single-input model receives one stream of data. A multi-input model receives several streams, sends each stream through its own path, and combines the resulting representations before producing an output. This is why a multi-input model should not be viewed as one straight sequence of layers. Its structure is a graph with branches that eventually meet.

The Two-Input Graph

The Keras functional API is designed for graph-shaped models. A two-input model begins with two input nodes. Each input is passed through its own branch encoder. The branch outputs then meet at a Keras merge operation, such as concatenate or add. The merged representation is passed to an output layer that produces the answer tensor.

text_input = keras.Input(name="text")
question_input = keras.Input(name="question")

text_representation = text_encoder(text_input)
question_representation = question_encoder(question_input)

merged = keras.layers.concatenate(
    [text_representation, question_representation]
)
answer = output_layer(merged)

model = keras.Model(
    inputs=[text_input, question_input],
    outputs=answer
)

This code is a structural example. The important path is explicit: the text input enters the text branch, the question input enters the question branch, both branch representations reach the merge operation, and the output layer receives the merged result. The Model construction receives both input tensors and produces the answer tensor.

Choosing the Merge Operation

Concatenation and addition are not interchangeable descriptions of the graph. They are different merge operations, and the choice determines how the branch representations are brought together. When a multi-input model behaves unexpectedly, inspect the merge line instead of assuming that every merge combines information in the same way.

Supplying Training Data

Training data must preserve the model's input structure. The source describes two supported forms. A list supplies arrays in the same order as the model's inputs. A dictionary supplies arrays by input name. Dictionary-based training requires named inputs.

model.fit(
    [text_array, question_array],
    answer_array
)

model.fit(
    {
        "text": text_array,
        "question": question_array
    },
    answer_array
)

In the list form, position carries the meaning: the first array belongs to the first model input, and the second array belongs to the second model input. In the dictionary form, the names carry the meaning: the array under text is associated with the input named text, and the array under question is associated with the input named question.

Tracing a Failure

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

• Checking only the final classifier when the real problem is earlier in the graph.

  The final output depends on the paths and merge operation that came before it.

  Fix: Inspect the input branches first, then the merge stage, and only then the final classifier.

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

  List-based training maps arrays by position.

  Fix: Compare the list order with the model's declared input order before training.

• Using dictionary-based training with names that do not identify the model inputs.

  Dictionary-based training relies on input names.

  Fix: Use the model's input names as the dictionary keys.

• Assuming concatenate and add represent the same merge behavior.

  The merge operation determines how the branch representations are brought together.

  Fix: Inspect the merge line and verify that it uses the intended Keras operation.

Practice the Trace

Key Takeaways

1. A multi-input Keras functional model gives each data source its own branch before combining the branch representations.
2. A two-input graph contains input layers, branch encoders, a merge operation, and an output layer.
3. Concatenate and add are different Keras merge operations, so the merge line deserves deliberate inspection.
4. List-based training data maps by model input order, while dictionary-based training data maps by named inputs.
5. When debugging, trace the actual data path from training-data mapping to input branches to the merge stage and then to the output.