Sequential model API in TensorFlow

Introduction

The Sequential model API helps you build a simple stack of layers for machine learning models easily. It lets you create models step-by-step, like stacking blocks.

When you want to build a straightforward neural network with layers in order.

When you are learning how to create models and want a simple way to add layers.

When your model has one input and one output without complex connections.

When you want to quickly test ideas with a simple model structure.

When you need to build common models like basic classifiers or regressors.

Syntax

TensorFlow

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

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

The layers are added in the order you list them inside the Sequential constructor.

The first layer needs to know the shape of the input data using input_shape.

Examples

Adding layers one by one using add() method instead of passing a list.

TensorFlow

model = Sequential()
model.add(Dense(32, activation='relu', input_shape=(100,)))
model.add(Dense(1, activation='sigmoid'))

Creating a model with three layers in one step using a list.

TensorFlow

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

Sample Model

This example builds a simple Sequential model with two layers to classify data into 3 classes. It trains on 5 samples and then predicts probabilities for 2 new samples.

TensorFlow

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

# Create a simple model for classifying 3 classes
model = Sequential([
    Dense(16, activation='relu', input_shape=(4,)),
    Dense(3, activation='softmax')
])

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

# Sample data: 5 samples, 4 features each
import numpy as np
x_train = np.array([[5.1, 3.5, 1.4, 0.2],
                    [6.2, 3.4, 5.4, 2.3],
                    [5.9, 3.0, 4.2, 1.5],
                    [6.0, 2.2, 4.0, 1.0],
                    [5.5, 2.3, 4.0, 1.3]])

# Labels for 3 classes
y_train = np.array([0, 2, 1, 1, 1])

# Train the model for 5 epochs
history = model.fit(x_train, y_train, epochs=5, verbose=0)

# Predict class probabilities for new data
x_test = np.array([[5.0, 3.6, 1.4, 0.2],
                   [6.7, 3.1, 4.7, 1.5]])
predictions = model.predict(x_test)

print('Predictions:')
print(predictions)
print('Training accuracy after 5 epochs:', history.history['accuracy'][-1])

Important Notes

Sequential models are best for simple, linear stacks of layers.

For models with multiple inputs or outputs, use the Functional API instead.

Always specify input_shape in the first layer to tell the model what data to expect.

Summary

The Sequential API lets you build models by stacking layers in order.

It is easy to use and great for beginners and simple problems.

Remember to compile the model before training to set loss and optimizer.

Practice

1. What is the main purpose of the Sequential model API in TensorFlow?

easy

A. To visualize the training process of a model

B. To create complex models with multiple inputs and outputs

C. To perform data preprocessing before training

D. To build a model by stacking layers in a linear order

Solution

1. Step 1: Understand the Sequential API purpose

   The Sequential API is designed to build models by stacking layers one after another in a simple linear fashion.

2. Step 2: Compare options with the API's function

   Options B, C, and D describe other functionalities not related to the Sequential API's main purpose.

3. Final Answer:

   To build a model by stacking layers in a linear order -> Option D

4. Quick Check:

   Sequential API = linear stacking of layers [OK]

Hint: Sequential means layers stacked one after another [OK]

Common Mistakes:

• Confusing Sequential with Functional API for complex models
• Thinking Sequential handles data preprocessing
• Assuming Sequential is for visualization

2. Which of the following is the correct way to create a Sequential model with one dense layer of 10 units in TensorFlow?

easy

A. model = Sequential(Dense(10))

B. model = Sequential([Dense(10)])

C. model = Sequential().add(Dense(10))

D. model = Sequential.add(Dense(10))

Solution

1. Step 1: Recall correct Sequential model creation syntax

   The Sequential model can be created by passing a list of layers inside the constructor, e.g., Sequential([Dense(10)]).

2. Step 2: Check each option's syntax validity

   model = Sequential([Dense(10)]) uses the correct list syntax. model = Sequential(Dense(10)) misses the list brackets. model = Sequential().add(Dense(10)) is valid usage but requires assignment to a variable to keep the model reference. model = Sequential.add(Dense(10)) incorrectly calls add() on the class, not an instance.

3. Final Answer:

   model = Sequential([Dense(10)]) -> Option B

4. Quick Check:

   Sequential needs list of layers in constructor [OK]

Hint: Pass layers as a list inside Sequential() [OK]

Common Mistakes:

• Omitting brackets around layers list
• Calling add() on class instead of instance
• Chaining add() without assignment

3. What will be the output shape of the model after running this code?

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

model = Sequential([
    Dense(5, input_shape=(10,)),
    Dense(3)
])
print(model.output_shape)

medium

A. (None, 5)

B. (10, 3)

C. (None, 3)

D. (5, 3)

Solution

1. Step 1: Understand input and output shapes in Sequential

   The input shape is (10,), so the first Dense layer outputs (None, 5). The second Dense layer outputs (None, 3) because it has 3 units.

2. Step 2: Identify final output shape

   The model's output shape is the output of the last layer, which is (None, 3). None means batch size is flexible.

3. Final Answer:

   (None, 3) -> Option C

4. Quick Check:

   Last Dense units = output shape [OK]

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

Common Mistakes:

• Confusing input shape with output shape
• Using batch size instead of None
• Mixing layer output shapes

4. Identify the error in this Sequential model code:

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

model = Sequential()
model.add(Dense(10, input_shape=(5,)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
model.fit(x_train, y_train, epochs=5)

medium

A. x_train and y_train are not defined

B. Sequential model cannot use add() method

C. Loss function 'mse' is invalid

D. Missing import for optimizer

Solution

1. Step 1: Check code for missing definitions

   The code uses x_train and y_train in model.fit() but they are not defined anywhere, causing a runtime error.

2. Step 2: Verify other parts

   Optimizer 'adam' and loss 'mse' are valid strings. add() method is valid for Sequential instances. Imports are sufficient.

3. Final Answer:

   x_train and y_train are not defined -> Option A

4. Quick Check:

   Undefined training data causes error [OK]

Hint: Check if training data variables are defined before fit() [OK]

Common Mistakes:

• Assuming loss 'mse' is invalid
• Thinking add() method is not allowed
• Ignoring missing data variables

5. You want to build a Sequential model for a classification task with 3 classes. Which of the following is the best final layer and loss combination?

hard

A. Dense(3, activation='softmax') with loss='categorical_crossentropy'

B. Dense(1, activation='sigmoid') with loss='mean_squared_error'

C. Dense(3, activation='relu') with loss='binary_crossentropy'

D. Dense(3) with loss='sparse_categorical_crossentropy'

Solution

1. Step 1: Understand classification output requirements

   For 3 classes, the final layer should have 3 units with softmax activation to output class probabilities.

2. Step 2: Match appropriate loss function

   For one-hot encoded labels, 'categorical_crossentropy' is the correct loss function to use with softmax output.

3. Final Answer:

   Dense(3, activation='softmax') with loss='categorical_crossentropy' -> Option A

4. Quick Check:

   Softmax + categorical_crossentropy = multi-class classification [OK]

Hint: Use softmax + categorical_crossentropy for multi-class tasks [OK]

Common Mistakes:

• Using sigmoid for multi-class output
• Using mean squared error for classification
• Missing activation in final layer