Tạo bản đồ nhiệt từ gấu trúc DataFrame

Tôi có một khung dữ liệu được tạo từ gói Pandas của Python. Làm cách nào để tạo bản đồ nhiệt bằng DataFrame từ gói gấu trúc.

import numpy as np 
from pandas import *

Index= ['aaa','bbb','ccc','ddd','eee']
Cols = ['A', 'B', 'C','D']
df = DataFrame(abs(np.random.randn(5, 4)), index= Index, columns=Cols)

>>> df
          A         B         C         D
aaa  2.431645  1.248688  0.267648  0.613826
bbb  0.809296  1.671020  1.564420  0.347662
ccc  1.501939  1.126518  0.702019  1.596048
ddd  0.137160  0.147368  1.504663  0.202822
eee  0.134540  3.708104  0.309097  1.641090
>>> 

Bạn muốn matplotlib.pcolor:

import numpy as np 
from pandas import DataFrame
import matplotlib.pyplot as plt

index = ['aaa', 'bbb', 'ccc', 'ddd', 'eee']
columns = ['A', 'B', 'C', 'D']
df = DataFrame(abs(np.random.randn(5, 4)), index=index, columns=columns)

plt.pcolor(df)
plt.yticks(np.arange(0.5, len(df.index), 1), df.index)
plt.xticks(np.arange(0.5, len(df.columns), 1), df.columns)
plt.show()

Điều này mang lại:

Đối với những người nhìn vào điều này ngày hôm nay, tôi muốn giới thiệu Seaborn heatmap()như được ghi lại ở đây .

Ví dụ trên sẽ được thực hiện như sau:

import numpy as np 
from pandas import DataFrame
import seaborn as sns
%matplotlib inline

Index= ['aaa', 'bbb', 'ccc', 'ddd', 'eee']
Cols = ['A', 'B', 'C', 'D']
df = DataFrame(abs(np.random.randn(5, 4)), index=Index, columns=Cols)

sns.heatmap(df, annot=True)

Đâu %matplotliblà một chức năng ma thuật IPython cho những người không quen.

Nếu bạn không cần một biểu đồ và chỉ đơn giản là muốn thêm màu sắc để thể hiện các giá trị trong một định dạng bảng, bạn có thể sử dụng style.background_gradient()phương pháp của khung dữ liệu gấu trúc. Phương pháp này tô màu bảng HTML được hiển thị khi xem các khung dữ liệu gấu trúc trong Máy tính xách tay JupyterLab và kết quả tương tự như sử dụng "định dạng có điều kiện" trong phần mềm bảng tính:

import numpy as np 
import pandas as pd


index= ['aaa', 'bbb', 'ccc', 'ddd', 'eee']
cols = ['A', 'B', 'C', 'D']
df = pd.DataFrame(abs(np.random.randn(5, 4)), index=index, columns=cols)
df.style.background_gradient(cmap='Blues')

Để biết cách sử dụng chi tiết, vui lòng xem câu trả lời phức tạp hơn mà tôi đã cung cấp về cùng chủ đề trước đây và phần tạo kiểu của tài liệu về gấu trúc .

sns.heatmapApi hữu ích là ở đây . Kiểm tra các thông số, có một số tốt trong số họ. Thí dụ:

import seaborn as sns
%matplotlib inline

idx= ['aaa','bbb','ccc','ddd','eee']
cols = list('ABCD')
df = DataFrame(abs(np.random.randn(5,4)), index=idx, columns=cols)

# _r reverses the normal order of the color map 'RdYlGn'
sns.heatmap(df, cmap='RdYlGn_r', linewidths=0.5, annot=True)

Nếu bạn muốn có một bản đồ nhiệt tương tác từ Pandas DataFrame và bạn đang chạy sổ ghi chép Jupyter, bạn có thể thử Widget Clustergrammer-Widget tương tác, xem sổ ghi chép tương tác trên NBViewer tại đây , tài liệu tại đây

Và đối với các tập dữ liệu lớn hơn, bạn có thể dùng thử tiện ích con Clustergrammer2 WebGL đang được phát triển (sổ tay mẫu tại đây )

Xin lưu ý rằng các tác giả của seabornchỉ muốn seaborn.heatmap làm việc với các khung dữ liệu phân loại. Nó không chung chung.

Nếu chỉ mục và cột của bạn là giá trị số và / hoặc ngày giờ, mã này sẽ phục vụ bạn tốt.

Chức năng ánh xạ nhiệt Matplotlib pcolormeshyêu cầu các thùng thay vì các chỉ mục , vì vậy có một số mã ưa thích để tạo các thùng từ các chỉ số khung dữ liệu của bạn (ngay cả khi chỉ mục của bạn không cách đều nhau!).

Phần còn lại đơn giản là np.meshgridvà plt.pcolormesh.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def conv_index_to_bins(index):
    """Calculate bins to contain the index values.
    The start and end bin boundaries are linearly extrapolated from 
    the two first and last values. The middle bin boundaries are 
    midpoints.

    Example 1: [0, 1] -> [-0.5, 0.5, 1.5]
    Example 2: [0, 1, 4] -> [-0.5, 0.5, 2.5, 5.5]
    Example 3: [4, 1, 0] -> [5.5, 2.5, 0.5, -0.5]"""
    assert index.is_monotonic_increasing or index.is_monotonic_decreasing

    # the beginning and end values are guessed from first and last two
    start = index[0] - (index[1]-index[0])/2
    end = index[-1] + (index[-1]-index[-2])/2

    # the middle values are the midpoints
    middle = pd.DataFrame({'m1': index[:-1], 'p1': index[1:]})
    middle = middle['m1'] + (middle['p1']-middle['m1'])/2

    if isinstance(index, pd.DatetimeIndex):
        idx = pd.DatetimeIndex(middle).union([start,end])
    elif isinstance(index, (pd.Float64Index,pd.RangeIndex,pd.Int64Index)):
        idx = pd.Float64Index(middle).union([start,end])
    else:
        print('Warning: guessing what to do with index type %s' % 
              type(index))
        idx = pd.Float64Index(middle).union([start,end])

    return idx.sort_values(ascending=index.is_monotonic_increasing)

def calc_df_mesh(df):
    """Calculate the two-dimensional bins to hold the index and 
    column values."""
    return np.meshgrid(conv_index_to_bins(df.index),
                       conv_index_to_bins(df.columns))

def heatmap(df):
    """Plot a heatmap of the dataframe values using the index and 
    columns"""
    X,Y = calc_df_mesh(df)
    c = plt.pcolormesh(X, Y, df.values.T)
    plt.colorbar(c)

Gọi nó bằng cách sử dụng heatmap(df), và xem nó bằng cách sử dụng plt.show().