Seaborn heatmaps: Everything you need to get started

When to use them

Heatmaps shine in the following scenarios:

1. Correlation analysis: If you want to quickly understand how multiple numeric variables relate to each other, a correlation matrix visualized via a heatmap can reveal which variables move together (positive correlation), move inversely (negative correlation), or show no clear relationship.
2. Categorical vs. numerical data: Heatmaps can also display how a numerical metric changes across different categories. For example, comparing monthly sales across various store locations and product types.
3. High-dimensional data: Heatmaps allow you to see a big-picture view of large datasets. When you have a matrix of data points, using color scales can help you quickly spot outliers or clusters.
4. Time-series analysis: You can visualize data across time (e.g., months, weeks, hours) on one axis and different categories or variables on the other axis. For instance, analyzing website traffic or sales volume by hour of day and day of week.

However, heatmaps may not be ideal when your primary goal is to display exact values. While you can annotate a heatmap to show exact numbers, the main power of a heatmap lies in visually revealing patterns—making it less about precise values and more about comparisons.

‍Creating a Seaborn heatmap

‍One of the main reasons for Seaborn’s popularity is its simplicity and elegance in creating statistical graphics. Heatmaps are no exception. In just a few lines of code, you can generate an insightful visualization.Before starting, make sure you have the necessary libraries installed:

pip install seaborn matplotlib pandas

‍Basic heatmaps

‍Let’s begin by creating a basic heatmap. We’ll assume you’re analyzing fictional sales data from Superdope, a company that sells apparel and clothes. Suppose we have monthly sales data across three regions and three product categories (T-Shirts, Hoodies, Jackets).Before we get started, let’s generate some synthetic data for a fictitious company called Superdope, which sells fashion apparel.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Sample data for Superdope
data = {
    'Region': ['North', 'North', 'North', 'South', 'South', 'South', 'East', 'East', 'East'],
    'Product': ['T-Shirt', 'Hoodie', 'Jacket', 'T-Shirt', 'Hoodie', 'Jacket', 'T-Shirt', 'Hoodie', 'Jacket'],
    'Jan': [100, 50, 30, 80, 70, 25, 60, 55, 20],
    'Feb': [110, 45, 35, 85, 60, 30, 65, 58, 25],
    'Mar': [120, 48, 28, 75, 65, 35, 70, 52, 22],
}

df = pd.DataFrame(data)

Now that we have some data stored in a Pandas DataFrame called df, we’re ready to get started.

# Let's pivot this data so that rows represent Regions, columns represent Products, and the values represent average sales across the months.

df['AverageSales'] = df[['Jan', 'Feb', 'Mar']].mean(axis=1)
pivot_df = df.pivot(index='Region', columns='Product', values='AverageSales')

And finally, let’s plot the data using a heatmap:

plt.figure(figsize=(8, 6))
sns.heatmap(pivot_df, cmap='YlGnBu')
plt.title('Average Sales by Region and Product')
plt.show()

Explanation:

• We create a DataFrame that includes the region, product, and monthly sales data.
• We calculate an AverageSales column by averaging the sales from January, February, and March.
• We use pivot_df to reshape the data for the heatmap: each row is a region, each column is a product, and the cell values are the average sales for those combinations.
• We call sns.heatmap() on pivot_df with a chosen color map (e.g., 'YlGnBu').
• Finally, we display the heatmap with plt.show().

This basic heatmap is a great starting point. Each cell’s color corresponds to the magnitude of the average sales, providing an immediate visual for comparing T-Shirt, Hoodie, and Jacket sales across the North, South, and East regions.Advanced heatmap customizationWhile the default Seaborn heatmap is serviceable, you often need to customize it for clarity and branding or to highlight specific information. Here are a few popular parameters and techniques:

1. Annotations: Displaying numerical values inside each cell can be helpful, especially when precise values are important.
2. Color bars: By default, Seaborn will display a color bar on the side, but you can remove it or position it differently if needed.
3. Custom color maps: Seaborn supports a range of color maps, and you can also create your own.
4. Axis label rotation: If you have longer category names, you might want to rotate them for better readability.
5. Value normalization: If your data spans vastly different scales, normalizing or scaling your data might lead to a more meaningful color range.

Let’s illustrate some of these customizations:

plt.figure(figsize=(8, 6))
sns.heatmap(
    pivot_df, 
    cmap='coolwarm',         # A different color map
    annot=True,              # Show numbers in each cell
    fmt=".1f",               # Format the annotation numbers
    linewidths=0.5,          # Lines between cells
    linecolor='black',       # Color of the cell lines
    cbar_kws={'shrink': 0.8} # Shrink the color bar a bit
)

