5 Effective Techniques to Build Sequential Models in TensorFlow Using Python

Rate this post

πŸ’‘ Problem Formulation: When approaching a machine learning problem, one might have a dataset with features as inputs and a target variable as output. The goal is to create a predictive model that can take new instances of data and predict the output with high accuracy. This article will explain how TensorFlow can be used to build a Sequential model in Python, aimed at addressing such predictive tasks.

Method 1: Using Sequential API to Stack Layers

The Sequential API is a straightforward and intuitive way to build models in TensorFlow. By stacking layers linearly, one can easily create a model for simple architectures. Each layer has its own function specification, like Dense for fully connected layers, Conv2D for convolutional layers, and so on.

Here’s an example:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(64, activation='relu', input_shape=(784,)),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Output of this code snippet is not visible since it defines a model structure and compiles it. It doesn’t produce a result without fitting the model to data.

This code snippet constructs a Sequential model with three layers using TensorFlow’s Keras API. The input layer expects data of shape (784,) and uses ReLU activation. A second ReLU-activated layer follows with the same number of units, and the output layer has 10 units with a softmax activation, suitable for a ten-class classification.

Method 2: Adding Layers Sequentially

For more flexibility, layers can be added incrementally to the Sequential model using the add() method. This allows more dynamic decision-making while building the model architecture.

Here’s an example:

model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(784,)))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))

Output of this code snippet is a text summary of the neural network’s architecture, detailing the layers, their shapes, and the number of parameters.

This code builds the same model as in Method 1 but adds each layer using the add() function. After constructing the model, model.summary() prints a summary of the model’s architecture, showing layer types, output shapes, and parameter counts.

Method 3: Functional API for Complex Architectures

TensorFlow’s Functional API allows for the creation of more complex models that might have multiple inputs or outputs, shared layers, or non-sequential data flows. It offers more control and customization over the model architecture.

Here’s an example:

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

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)
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Output of this code snippet is not visible as it pertains to model construction and compilation and requires data to produce results.

This code snippet utilizes TensorFlow’s Functional API to define a more complex model. It starts with an Input layer to specify the shape of the incoming data, then stacks Dense layers; finally, it creates a Model instance specifying the inputs and outputs.

Method 4: Subclassing the Model Class for Custom Behaviors

Subclassing the Model class in TensorFlow offers maximal flexibility by defining custom layers and forward passes. You design your own model class, which is especially useful for complex models and research.

Here’s an example:

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense

class MyModel(Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.dense1 = Dense(64, activation='relu')
        self.dense2 = Dense(64, activation='relu')
        self.dense3 = Dense(10, activation='softmax')

    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dense2(x)
        return self.dense3(x)

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

Output of this code snippet is a custom-built model with no visible output via the compiler until it’s fit to data.

In this snippet, a custom model MyModel is defined by subclassing the Model class. This approach allows customized forward passes and can be beneficial when experimental architectures are needed.

Bonus One-Liner Method 5: Using tf.keras.Sequential for Quick Prototyping

For swift experimentation, TensorFlow provides tf.keras.Sequential, which can be used for quick prototyping of simple models with minimal lines of code.

Here’s an example:

model = tf.keras.Sequential([tf.keras.layers.Dense(10, activation='softmax', input_shape=(784,))])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

This code snippet demonstrates a very basic model intended for quick prototyping. This approach is best when speed is more critical than the complexity or customization of the model.


  • Method 1: Sequential API Stack. Simple to use. Limited to linear architectures.
  • Method 2: Add Layers Sequentially. More flexibility. Still limited to linear stacking.
  • Method 3: Functional API. Suited for complex architectures. Higher learning curve.
  • Method 4: Subclassing Model. Maximum customization. May result in more complex and harder to debug code.
  • Method 5: Quick Prototyping. Fastest way to build and test simple models. Not suitable for complex architecture needs.