Heatmaps and correlation matrices are powerful tools for visualizing data relationships and patterns. However, static heatmaps may not always capture the dynamic nature of data changes over time. Animating a heatmap or correlation matrix can provide deeper insights into how data evolves. This article will guide you through the process of creating an animated heatmap or correlation matrix using Python’s seaborn and matplotlib libraries.

Understanding Seaborn Heatmaps

Before diving into animation, let’s briefly review how to create a basic Seaborn heatmap. Seaborn’s heatmap() function takes a matrix of data as input and uses color to represent different levels of data magnitude. This allows us to quickly identify highly correlated or inversely correlated variables. The function supports various parameters to customize the heatmap, such as specifying the colormap (cmap), annotating cell values (annot), and setting the width of cell dividers (linewidths).

Animate a Seaborn’s Heatmap: Practical Implementation

Preparing Data for Animation

To animate a heatmap, we need a series of data matrices that will be displayed sequentially. These matrices can be generated using various methods, such as:

1. Random Data Generation: We can use NumPy’s random.rand() function to generate random matrices of a specified size.
2. Iterating Over a List of Dataframes: If we have a list of dataframes, we can iterate over them and create a heatmap for each dataframe.

Creating the Animation

To create the animation, we will use matplotlib’s FuncAnimation() class. This class takes three main arguments:

1. Figure: The figure on which the animation will be displayed.
2. Animate Function: A function that will be called repeatedly to update the animation.
3. Init Function: An optional function to initialize the animation.

Here is a basic example of how to create an animated heatmap using FuncAnimation():

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib import animation

dimension = (5, 5)
fig, ax = plt.subplots(figsize=(3, 3))  # Reduce the figure size

# Create the heatmap with initial data
data = np.random.rand(*dimension)
heatmap = sns.heatmap(data, ax=ax, vmax=.8, cbar=False, annot=True, fmt=".2f")

def init():
    data = np.zeros(dimension)
    ax.clear()
    sns.heatmap(data, ax=ax, vmax=.8, cbar=False, annot=True, fmt=".2f")

# Define the animate function
def animate(i):
    data = np.random.rand(*dimension)
    ax.clear()
    sns.heatmap(data, ax=ax, vmax=.8, cbar=False, annot=True, fmt=".2f")
    return ax

# Create the animation
ani = animation.FuncAnimation(fig, animate, init_func=init, frames=20, repeat=False)
plt.show()

# Save the animation as a GIF with optimized parameters
ani.save('animated_heatmap.gif', writer='pillow', fps=2, dpi=80)

Output:

Animating Seaborn’s Heatmap

For animation, of seaborn heatmap, refer to video below:

Example: Animate a Seaborn’s Heatmap Matrix ( Step-by-Step)

Setting Up the Environment

First, let’s import the necessary libraries and set up our environment:

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import pandas as pd

Generating Sample Data

def generate_random_data(size, num_frames):
    data_frames = []
    for _ in range(num_frames):
        data = np.random.rand(size, size)
        df = pd.DataFrame(data)
        data_frames.append(df)
    return data_frames

size = 10  # Size of the correlation matrix
num_frames = 50  # Number of frames in the animation
data_frames = generate_random_data(size, num_frames)

Creating the Heatmap

Next, we’ll create a function to initialize the heatmap. This function will set up the figure and axis for the animation.

def init_heatmap():
    fig, ax = plt.subplots()
    sns.heatmap(data_frames[0], ax=ax, cbar=True, annot=True)
    return fig, ax

Animating the Heatmap

Now, let’s create the animation function. This function will update the heatmap for each frame in the animation.

def update_heatmap(frame, ax):
    ax.clear()
    sns.heatmap(data_frames[frame], ax=ax, cbar=True, annot=True)

Creating the Animation

With the initialization and update functions in place, we can now create the animation using Matplotlib’s FuncAnimation.

fig, ax = init_heatmap()
anim = FuncAnimation(fig, update_heatmap, frames=num_frames, fargs=(ax,), interval=200)

Saving the Animation

Finally, we can save the animation as a GIF or MP4 file.

anim.save('animated_heatmap.gif', writer='imagemagick')
# or
anim.save('animated_heatmap.mp4', writer='ffmpeg')

Output:

For animation, of seaborn heatmap, refer to video below:

Conclusion

Animating a Seaborn heatmap or correlation matrix is a powerful tool for visualizing changes in data over time. By using matplotlib’s FuncAnimation() class and Seaborn’s heatmap() function, we can create dynamic and informative visualizations. This article has provided a step-by-step guide on how to create such animations, including preparing data, creating the animation, adding annotations, and saving the animation as a GIF.