How to Use the Keras Functional API for Deep Learning

 The Keras Python library makes creating deep learning models fast and easy.

The sequential API allows you to create models layer-by-layer for most problems. It is limited in that it does not allow you to create models that share layers or have multiple inputs or outputs.

The functional API in Keras is an alternate way of creating models that offers a lot more flexibility, including creating more complex models.

In this tutorial, you will discover how to use the more flexible functional API in Keras to define deep learning models.

After completing this tutorial, you will know:

• The difference between the Sequential and Functional APIs.
• How to define simple Multilayer Perceptron, Convolutional Neural Network, and Recurrent Neural Network models using the functional API.
• How to define more complex models with shared layers and multiple inputs and outputs.

Kick-start your project with my new book Deep Learning With Python, including step-by-step tutorials and the Python source code files for all examples.

Let’s get started.

• Update Nov/2017: Added note about hanging dimension for input layers.
• Update Nov/2018: Added missing flatten layer for CNN, thanks Konstantin.
• Update Nov/2018: Added description of the functional API Python syntax.

Tutorial Overview

This tutorial is divided into 7 parts; they are:

1. Keras Sequential Models
2. Keras Functional Models
3. Standard Network Models
4. Shared Layers Model
5. Multiple Input and Output Models
6. Best Practices
7. NEW: Note on the Functional API Python Syntax

1. Keras Sequential Models

As a review, Keras provides a Sequential model API.

If you are new to Keras or deep learning, see this step-by-step Keras tutorial.

The Sequential model API is a way of creating deep learning models where an instance of the Sequential class is created and model layers are created and added to it.

For example, the layers can be defined and passed to the Sequential as an array:

1 2 3

from keras.models import Sequential from keras.layers import Dense model = Sequential([Dense(2, input_dim=1), Dense(1)])

Layers can also be added piecewise:

1 2 3 4 5

from keras.models import Sequential from keras.layers import Dense model = Sequential() model.add(Dense(2, input_dim=1)) model.add(Dense(1))

The Sequential model API is great for developing deep learning models in most situations, but it also has some limitations.

For example, it is not straightforward to define models that may have multiple different input sources, produce multiple output destinations or models that re-use layers.

2. Keras Functional Models

The Keras functional API provides a more flexible way for defining models.

It specifically allows you to define multiple input or output models as well as models that share layers. More than that, it allows you to define ad hoc acyclic network graphs.

Models are defined by creating instances of layers and connecting them directly to each other in pairs, then defining a Model that specifies the layers to act as the input and output to the model.

Let’s look at the three unique aspects of Keras functional API in turn:

1. Defining Input

Unlike the Sequential model, you must create and define a standalone Input layer that specifies the shape of input data.

The input layer takes a shape argument that is a tuple that indicates the dimensionality of the input data.

When input data is one-dimensional, such as for a multilayer Perceptron, the shape must explicitly leave room for the shape of the mini-batch size used when splitting the data when training the network. Therefore, the shape tuple is always defined with a hanging last dimension when the input is one-dimensional (2,), for example:

1 2	from keras.layers import Input visible = Input(shape=(2,))

2. Connecting Layers

The layers in the model are connected pairwise.

This is done by specifying where the input comes from when defining each new layer. A bracket notation is used, such that after the layer is created, the layer from which the input to the current layer comes from is specified.

Let’s make this clear with a short example. We can create the input layer as above, then create a hidden layer as a Dense that receives input only from the input layer.

1 2 3 4

from keras.layers import Input from keras.layers import Dense visible = Input(shape=(2,)) hidden = Dense(2)(visible)

Note the (visible) after the creation of the Dense layer that connects the input layer output as the input to the dense hidden layer.

It is this way of connecting layers piece by piece that gives the functional API its flexibility. For example, you can see how easy it would be to start defining ad hoc graphs of layers.

3. Creating the Model

After creating all of your model layers and connecting them together, you must define the model.

As with the Sequential API, the model is the thing you can summarize, fit, evaluate, and use to make predictions.

Keras provides a Model class that you can use to create a model from your created layers. It requires that you only specify the input and output layers. For example:

1 2 3 4 5 6

