Seaborn 自定义范围热图

Question

I need to build custom seaborn heatmap-like plot according to these requirements:

import pandas as pd
df = pd.DataFrame({"A": [0.3, 0.8, 1.3], 
                   "B": [4, 9, 15], 
                   "C": [650, 780, 900]})

df_info = pd.DataFrame({"id": ["min", "max"],
                   "A": [0.5, 0.9], 
                   "B": [6, 10], 
                   "C": [850, 880]})
df_info = df_info.set_index('id')

df

    A      B    C
0   0.3    4    650
1   0.8    9    780
2   1.3    15   900

df_info

id      A      B    C
            
min     0.5    6    850
max     0.9    10   880

Each value within df is supposed to be within a range defined in df_info .
For example the values for the column A are considered normal if they are within 0.5 and 0.9. Values that are outside the range should be colorized using a custom heatmap.

In particular:

• Values that fall within the range defined for each column should not be colorized, plain black text on white background cell.
• Values lower than min for that column should be colorized, for example in blue. The lower their values from the min the darker the shade of blue.
• Values higher than max for that column should be colorized, for example in red. The higher their values from the max the darker the shade of red.

Q: I wouldn't know how to approach this with a standard heatmap, I'm not even sure I can accomplish this with a heatmap plot. Any suggestion?

Answer 1

As far as I know, a heatmap can only have one scale of values. I would suggest normalizing the data you have in the df dataframe so the values in every column follow:

• between 0 and 1 if the value is between df_info 's min max
• below 0 if the value is below df_info 's min
• above 1 if the value is above df_info 's max

To normalize your dataframe use:

for col in df:
    df[col] = (df[col] - df_info[col]['min']) / (df_info[col]['max'] - df_info[col]['min'])

Finally, to create the color-coded heatmap use:

import seaborn as sns
from matplotlib.colors import LinearSegmentedColormap

vmin = df.min().min()
vmax = df.max().max()

colors = [[0, 'darkblue'],
          [- vmin / (vmax - vmin), 'white'],
          [(1 - vmin)/ (vmax - vmin), 'white'],
          [1, 'darkred']]

cmap = LinearSegmentedColormap.from_list('', colors)
sns.heatmap(df, cmap=cmap, vmin=vmin, vmax=vmax)

The additional calculations with vmin and vmax allow a dynamic scaling of the colormap depending on the differences with the minimums and maximums.

Using your input dataframe we have the following heatmap: