Skip to main content

TensorFlow Functional API

Introduction​

TensorFlow provides multiple ways to build neural networks, and the Functional API is one of the most flexible approaches. While the Sequential API is great for simple, linear stacks of layers, the Functional API allows you to create models with non-linear topology, shared layers, and multiple inputs or outputs.

In this tutorial, you'll learn:

  • What the Functional API is and how it differs from the Sequential API
  • How to create basic models using the Functional API
  • How to build complex architectures like multi-input/multi-output models
  • When and why to choose the Functional API over other approaches

Understanding the Functional API​

The Functional API is a way to create models that is more flexible than the Sequential API. It works by creating instances of layers and then connecting them directly to each other in pairs, forming a graph of layers.

Sequential vs. Functional API​

Let's first recall how we build a model with the Sequential API:

python
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Input

# Sequential model
model = Sequential([
    Dense(64, activation='relu', input_shape=(784,)),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

Now, here's how we would build the same model with the Functional API:

python
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, Input

# Functional API model
inputs = Input(shape=(784,))
x = Dense(64, activation='relu')(inputs)
x = Dense(64, activation='relu')(x)
outputs = Dense(10, activation='softmax')(x)

model = Model(inputs=inputs, outputs=outputs)

The key difference is that in the Functional API, you explicitly create an input tensor and pass it through a series of layer transformations until you reach your output. Finally, you create a Model by specifying its inputs and outputs.

Building Your First Functional Model​

Let's build a simple model for classifying the MNIST dataset:

python
import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, Flatten, Input
from tensorflow.keras.datasets import mnist
import numpy as np

# Load and preprocess data
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Define the model using the Functional API
inputs = Input(shape=(28, 28))
x = Flatten()(inputs)
x = Dense(128, activation='relu')(x)
x = Dense(64, activation='relu')(x)
outputs = Dense(10, activation='softmax')(x)

model = Model(inputs=inputs, outputs=outputs)

# Compile the model
model.compile(optimizer='adam', 
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Display the model summary
model.summary()

Output of model.summary():

Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         [(None, 28, 28)]          0         
_________________________________________________________________
flatten (Flatten)            (None, 784)               0         
_________________________________________________________________
dense (Dense)                (None, 128)               100480    
_________________________________________________________________
dense_1 (Dense)              (None, 64)                8256      
_________________________________________________________________
dense_2 (Dense)              (None, 10)                650       
=================================================================
Total params: 109,386
Trainable params: 109,386
Non-trainable params: 0
_________________________________________________________________

Now you can train the model:

python
# Train the model
model.fit(x_train, y_train, 
          batch_size=128, 
          epochs=5, 
          validation_split=0.1)

# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.4f}")

Advanced Models with the Functional API​

Multi-Input Models​

One of the major advantages of the Functional API is the ability to build models with multiple inputs. Let's create a model that takes both numerical and categorical features:

python
from tensorflow.keras.layers import Input, Dense, Embedding, Concatenate, Flatten
from tensorflow.keras.models import Model

# Numerical features input
numerical_input = Input(shape=(5,), name='numerical_features')
numerical_features = Dense(32, activation='relu')(numerical_input)

# Categorical features input
categorical_input = Input(shape=(3,), name='categorical_features')
embedding = Embedding(input_dim=100, output_dim=8)(categorical_input)
flattened_embedding = Flatten()(embedding)

# Combine features
concatenated = Concatenate()([numerical_features, flattened_embedding])
x = Dense(64, activation='relu')(concatenated)
output = Dense(1, activation='sigmoid')(x)

# Create model with multiple inputs
model = Model(inputs=[numerical_input, categorical_input], outputs=output)

model.compile(optimizer='adam', loss='binary_crossentropy')

# Display model
model.summary()

When using a multi-input model, you need to provide a list or dictionary of inputs during training:

python
# Example data (simulated)
import numpy as np

# Generate some dummy data
n_samples = 1000
numerical_data = np.random.random((n_samples, 5))
categorical_data = np.random.randint(0, 100, (n_samples, 3))
labels = np.random.randint(0, 2, (n_samples, 1))

# Train the model
model.fit(
    [numerical_data, categorical_data],  # List of inputs
    labels,
    epochs=3,
    batch_size=32
)

# You can also use a dictionary if you named your inputs
model.fit(
    {'numerical_features': numerical_data, 'categorical_features': categorical_data},
    labels,
    epochs=3,
    batch_size=32
)

Multi-Output Models​

Similarly, we can create models with multiple outputs:

python
from tensorflow.keras.layers import Input, Dense, Flatten
from tensorflow.keras.models import Model

# Input layer
inputs = Input(shape=(28, 28))
x = Flatten()(inputs)
shared = Dense(128, activation='relu')(x)

# First output branch: classification
classification_output = Dense(10, activation='softmax', name='classification')(shared)

# Second output branch: reconstruction
reconstruction_output = Dense(784, activation='sigmoid', name='reconstruction')(shared)

# Create multi-output model
model = Model(inputs=inputs, outputs=[classification_output, reconstruction_output])

# We need to specify loss and metrics for each output
model.compile(
    optimizer='adam',
    loss={
        'classification': 'categorical_crossentropy',
        'reconstruction': 'binary_crossentropy'
    },
    metrics={
        'classification': 'accuracy',
        'reconstruction': 'mse'
    }
)

model.summary()

When training a multi-output model, you need to provide a list or dictionary of targets:

python
# Reshape targets for the reconstruction output
x_train_flat = x_train.reshape(-1, 784)

# Train the model with multiple outputs
model.fit(
    x_train,
    {'classification': y_train, 'reconstruction': x_train_flat},
    epochs=5,
    batch_size=128,
    validation_split=0.1
)

Shared Layers and Model Reuse​

Another powerful feature of the Functional API is the ability to share layers between different parts of your model:

python
from tensorflow.keras.layers import Input, Dense, LSTM
from tensorflow.keras.models import Model

# Shared layer
shared_lstm = LSTM(64)

# First input and its branch
input_1 = Input(shape=(None, 10))
output_1 = shared_lstm(input_1)

# Second input and its branch
input_2 = Input(shape=(None, 10))
output_2 = shared_lstm(input_2)

# Merge branches
merged = Concatenate()([output_1, output_2])
output = Dense(1, activation='sigmoid')(merged)

model = Model(inputs=[input_1, input_2], outputs=output)
model.summary()

This model will process two different sequences using the same LSTM layer, meaning the layer's weights are shared between both pathways.

Complex Model Architectures​

The Functional API makes it easy to implement complex architectures like Residual Networks (ResNets) that use skip connections:

python
from tensorflow.keras.layers import Input, Conv2D, BatchNormalization, Activation
from tensorflow.keras.layers import Add, GlobalAveragePooling2D, Dense
from tensorflow.keras.models import Model

def residual_block(x, filters, kernel_size=3, stride=1):
    # Shortcut connection
    shortcut = x
    
    # First convolutional layer
    y = Conv2D(filters, kernel_size=kernel_size, strides=stride, padding='same')(x)
    y = BatchNormalization()(y)
    y = Activation('relu')(y)
    
    # Second convolutional layer
    y = Conv2D(filters, kernel_size=kernel_size, strides=1, padding='same')(y)
    y = BatchNormalization()(y)
    
    # If dimensions changed, adjust shortcut
    if stride != 1 or x.shape[-1] != filters:
        shortcut = Conv2D(filters, kernel_size=1, strides=stride, padding='same')(shortcut)
        shortcut = BatchNormalization()(shortcut)
    
    # Add shortcut to main path
    output = Add()([y, shortcut])
    output = Activation('relu')(output)
    
    return output

# Build a simple ResNet
inputs = Input(shape=(32, 32, 3))
x = Conv2D(32, kernel_size=3, padding='same')(inputs)
x = BatchNormalization()(x)
x = Activation('relu')(x)

# Add residual blocks
x = residual_block(x, filters=32)
x = residual_block(x, filters=32)
x = residual_block(x, filters=64, stride=2)
x = residual_block(x, filters=64)

# Final layers
x = GlobalAveragePooling2D()(x)
outputs = Dense(10, activation='softmax')(x)

# Create model
resnet_model = Model(inputs=inputs, outputs=outputs)
resnet_model.summary()

When to Use the Functional API​

The Functional API is best suited for situations where:

  1. You need multiple inputs or outputs
  2. Your model has non-sequential data flows (like residual connections)
  3. You want to share layers across different parts of the model
  4. You're implementing complex architectures from research papers
  5. You need more fine-grained control over your model structure

If your model is just a simple stack of layers that process data linearly, the Sequential API might be more concise and easier to use.

Best Practices​

  1. Name your layers: Add a name parameter to important layers for easier model debugging.
  2. Create reusable blocks: Define functions that create commonly used layer patterns.
  3. Visualize your model: Use tf.keras.utils.plot_model(model, 'model.png', show_shapes=True) to get a visual representation of your model architecture.
  4. Check model.summary(): Always check your model summary to ensure layers are connected as expected.
  5. Use Model subclassing for even more complex behaviors that can't be expressed through layer connections alone.

Summary​

In this tutorial, you've learned how to use TensorFlow's Functional API to create neural networks with complex architectures. The Functional API offers several advantages over the Sequential API, including:

  • Support for multiple inputs and outputs
  • Non-linear layer connectivity
  • Ability to share layers between different parts of the model
  • Implementing advanced architectures like ResNets

These capabilities make the Functional API a powerful tool for creating sophisticated neural network models for a variety of applications.

Exercises​

  1. Convert a Sequential model you've previously built into a model using the Functional API.
  2. Create a multi-input model that combines image data (using convolutional layers) and tabular data (using dense layers).
  3. Implement a simple autoencoder with the Functional API.
  4. Build a multi-task learning model that performs both classification and regression with shared early layers.
  5. Create a siamese network for similarity comparison using shared weights.

Additional Resources​


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)