from keras.models import Model from keras.layers import Input from keras.layers import Dense visible = Input(shape=(2,)) hidden = Dense(2)(visible) model = Model(inputs=visible, outputs=hidden)

Now that we know all of the key pieces of the Keras functional API, let’s work through defining a suite of different models and build up some practice with it.

Each example is executable and prints the structure and creates a diagram of the graph. I recommend doing this for your own models to make it clear what exactly you have defined.

My hope is that these examples provide templates for you when you want to define your own models using the functional API in the future.

3. Standard Network Models

When getting started with the functional API, it is a good idea to see how some standard neural network models are defined.

In this section, we will look at defining a simple multilayer Perceptron, convolutional neural network, and recurrent neural network.

These examples will provide a foundation for understanding the more elaborate examples later.

Multilayer Perceptron

In this section, we define a multilayer Perceptron model for binary classification.

The model has 10 inputs, 3 hidden layers with 10, 20, and 10 neurons, and an output layer with 1 output. Rectified linear activation functions are used in each hidden layer and a sigmoid activation function is used in the output layer, for binary classification.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# Multilayer Perceptron from keras.utils import plot_model from keras.models import Model from keras.layers import Input from keras.layers import Dense visible = Input(shape=(10,)) hidden1 = Dense(10, activation='relu')(visible) hidden2 = Dense(20, activation='relu')(hidden1) hidden3 = Dense(10, activation='relu')(hidden2) output = Dense(1, activation='sigmoid')(hidden3) model = Model(inputs=visible, outputs=output) # summarize layers print(model.summary()) # plot graph plot_model(model, to_file='multilayer_perceptron_graph.png')

Running the example prints the structure of the network.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

_________________________________________________________________ Layer (type)                 Output Shape              Param # ================================================================= input_1 (InputLayer)         (None, 10)                0 _________________________________________________________________ dense_1 (Dense)              (None, 10)                110 _________________________________________________________________ dense_2 (Dense)              (None, 20)                220 _________________________________________________________________ dense_3 (Dense)              (None, 10)                210 _________________________________________________________________ dense_4 (Dense)              (None, 1)                 11 ================================================================= Total params: 551 Trainable params: 551 Non-trainable params: 0 _________________________________________________________________

A plot of the model graph is also created and saved to file.

Multilayer Perceptron Network Graph

Convolutional Neural Network

In this section, we will define a convolutional neural network for image classification.

The model receives black and white 64×64 images as input, then has a sequence of two convolutional and pooling layers as feature extractors, followed by a fully connected layer to interpret the features and an output layer with a sigmoid activation for two-class predictions.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# Convolutional Neural Network from keras.utils import plot_model from keras.models import Model from keras.layers import Input from keras.layers import Dense from keras.layers import Flatten from keras.layers.convolutional import Conv2D from keras.layers.pooling import MaxPooling2D visible = Input(shape=(64,64,1)) conv1 = Conv2D(32, kernel_size=4, activation='relu')(visible) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(16, kernel_size=4, activation='relu')(pool1) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) flat = Flatten()(pool2) hidden1 = Dense(10, activation='relu')(flat) output = Dense(1, activation='sigmoid')(hidden1) model = Model(inputs=visible, outputs=output) # summarize layers print(model.summary()) # plot graph plot_model(model, to_file='convolutional_neural_network.png')

Running the example summarizes the model layers.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

_________________________________________________________________ Layer (type)                 Output Shape              Param #   ================================================================= input_1 (InputLayer)         (None, 64, 64, 1)         0         _________________________________________________________________ conv2d_1 (Conv2D)            (None, 61, 61, 32)        544       _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 30, 30, 32)        0         _________________________________________________________________ conv2d_2 (Conv2D)            (None, 27, 27, 16)        8208       _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 13, 13, 16)        0         _________________________________________________________________ flatten_1 (Flatten)          (None, 2704)              0         _________________________________________________________________ dense_1 (Dense)              (None, 10)                27050     _________________________________________________________________ dense_2 (Dense)              (None, 1)                 11         ================================================================= Total params: 35,813 Trainable params: 35,813 Non-trainable params: 0 _________________________________________________________________

