Functional API basics in TensorFlow - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output shape of a Functional API model

Consider the following TensorFlow Functional API model. What is the shape of the output tensor?

TensorFlow

import tensorflow as tf
inputs = tf.keras.Input(shape=(32,))
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
outputs = tf.keras.layers.Dense(10)(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
print(model.output_shape)

A (32, 64)

B (32, 10)

C (None, 64)

D (None, 10)

💡 Hint

Remember the first dimension is batch size and is None by default.

The model input shape is (32,), so the output shape is (None, 10) where None is the batch size.

❓ Model Choice

intermediate

Choosing the correct Functional API model for multiple inputs

You want to build a model that takes two inputs: one with shape (10,) and another with shape (5,). Which Functional API model code correctly defines this?

A

input1 = tf.keras.Input(shape=(10,))
input2 = tf.keras.Input(shape=(5,))
concat = tf.keras.layers.Concatenate()([input1, input2])
output = tf.keras.layers.Dense(1)(concat)
model = tf.keras.Model(inputs=[input1, input2], outputs=output)

B

input1 = tf.keras.Input(shape=(10,))
input2 = tf.keras.Input(shape=(5,))
concat = tf.keras.layers.Dense(15)(input1)
output = tf.keras.layers.Dense(1)(concat)
model = tf.keras.Model(inputs=[input1, input2], outputs=output)

C

input1 = tf.keras.Input(shape=(10,))
input2 = tf.keras.Input(shape=(5,))
concat = tf.keras.layers.Multiply()([input1, input2])
output = tf.keras.layers.Dense(1)(concat)
model = tf.keras.Model(inputs=[input1, input2], outputs=output)

D

input1 = tf.keras.Input(shape=(10,))
input2 = tf.keras.Input(shape=(5,))
concat = tf.keras.layers.Add()([input1, input2])
output = tf.keras.layers.Dense(1)(concat)
model = tf.keras.Model(inputs=[input1, input2], outputs=output)

💡 Hint

Concatenate layer joins inputs along last axis; Add and Multiply require same shape inputs.

Option A correctly concatenates two inputs of different shapes. Add and Multiply layers require inputs of the same shape, so A and C are invalid. Option A ignores input2.

❓ Hyperparameter

advanced

Effect of activation function in Functional API model

In a Functional API model, you replace the activation in a Dense layer from 'relu' to 'linear'. What is the most likely effect on the model's training?

A The model will train faster because linear activation is simpler.

B The model may train slower or fail to learn complex patterns due to lack of non-linearity.

C The model will always overfit because linear activation increases complexity.

D The model will have better accuracy because linear activation avoids vanishing gradients.

💡 Hint

Activation functions add non-linearity needed for learning complex data.

Replacing 'relu' with 'linear' removes non-linearity, limiting the model's ability to learn complex patterns, often causing slower or failed training.

🔧 Debug

advanced

Identifying error in Functional API model definition

What error will this Functional API code raise when run?

TensorFlow

import tensorflow as tf
inputs = tf.keras.Input(shape=(20,))
x = tf.keras.layers.Dense(10)(inputs)
outputs = tf.keras.layers.Dense(5)(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer='adam', loss='mse')

A TypeError: Inputs and outputs must be layers or tensors connected in a graph.

B ValueError: Output tensor must be connected to the input tensor.

C No error; model compiles successfully.

D RuntimeError: Model outputs must come from the last layer applied to inputs.

💡 Hint

Outputs can be any tensor derived from inputs, not necessarily last layer.

The code defines outputs directly from inputs, which is valid. Model compiles without error.

🧠 Conceptual

expert

Understanding model summary in Functional API

Given a Functional API model with two input layers merged by Concatenate and followed by two Dense layers, what does the model.summary() show for the total params if the first Dense layer has 8 units and the second has 4 units? Assume input shapes are (3,) and (2,).

A Total params = (3+2)*8 + 8 + 8*4 + 4 = 84

B Total params = (3+2)*8 + 8 + (3+2)*4 + 4 = 72

C Total params = (3+2)*8 + 8 + 8*4 + 4*2 = 70

D Total params = (3+2)*8 + 8 + 8*4 + 4*1 = 66

💡 Hint

Calculate params as (input_dim * units) + bias per Dense layer, sum all layers.

Concatenate merges inputs to dimension 5. First Dense(8): 5*8 + 8 = 48 params. Second Dense(4): 8*4 + 4 = 36 params. Total: 84. Option A shows the correct calculation.

Practice

1. What is the main advantage of using TensorFlow's Functional API over the Sequential API?

easy

A. It allows building models with multiple inputs and outputs.

B. It automatically tunes hyperparameters.

C. It requires less code to build simple models.

D. It only supports linear stacks of layers.

Solution

1. Step 1: Understand Functional API capabilities

   The Functional API allows explicit connections between layers, supporting complex architectures.

2. Step 2: Compare with Sequential API

   Sequential API only supports simple linear stacks, while Functional API supports multiple inputs and outputs.

3. Final Answer:

   It allows building models with multiple inputs and outputs. -> Option A

4. Quick Check:

   Functional API = multiple inputs/outputs [OK]

Hint: Functional API supports complex models with multiple inputs/outputs [OK]

Common Mistakes:

• Thinking Functional API is simpler for linear models
• Confusing hyperparameter tuning with model building
• Assuming Sequential API supports multiple inputs

2. Which of the following is the correct way to start defining a model using the Functional API?

easy

A. inputs = tf.keras.Input(shape=(32,))

B. inputs = tf.keras.layers.Dense(32)

C. model = tf.keras.Model()

D. model = tf.keras.Sequential()

Solution

1. Step 1: Identify how to define input in Functional API

   Functional API starts with tf.keras.Input() to define the input shape.

2. Step 2: Check other options

   Sequential() is for Sequential API, Model() requires inputs and outputs, Dense is a layer, not input.

3. Final Answer:

   inputs = tf.keras.Input(shape=(32,)) -> Option A

4. Quick Check:

   Start Functional API with Input() [OK]

Hint: Use Input() to start Functional API models [OK]

Common Mistakes:

• Using Sequential() instead of Input() to start
• Trying to create Model() without inputs and outputs
• Confusing layers with input definitions

3. What will be the output shape of the model defined below?

inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(5)(inputs)
outputs = tf.keras.layers.Dense(2)(x)
model = tf.keras.Model(inputs, outputs)
print(model.output_shape)

medium

A. (None, 10)

B. (10, 2)

C. (None, 5)

D. (None, 2)

Solution

1. Step 1: Trace the model layers

   Input shape is (10,), first Dense layer outputs (5,), second Dense outputs (2,).

2. Step 2: Understand output shape format

   Output shape includes batch size None, so final output shape is (None, 2).

3. Final Answer:

   (None, 2) -> Option D

4. Quick Check:

   Output shape = (None, 2) [OK]

Hint: Output shape matches last layer units with batch None [OK]

Common Mistakes:

• Confusing input shape with output shape
• Ignoring batch dimension None
• Mixing layer output sizes

4. Identify the error in this Functional API model code:

inputs = tf.keras.Input(shape=(8,))
x = tf.keras.layers.Dense(4)(inputs)
outputs = tf.keras.layers.Dense(1)(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

medium

A. Input shape must be (4,), not (8,).

B. Output layer should connect to x, not inputs.

C. Model() requires no arguments.

D. Dense layers cannot be used in Functional API.

Solution

1. Step 1: Check layer connections

   The output layer is connected directly to inputs, skipping the intermediate Dense layer x.

2. Step 2: Correct the output connection

   Output should connect to x to use the transformed data, not inputs.

3. Final Answer:

   Output layer should connect to x, not inputs. -> Option B

4. Quick Check:

   Output must connect to last layer, not input [OK]

Hint: Connect outputs to last layer, not inputs [OK]

Common Mistakes:

• Connecting output directly to inputs
• Changing input shape unnecessarily
• Misunderstanding Model() arguments

5. You want to build a model with two inputs: one for images (shape 64x64x3) and one for metadata (shape 10). Which Functional API code snippet correctly defines the inputs?

hard

A. img_input = tf.keras.layers.Input(shape=(64,64,3))
meta_input = tf.keras.layers.Input(shape=(10,))

B. inputs = tf.keras.Input(shape=(64,64,3,10))

C. img_input = tf.keras.Input(shape=(64,64,3))
meta_input = tf.keras.Input(shape=(10,))

D. inputs = tf.keras.Input(shape=(64,64,3))
inputs = tf.keras.Input(shape=(10,))

Solution

1. Step 1: Define separate inputs for each data type

   Functional API allows multiple inputs by defining each with tf.keras.Input and correct shapes.

2. Step 2: Check each option for correctness

   img_input = tf.keras.Input(shape=(64,64,3)) meta_input = tf.keras.Input(shape=(10,)) correctly defines two inputs separately; B merges shapes incorrectly; A uses wrong module; D overwrites inputs variable.

3. Final Answer:

   img_input = tf.keras.Input(shape=(64,64,3)) meta_input = tf.keras.Input(shape=(10,)) -> Option C

4. Quick Check:

   Multiple inputs need separate Input() calls [OK]

Hint: Use separate Input() for each input tensor [OK]

Common Mistakes:

• Combining input shapes incorrectly
• Using layers.Input instead of keras.Input
• Overwriting input variables