Visualizing Keras Models with Input and Output Shapes in Python

by

💡 Problem Formulation: When building complex neural network models using Keras, it’s often useful to visualize the model’s architecture to ensure it’s structured correctly. Visualizing a model can provide insights about layer connections, input and output shapes, and reveal errors. This article will explain several methods to plot a Keras model as a graph and display the input/output shapes using Python.

Method 1: Using Keras plot_model Utility

This method utilizes the plot_model function provided by Keras. It takes a model and generates a graphical representation of the neural network, showcasing the architecture including input and output shapes. The function specification includes parameters such as show_shapes which, if set to True, will display the input and output shapes of each layer within the model.

Here’s an example:

from keras.utils.vis_utils import plot_model
from keras.models import Sequential
from keras.layers import Dense

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

plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)

Output: This code generates a PNG image named ‘model_plot.png’ that displays the model’s architecture with detailed layer information including input and output shapes.

The code snippet demonstrates the straightforward nature of the plot_model function. Adding the show_shapes=True option will specifically include the shape information in the visualization, an essential aspect for understanding the data transformation through layers.

Method 2: Summarize Model with model.summary()

Keras provides the model.summary() method, which prints a summary of the model’s architecture. While this does not create a graphical plot, it is a quick and easy way to get an overview of the model, including details on the layers, output shapes, and number of parameters.

Here’s an example:

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

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

model.summary()

Output: This code prints a tabulated summary directly in the console, detailing layers, output shapes, and the number of trainable parameters.

This method is not visual, but it’s a quick way to confirm the structure of your Keras model and see the input and output shapes alongside other vital details in a compact form.

Method 3: Visualization with GraphViz and pydot

For a more advanced approach, you can use the combination of GraphViz and pydot plugins to render high-quality graphs of the model structure. This method allows for significantly more customization and can produce more polished diagrams suitable for presentations.

Here’s an example:

import pydot
import graphviz
from keras.utils.vis_utils import plot_model
from keras.models import Sequential
from keras.layers import Dense

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

plot_model(model, to_file='model_graph.png', show_shapes=True)

Output: Similar to Method 1, but potentially with a different aesthetic depending on the GraphViz and pydot configurations, resulting in a ‘model_graph.png’ file with the detailed architecture.

This method extends the capabilities of the basic plot_model utility by leveraging sophisticated graph visualization libraries, allowing for greater visual customization.

Method 4: Interactive Visualization with TensorBoard

TensorBoard is TensorFlow’s visualization toolkit that can also be used with Keras models. It provides interactive visualizations of the model graph in the browser, with capabilities of zooming in/out and panning through the architecture.

Here’s an example:

from keras.callbacks import TensorBoard
from keras.models import Sequential
from keras.layers import Dense

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

tensorboard_callback = TensorBoard(log_dir="./logs")
model.fit(x_train, y_train, epochs=5, callbacks=[tensorboard_callback])

Output: After running the code and training the model, you can open TensorBoard in your web browser and interactively explore the model’s architecture.

Using TensorBoard for visualizing the model structure provides a dynamic experience and can be particularly helpful with very large models, thanks to its interactive features.

Bonus One-Liner Method 5: Simple Visualization with netron

Netron is a viewer for neural network, deep learning, and machine learning models. While it is a standalone application rather than a Python package, it supports Keras models and provides a graphical interface to display model architectures.

Here’s an example:

model.save('model.h5')

Output: After saving the model as an H5 file, you can drag and drop the file into Netron to visualize it.

This one-line code snippet shows the simplicity of using Netron for visualization purposes: just save your Keras model as an H5 file and open it in Netron to explore its architecture graphically.

Summary/Discussion

  • Method 1: Keras plot_model. Offers a quick, built-in way to visualize models with shape information. Limited customization options.
  • Method 2: model.summary(). Provides an immediate text-based summary of the model in the console. Does not produce a graphical output.
  • Method 3: GraphViz and pydot. Enables highly customizable and polished model graphs. Requires additional software installation.
  • Method 4: TensorBoard. Interactive and web-based, great for complex models. It requires running a local server and may require additional setup.
  • Bonus Method 5: Netron. Extremely user-friendly and supports various model formats. Not integrated into Python workflows; it is a separate application.