A plot of the model graph is also created and saved to file.

Convolutional Neural Network Graph

Recurrent Neural Network

In this section, we will define a long short-term memory recurrent neural network for sequence classification.

The model expects 100 time steps of one feature as input. The model has a single LSTM hidden layer to extract features from the sequence, followed by a fully connected layer to interpret the LSTM output, followed by an output layer for making binary predictions.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# Recurrent Neural Network from keras.utils import plot_model from keras.models import Model from keras.layers import Input from keras.layers import Dense from keras.layers.recurrent import LSTM visible = Input(shape=(100,1)) hidden1 = LSTM(10)(visible) hidden2 = Dense(10, activation='relu')(hidden1) output = Dense(1, activation='sigmoid')(hidden2) model = Model(inputs=visible, outputs=output) # summarize layers print(model.summary()) # plot graph plot_model(model, to_file='recurrent_neural_network.png')

Running the example summarizes the model layers.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

_________________________________________________________________ Layer (type)                 Output Shape              Param # ================================================================= input_1 (InputLayer)         (None, 100, 1)            0 _________________________________________________________________ lstm_1 (LSTM)                (None, 10)                480 _________________________________________________________________ dense_1 (Dense)              (None, 10)                110 _________________________________________________________________ dense_2 (Dense)              (None, 1)                 11 ================================================================= Total params: 601 Trainable params: 601 Non-trainable params: 0 _________________________________________________________________

A plot of the model graph is also created and saved to file.

Recurrent Neural Network Graph

4. Shared Layers Model

Multiple layers can share the output from one layer.

For example, there may be multiple different feature extraction layers from an input, or multiple layers used to interpret the output from a feature extraction layer.

Let’s look at both of these examples.

Shared Input Layer

In this section, we define multiple convolutional layers with differently sized kernels to interpret an image input.

The model takes black and white images with the size 64×64 pixels. There are two CNN feature extraction submodels that share this input; the first has a kernel size of 4 and the second a kernel size of 8. The outputs from these feature extraction submodels are flattened into vectors and concatenated into one long vector and passed on to a fully connected layer for interpretation before a final output layer makes a binary classification.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# Shared Input Layer from keras.utils import plot_model from keras.models import Model from keras.layers import Input from keras.layers import Dense from keras.layers import Flatten from keras.layers.convolutional import Conv2D from keras.layers.pooling import MaxPooling2D from keras.layers.merge import concatenate # input layer visible = Input(shape=(64,64,1)) # first feature extractor conv1 = Conv2D(32, kernel_size=4, activation='relu')(visible) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) flat1 = Flatten()(pool1) # second feature extractor conv2 = Conv2D(16, kernel_size=8, activation='relu')(visible) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) flat2 = Flatten()(pool2) # merge feature extractors merge = concatenate([flat1, flat2]) # interpretation layer hidden1 = Dense(10, activation='relu')(merge) # prediction output output = Dense(1, activation='sigmoid')(hidden1) model = Model(inputs=visible, outputs=output) # summarize layers print(model.summary()) # plot graph plot_model(model, to_file='shared_input_layer.png')

Running the example summarizes the model layers.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

____________________________________________________________________________________________________ Layer (type)                     Output Shape          Param #     Connected to ==================================================================================================== input_1 (InputLayer)             (None, 64, 64, 1)     0 ____________________________________________________________________________________________________ conv2d_1 (Conv2D)                (None, 61, 61, 32)    544         input_1[0][0] ____________________________________________________________________________________________________ conv2d_2 (Conv2D)                (None, 57, 57, 16)    1040        input_1[0][0] ____________________________________________________________________________________________________ max_pooling2d_1 (MaxPooling2D)   (None, 30, 30, 32)    0           conv2d_1[0][0] ____________________________________________________________________________________________________ max_pooling2d_2 (MaxPooling2D)   (None, 28, 28, 16)    0           conv2d_2[0][0] ____________________________________________________________________________________________________ flatten_1 (Flatten)              (None, 28800)         0           max_pooling2d_1[0][0] ____________________________________________________________________________________________________ flatten_2 (Flatten)              (None, 12544)         0           max_pooling2d_2[0][0] ____________________________________________________________________________________________________ concatenate_1 (Concatenate)      (None, 41344)         0           flatten_1[0][0]                                                                    flatten_2[0][0] ____________________________________________________________________________________________________ dense_1 (Dense)                  (None, 10)            413450      concatenate_1[0][0] ____________________________________________________________________________________________________ dense_2 (Dense)                  (None, 1)             11          dense_1[0][0] ==================================================================================================== Total params: 415,045 Trainable params: 415,045 Non-trainable params: 0 ____________________________________________________________________________________________________

