Auto Adjust Font Size in Seaborn Heatmap Using Matplotlib

Auto Adjust Font Size in Seaborn Heatmap Using Matplotlib

Creating visualizations that are both informative and aesthetically pleasing can be a challenging task, especially when dealing with complex datasets and intricate plotting libraries. One common issue is ensuring that text elements such as labels and titles are legible and appropriately sized, which can be particularly problematic in heatmaps where the number of variables and the granularity of data can vary widely. In this article, we will explore how to automatically adjust font sizes in Seaborn heatmaps using Matplotlib, ensuring that your heatmaps are both functional and visually appealing.

Introduction to Seaborn and Matplotlib

Seaborn is a Python data visualization library based on Matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics. For this tutorial, we will focus on the heatmap, which is a way of representing data values in a matrix as colors. However, one common issue with heatmaps is that the font size of annotations can become too small or too large, depending on the size of the heatmap and the number of annotations.

Matplotlib is a plotting library for the Python programming language and its numerical mathematics extension NumPy. It provides an object-oriented API for embedding plots into applications using general-purpose GUI toolkits like Tkinter, wxPython, Qt, or GTK.

Setting Up Your Environment

Before diving into the code examples, ensure you have the necessary libraries installed. You can install Seaborn and Matplotlib using pip:

pip install seaborn matplotlib

Basic Heatmap with Seaborn

Let’s start by creating a basic heatmap using Seaborn. This will serve as our foundation for the subsequent examples where we will adjust the font sizes dynamically.

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

data = np.random.rand(10, 12)
sns.heatmap(data)
plt.title("Basic Heatmap - how2matplotlib.com")
plt.show()

Output:

Example 1: Adjusting Font Size Manually

Before we look into automatically adjusting font sizes, let’s manually set the font size for annotations in a heatmap.

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

data = np.random.rand(10, 12)

sns.heatmap(data, annot=True, fmt=".1f", annot_kws={"size": 8})
plt.title("Manual Font Size Adjustment - how2matplotlib.com", fontsize=10)
plt.show()

Output:

Example 2: Dynamic Font Size Adjustment Based on Heatmap Size

To dynamically adjust font sizes based on the heatmap size, we can define a function that calculates an appropriate font size based on the dimensions of the heatmap.

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

data = np.random.rand(10, 12)

def adjust_font_size(ax, data):
    min_dim = min(data.shape)
    font_size = min(12, max(8, int(100 / min_dim)))
    sns.heatmap(data, annot=True, fmt=".1f", annot_kws={"size": font_size}, ax=ax)
    ax.set_title("Dynamic Font Size - how2matplotlib.com", fontsize=font_size)

fig, ax = plt.subplots()
adjust_font_size(ax, data)
plt.show()

Output:

Example 3: Adjusting Font Size Based on Figure Dimensions

Another approach is to adjust the font size based on the dimensions of the figure itself, rather than the data matrix.

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

data = np.random.rand(10, 12)

def adjust_font_size_figure(ax, data, fig_width, fig_height):
    fig_dim = min(fig_width, fig_height)
    font_size = min(12, max(8, int(fig_dim / 10)))
    sns.heatmap(data, annot=True, fmt=".1f", annot_kws={"size": font_size}, ax=ax)
    ax.set_title("Font Size Based on Figure Dimensions - how2matplotlib.com", fontsize=font_size)

fig, ax = plt.subplots(figsize=(8, 6))
adjust_font_size_figure(ax, data, 8, 6)
plt.show()

Output:

Example 4: Responsive Font Size Adjustment for Heatmap Annotations

To make the font size responsive, we can adjust it based on the number of cells in the heatmap.

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

data = np.random.rand(10, 12)

def responsive_font_size(data):
    total_cells = np.product(data.shape)
    font_size = min(12, max(8, int(1000 / total_cells)))
    return font_size

font_size = responsive_font_size(data)
sns.heatmap(data, annot=True, fmt=".1f", annot_kws={"size": font_size})
plt.title("Responsive Font Size for Annotations - how2matplotlib.com", fontsize=font_size)
plt.show()

Example 5: Using GridSpec for Advanced Layout and Font Size Control

When dealing with multiple heatmaps in a single figure, controlling the font size becomes more complex. Here, we use GridSpec to manage layout and font size effectively.

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

data = np.random.rand(10, 12)

def plot_with_gridspec(data1, data2):
    fig = plt.figure(figsize=(10, 5))
    gs = gridspec.GridSpec(1, 2, width_ratios=[1, 2])

    ax1 = plt.subplot(gs[0])
    ax2 = plt.subplot(gs[1])

    font_size1 = responsive_font_size(data1)
    font_size2 = responsive_font_size(data2)

    sns.heatmap(data1, annot=True, fmt=".1f", annot_kws={"size": font_size1}, ax=ax1)
    ax1.set_title("Left Heatmap - how2matplotlib.com", fontsize=font_size1)

    sns.heatmap(data2, annot=True, fmt=".1f", annot_kws={"size": font_size2}, ax=ax2)
    ax2.set_title("Right Heatmap - how2matplotlib.com", fontsize=font_size2)

    plt.tight_layout()
    plt.show()

data1 = np.random.rand(5, 5)
data2 = np.random.rand(10, 20)
plot_with_gridspec(data1, data2)

Conclusion

In this article, we explored various methods to dynamically adjust font sizes in Seaborn heatmaps using Matplotlib. By considering factors such as the dimensions of the heatmap, the dimensions of the figure, and the number of cells, we can ensure that our heatmaps are not only informative but also visually appealing. These techniques are crucial when preparing visualizations for presentations or publications where clarity and readability are paramount.