Introduction to Functional API: Unlocking the Unlimited Possibilities of Neural Network Architectures | by Adyuta Indra Adyatma | Jun, 2024

If you are working with deep learning, you’re probably familiar with the Sequential model. It’s easy to use, and straightforward, stacking layers one after another to solve neural network problems. But as you dive deeper into AI, you’ll find that many challenges require more flexibility and complexity. That is where Functional API comes in handy.

The Functional API in TensorFlow offers a versatile way to build sophisticated, non-linear architectures. Whether you’re managing multiple inputs and outputs or designing intricate layer connections, this tool provides the freedom to innovate and unlock many more possibilities.

TensorFlow Functional API is a powerful tool that allows the creation of more complex, and flexible neural network architectures beyond the possibilities and limitations of the Sequential models. While the Sequential model is linear stacks of layers, it falls short when dealing with more intricate network problems that require multiple inputs, outputs, or non-linear connections.

With the Functional API, you have full control over the flow of the data inputs through the network, enabling you to tailor your own architectures to your specific requirements. This flexibility is useful for building models that:

• Have multiple input and output layers, that you need to process images and text simultaneously.
• Share layers, such as models that reuse the same layers across different branches.
• Have non-linear topologies, such as residual networks or Inception modules that include skipping connections or parallel branches.

This is particularly beneficial when dealing with advanced model architecture and tasks such as Residual Networks (ResNet), Siamese Networks, object localization, and many more.

In this article, I’m assuming that you’re already familiar with the code to build a sequential model as shown on these example:

import tensorflow as tf
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28,28))
tf.keras.layers.Dense(128, activation='relu')
tf.keras.layers.Dense(10)
])

In the provided code snippet, a Sequential model architecture is achieved by using the Sequential() class. Let’s try to build the same model architecture using the Functional API. Here are the following four steps:

1. Define the input layer
2. Define a set of interconnected layers
3. Define the output layers
4. Define the model using the input and output layers.

Here are the code snippet that demonstrated building the model architectures:

import tensorflow as tf
# Instantiate the input layer
inputs = tf.keras.Input(shape=(28,28))
# Stack the layers
flatten_layer = tf.keras.layers.Flatten()(inputs)
first_dense = tf.keras.layers.Dense(128, activation='relu')(flatten_layer)
# Define the output layer
output_layer = tf.keras.layers.Dense(10, activation='softmax')(first_dense)
# Define the model
model = tf.keras.models.Model(inputs=inputs, outputs=output_layer, name="Model")