A plot of the model graph is also created and saved to file.

Neural Network Graph With Shared Inputs

Shared Feature Extraction Layer

In this section, we will use two parallel submodels to interpret the output of an LSTM feature extractor for sequence classification.

The input to the model is 100 time steps of 1 feature. An LSTM layer with 10 memory cells interprets this sequence. The first interpretation model is a shallow single fully connected layer, the second is a deep 3 layer model. The output of both interpretation models are concatenated into one long vector that is passed to the output layer used to make a binary prediction.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# Shared Feature Extraction Layer from keras.utils import plot_model from keras.models import Model from keras.layers import Input from keras.layers import Dense from keras.layers.recurrent import LSTM from keras.layers.merge import concatenate # define input visible = Input(shape=(100,1)) # feature extraction extract1 = LSTM(10)(visible) # first interpretation model interp1 = Dense(10, activation='relu')(extract1) # second interpretation model interp11 = Dense(10, activation='relu')(extract1) interp12 = Dense(20, activation='relu')(interp11) interp13 = Dense(10, activation='relu')(interp12) # merge interpretation merge = concatenate([interp1, interp13]) # output output = Dense(1, activation='sigmoid')(merge) model = Model(inputs=visible, outputs=output) # summarize layers print(model.summary()) # plot graph plot_model(model, to_file='shared_feature_extractor.png')

Running the example summarizes the model layers.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

____________________________________________________________________________________________________ Layer (type)                     Output Shape          Param #     Connected to ==================================================================================================== input_1 (InputLayer)             (None, 100, 1)        0 ____________________________________________________________________________________________________ lstm_1 (LSTM)                    (None, 10)            480         input_1[0][0] ____________________________________________________________________________________________________ dense_2 (Dense)                  (None, 10)            110         lstm_1[0][0] ____________________________________________________________________________________________________ dense_3 (Dense)                  (None, 20)            220         dense_2[0][0] ____________________________________________________________________________________________________ dense_1 (Dense)                  (None, 10)            110         lstm_1[0][0] ____________________________________________________________________________________________________ dense_4 (Dense)                  (None, 10)            210         dense_3[0][0] ____________________________________________________________________________________________________ concatenate_1 (Concatenate)      (None, 20)            0           dense_1[0][0]                                                                    dense_4[0][0] ____________________________________________________________________________________________________ dense_5 (Dense)                  (None, 1)             21          concatenate_1[0][0] ==================================================================================================== Total params: 1,151 Trainable params: 1,151 Non-trainable params: 0 ____________________________________________________________________________________________________

A plot of the model graph is also created and saved to file.

Neural Network Graph With Shared Feature Extraction Layer

5. Multiple Input and Output Models

The functional API can also be used to develop more complex models with multiple inputs, possibly with different modalities. It can also be used to develop models that produce multiple outputs.

We will look at examples of each in this section.

Multiple Input Model

We will develop an image classification model that takes two versions of the image as input, each of a different size. Specifically a black and white 64×64 version and a color 32×32 version. Separate feature extraction CNN models operate on each, then the results from both models are concatenated for interpretation and ultimate prediction.

Note that in the creation of the Model() instance, that we define the two input layers as an array. Specifically:

1	model = Model(inputs=[visible1, visible2], outputs=output)