plt.title('Average Sales by Region and Product - Customized')
plt.xticks(rotation=45, ha='right')  # Rotate x-axis labels for clarity
plt.yticks(rotation=0)               # Keep y-axis labels horizontal
plt.tight_layout()
plt.show()

In the example above:

• annot=True: Adds the actual numerical values in each cell.
• fmt=".1f": Formats these numbers to one decimal place.
• linewidths and linecolor: Adds thin lines between cells, improving readability.
• cbar_kws={'shrink': 0.8}: Adjusts the size of the color bar.
• plt.xticks() and plt.yticks(): Helps ensure that labels are readable.

Advanced color maps or sns.color_palette can also be used if you need a specific gradient or brand color scheme. For example, if Superdope has brand guidelines, you might want to use a palette that matches the company's colors.

Alternatives to Seaborn heatmaps

‍While Seaborn’s heatmap is widely used, there are a few close “cousins” in the Python ecosystem:

1. Matplotlib: Since Seaborn is built on top of Matplotlib, you can create heatmaps directly with Matplotlib’s imshow or matshow functions. However, you’ll often need more code to achieve the same level of style that Seaborn provides out of the box.
2. Plotly: Plotly offers interactive heatmaps, which can be zoomed, hovered over, and even integrated into web apps easily. For dynamic dashboards, Plotly is a strong choice.
3. Altair: Altair is a declarative statistical visualization library. While it’s more commonly used for bar charts, line charts, and scatter plots, it can also generate heatmaps if you prefer a highly declarative style.
4. Bokeh: Like Plotly, Bokeh is great for interactive visualizations. If you need a server-based or web-based app, Bokeh’s interactive heatmaps can provide an engaging user experience.

Note on personal preferences: I like to work with Plotly for two reasons. The first is that it renders dynamically, so when you’re embedding your chart in a report, it naturally scales up and down as the browser window size changes. This makes for a much better builder and viewer experience especially when using a platform like Fabi.ai to build reports. The other reason is that it’s interactive. Although this interactivity isn’t necessarily the most valuable for heatmaps, it does make charts more engaging and more useful for the viewer of the report.In most cases, sticking with Seaborn is straightforward, especially for quick correlation matrices or aggregated summary tables. But if you need more interactive features or specialized styling, these other libraries may be worth a look.Preparing your data for a heatmapBefore jumping into plotting a heatmap, it’s crucial to ensure your data is in a suitable format and scale:

1. Identify your axes: Decide what rows and columns will represent in your final matrix. This might be different product categories, time periods, or geographic regions.
2. Aggregation or summary statistics: Often, raw data is too granular. You might need to compute a summary statistic like mean, sum, or count. In our Superdope example, we used average sales per region-product combination.
3. Pivot or reshape your data:
   
   • If you’re dealing with correlation matrices, you can simply call df.corr() on a DataFrame of numeric columns.
   • If you need to create a custom matrix, pivot() or pivot_table() from Pandas will help structure your data so that each row-column combination is a single numeric value.
4. Handling missing values: Missing data can distort your heatmap. Decide whether to remove rows/columns with missing values or use an imputation strategy (filling them with zeros, means, etc.).
5. Scaling: If certain columns have values that range vastly higher than others, you might want to standardize or normalize your data. This ensures one very large column doesn’t overshadow smaller columns in the color map.

Example of data preparation with pivot tables‍

Below is an extended example using pivot_table. Suppose we have daily sales data across multiple months, and we want to see total sales for each region and product category:

import numpy as np

# Extended daily data
data_extended = {
    'Date': pd.date_range('2023-01-01', periods=90, freq='D'), 
    'Region': np.random.choice(['North', 'South', 'East'], 90),
    'Product': np.random.choice(['T-Shirt', 'Hoodie', 'Jacket'], 90),
    'Sales': np.random.randint(10, 200, 90)
}

df_extended = pd.DataFrame(data_extended)

# Add a 'Month' column
df_extended['Month'] = df_extended['Date'].dt.month_name()

# Create a pivot table with sum of sales by Month and Region, grouping by Product
pivot_extended = pd.pivot_table(
    df_extended, 
    values='Sales', 
    index='Region', 
    columns='Month', 
    aggfunc='sum'
).fillna(0)

print(pivot_extended)

In this snippet:

• We generate daily data for 90 days, ensuring we cover multiple months.
• np.random.choice and np.random.randint create random data for demonstration.
• We extract the month name from each date to use as columns in our pivot table.
• pivot_table creates a summary of total sales for each region-month combination.
• Finally, we fill missing values with zeros (in case some region has no sales in a particular month).

This pivot table can then be directly passed into sns.heatmap(pivot_extended) for visualization.