The complete example is listed below.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# Multiple Inputs from keras.utils import plot_model from keras.models import Model from keras.layers import Input from keras.layers import Dense from keras.layers import Flatten from keras.layers.convolutional import Conv2D from keras.layers.pooling import MaxPooling2D from keras.layers.merge import concatenate # first input model visible1 = Input(shape=(64,64,1)) conv11 = Conv2D(32, kernel_size=4, activation='relu')(visible1) pool11 = MaxPooling2D(pool_size=(2, 2))(conv11) conv12 = Conv2D(16, kernel_size=4, activation='relu')(pool11) pool12 = MaxPooling2D(pool_size=(2, 2))(conv12) flat1 = Flatten()(pool12) # second input model visible2 = Input(shape=(32,32,3)) conv21 = Conv2D(32, kernel_size=4, activation='relu')(visible2) pool21 = MaxPooling2D(pool_size=(2, 2))(conv21) conv22 = Conv2D(16, kernel_size=4, activation='relu')(pool21) pool22 = MaxPooling2D(pool_size=(2, 2))(conv22) flat2 = Flatten()(pool22) # merge input models merge = concatenate([flat1, flat2]) # interpretation model hidden1 = Dense(10, activation='relu')(merge) hidden2 = Dense(10, activation='relu')(hidden1) output = Dense(1, activation='sigmoid')(hidden2) model = Model(inputs=[visible1, visible2], outputs=output) # summarize layers print(model.summary()) # plot graph plot_model(model, to_file='multiple_inputs.png')

Running the example summarizes the model layers.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

____________________________________________________________________________________________________ Layer (type)                     Output Shape          Param #     Connected to ==================================================================================================== input_1 (InputLayer)             (None, 64, 64, 1)     0 ____________________________________________________________________________________________________ input_2 (InputLayer)             (None, 32, 32, 3)     0 ____________________________________________________________________________________________________ conv2d_1 (Conv2D)                (None, 61, 61, 32)    544         input_1[0][0] ____________________________________________________________________________________________________ conv2d_3 (Conv2D)                (None, 29, 29, 32)    1568        input_2[0][0] ____________________________________________________________________________________________________ max_pooling2d_1 (MaxPooling2D)   (None, 30, 30, 32)    0           conv2d_1[0][0] ____________________________________________________________________________________________________ max_pooling2d_3 (MaxPooling2D)   (None, 14, 14, 32)    0           conv2d_3[0][0] ____________________________________________________________________________________________________ conv2d_2 (Conv2D)                (None, 27, 27, 16)    8208        max_pooling2d_1[0][0] ____________________________________________________________________________________________________ conv2d_4 (Conv2D)                (None, 11, 11, 16)    8208        max_pooling2d_3[0][0] ____________________________________________________________________________________________________ max_pooling2d_2 (MaxPooling2D)   (None, 13, 13, 16)    0           conv2d_2[0][0] ____________________________________________________________________________________________________ max_pooling2d_4 (MaxPooling2D)   (None, 5, 5, 16)      0           conv2d_4[0][0] ____________________________________________________________________________________________________ flatten_1 (Flatten)              (None, 2704)          0           max_pooling2d_2[0][0] ____________________________________________________________________________________________________ flatten_2 (Flatten)              (None, 400)           0           max_pooling2d_4[0][0] ____________________________________________________________________________________________________ concatenate_1 (Concatenate)      (None, 3104)          0           flatten_1[0][0]                                                                    flatten_2[0][0] ____________________________________________________________________________________________________ dense_1 (Dense)                  (None, 10)            31050       concatenate_1[0][0] ____________________________________________________________________________________________________ dense_2 (Dense)                  (None, 10)            110         dense_1[0][0] ____________________________________________________________________________________________________ dense_3 (Dense)                  (None, 1)             11          dense_2[0][0] ==================================================================================================== Total params: 49,699 Trainable params: 49,699 Non-trainable params: 0 ____________________________________________________________________________________________________

A plot of the model graph is also created and saved to file.

Neural Network Graph With Multiple Inputs

Multiple Output Model

In this section, we will develop a model that makes two different types of predictions. Given an input sequence of 100 time steps of one feature, the model will both classify the sequence and output a new sequence with the same length.

An LSTM layer interprets the input sequence and returns the hidden state for each time step. The first output model creates a stacked LSTM, interprets the features, and makes a binary prediction. The second output model uses the same output layer to make a real-valued prediction for each input time step.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# Multiple Outputs from keras.utils import plot_model from keras.models import Model from keras.layers import Input from keras.layers import Dense from keras.layers.recurrent import LSTM from keras.layers.wrappers import TimeDistributed # input layer visible = Input(shape=(100,1)) # feature extraction extract = LSTM(10, return_sequences=True)(visible) # classification output class11 = LSTM(10)(extract) class12 = Dense(10, activation='relu')(class11) output1 = Dense(1, activation='sigmoid')(class12) # sequence output output2 = TimeDistributed(Dense(1, activation='linear'))(extract) # output model = Model(inputs=visible, outputs=[output1, output2]) # summarize layers print(model.summary()) # plot graph plot_model(model, to_file='multiple_outputs.png')

Running the example summarizes the model layers.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

____________________________________________________________________________________________________ Layer (type)                     Output Shape          Param #     Connected to ==================================================================================================== input_1 (InputLayer)             (None, 100, 1)        0 ____________________________________________________________________________________________________ lstm_1 (LSTM)                    (None, 100, 10)       480         input_1[0][0] ____________________________________________________________________________________________________ lstm_2 (LSTM)                    (None, 10)            840         lstm_1[0][0] ____________________________________________________________________________________________________ dense_1 (Dense)                  (None, 10)            110         lstm_2[0][0] ____________________________________________________________________________________________________ dense_2 (Dense)                  (None, 1)             11          dense_1[0][0] ____________________________________________________________________________________________________ time_distributed_1 (TimeDistribu (None, 100, 1)        11          lstm_1[0][0] ==================================================================================================== Total params: 1,452 Trainable params: 1,452 Non-trainable params: 0 ____________________________________________________________________________________________________

A plot of the model graph is also created and saved to file.

Neural Network Graph With Multiple Outputs

6. Best Practices

In this section, I want to give you some tips to get the most out of the functional API when you are defining your own models.

• Consistent Variable Names. Use the same variable name for the input (visible) and output layers (output) and perhaps even the hidden layers (hidden1, hidden2). It will help to connect things together correctly.
• Review Layer Summary. Always print the model summary and review the layer outputs to ensure that the model was connected together as you expected.
• Review Graph Plots. Always create a plot of the model graph and review it to ensure that everything was put together as you intended.
• Name the layers. You can assign names to layers that are used when reviewing summaries and plots of the model graph. For example: Dense(1, name=’hidden1′).
• Separate Submodels. Consider separating out the development of submodels and combine the submodels together at the end.

Do you have your own best practice tips when using the functional API?
Let me know in the comments.

7. Note on the Functional API Python Syntax

If you are new or new-ish to Python the syntax used in the functional API may be confusing.

For example, given:

1 2 3

... dense1 = Dense(32)(input) ...

What does the double bracket syntax do?

What does it mean?

It looks confusing, but it is not a special python thing, just one line doing two things.

The first bracket “(32)” creates the layer via the class constructor, the second bracket “(input)” is a function with no name implemented via the __call__() function, that when called will connect the layers.

The __call__() function is a default function on all Python objects that can be overridden and is used to “call” an instantiated object. Just like the __init__() function is a default function on all objects called just after instantiating an object to initialize it.

We can do the same thing in two lines:

1 2 3 4

# create layer dense1 = Dense(32) # connect layer to previous layer dense1(input)

I guess we could also call the __call__() function on the object explicitly, although I have never tried:

1 2 3 4

# create layer dense1 = Dense(32) # connect layer to previous layer dense1.__call_(input)

Further Reading

This section provides more resources on the topic if you are looking go deeper.

• The Sequential model API
• Getting started with the Keras Sequential model
• Getting started with the Keras functional API
• Model class Functional API

Summary

In this tutorial, you discovered how to use the functional API in Keras for defining simple and complex deep learning models.

Specifically, you learned:

• The difference between the Sequential and Functional APIs.
• How to define simple Multilayer Perceptron, Convolutional Neural Network, and Recurrent Neural Network models using the functional API.
• How to define more complex models with shared layers and multiple inputs and outputs.

Do you have any questions?
Ask your questions in the comments below and I will do my best to answer.