पांडा से हीटमैप बनाना DataFrame

Question

मेरे पास पायथन के पंडों पैकेज से उत्पन्न एक डेटाफ्रेम है। मैं पांडा पैकेज से डेटाफ़्रेम का उपयोग करके हीटमैप कैसे बना सकता हूं।

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
>>> 

Comments

हीटमैप या अनुसंधान बनाने के संदर्भ में आपने क्या प्रयास किया है? अधिक जानकारी के बिना, मैं आपके डेटा को परिवर्तित करने और इस पद्धति का उपयोग

— शिक्षार्थी

@joelostblom यह एक जवाब नहीं है, एक टिप्पणी है, लेकिन समस्या यह है कि मेरे पास एक टिप्पणी करने में सक्षम होने के लिए पर्याप्त प्रतिष्ठा नहीं है। मैं थोड़ा चकित हूं क्योंकि मैट्रिक्स का आउटपुट मूल्य और मूल सरणी पूरी तरह से अलग हैं। मैं हीट-मैप को वास्तविक मूल्यों में प्रिंट करना चाहता हूं, कुछ अलग नहीं। क्या कोई मुझे समझा सकता है कि ऐसा क्यों हो रहा है। उदाहरण के लिए: * मूल अनुक्रमित डेटा: आआआ / ए = 2.431645 * हीट-मैप में मुद्रित मूल्य: आआ / ए = 1.06192

— मोनिटोटियर

@Monitotier कृपया एक नया प्रश्न पूछें और जो आपने कोशिश की है उसका एक पूरा कोड उदाहरण शामिल करें। यह किसी को पाने में मदद करने का सबसे अच्छा तरीका है कि आप क्या गलत है! यदि आपको लगता है कि यह प्रासंगिक है, तो आप इस प्रश्न से लिंक कर सकते हैं।

— joelostblom

Answer 1

आप चाहते हैं 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()

यह देता है:

Comments

यहाँpcolor बनाम के बारे में कुछ दिलचस्प चर्चा हैimshow ।

— लंदनरोब

... और भी pcolormesh, जो इस तरह के ग्राफिक्स के लिए अनुकूलित है।

— एरिक ओ लेबिगॉट

Answer 2

आज इसे देखने वाले लोगों के लिए, मैं सीबोर्न heatmap()को यहाँ प्रलेखित करने की सलाह दूंगा ।

उपरोक्त उदाहरण निम्नानुसार किया जाएगा:

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)

%matplotlibअपरिचित लोगों के लिए एक IPython मैजिक फ़ंक्शन कहाँ है।

Comments

आप पांडा का उपयोग क्यों नहीं करेंगे?

— tommy.carstensen

सीबॉर्न और पंडस एक साथ अच्छी तरह से काम करते हैं, इसलिए आप अपने डेटा को सही आकार में लाने के लिए पंडों का उपयोग करेंगे। Seaborn स्थिर चार्ट में हालांकि माहिर है, और एक पंडों DataFrame मृत सरल से एक heatmap बना रही है।

— ब्रिजियो

लगता है यह लिंक मर चुका है; क्या आप इसे अपडेट कर सकते हैं !? इसके अलावा, मैं उपरोक्त कोड कैसे चलाऊंगा import matplotlib.pyplot as plt?

— क्लेब

अरे @Cleb, मुझे इसे संग्रहीत पेज पर अपडेट करना पड़ा क्योंकि यह कहीं भी अपनी तरह नहीं दिखता है। Pyplot के साथ इसका उपयोग करने के लिए उनके डॉक्स पर एक नज़र डालें: stanford.edu/~mwaskom/software/seaborn-dev/tutorial/…

— Brideau

import matplotlib.pyplot as pltइसके बजाय का उपयोग करें %matplotlib inlineऔर plt.show()वास्तव में भूखंड को देखने के साथ खत्म करें ।

— tsveti_iko

Answer 3

यदि आपको प्रति प्लॉट की आवश्यकता नहीं है, और आप केवल तालिका प्रारूप में मूल्यों को दर्शाने के लिए रंग जोड़ने में रुचि रखते हैं, तो आप style.background_gradient()पांडा डेटा फ्रेम की विधि का उपयोग कर सकते हैं । यह विधि HTML तालिका को चित्रित करती है, जो कि ज्यूपिटरलैब नोटबुक जैसे पंडों डेटा फ़्रेमों को देखते समय प्रदर्शित होती है और परिणाम स्प्रेडशीट सॉफ़्टवेयर में "सशर्त स्वरूपण" का उपयोग करने के समान है:

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')

विस्तृत उपयोग के लिए, कृपया पहले से एक ही विषय पर प्रदान किए गए अधिक विस्तृत उत्तर और पंडों के दस्तावेज की स्टाइलिंग अनुभाग देखें ।

Comments

धिक्कार है, यह उत्तर वास्तव में वही है जिसकी मुझे तलाश थी। IMO, उच्च (+1) होना चाहिए।

— पोनाड्टो

यह उत्तर पोस्ट किए गए प्रश्न का एक वैध समाधान नहीं है। पंडों की पृष्ठभूमि ढाल रंग या तो प्रत्येक पंक्ति या प्रत्येक स्तंभ को अलग-अलग खाते में ले जाता है जबकि मैटलपोटलिब के पीसीओलर या पीसीओलेर्मेश रंग पूरे मैट्रिक्स को ध्यान में रखते हैं। उदाहरण के लिए pd.DataFrame([[1, 1], [0, 3]]).style.background_gradient(cmap='summer') दो लोगों के साथ एक तालिका में निम्नलिखित कोड परिणाम लें , उनमें से प्रत्येक एक अलग रंग के साथ है।

— टोनी पेन्या-अल्बा

@ ToniPenya-Alba सवाल यह है कि पैंडस डेटाफ्रेम से हीटमैप कैसे उत्पन्न किया जाए, न कि पीसीओलर या PColormesh के व्यवहार को कैसे दोहराया जाए। यदि आप अपने स्वयं के उद्देश्यों के लिए उत्तरार्द्ध में रुचि रखते हैं, तो आप axis=None(पांडा 0.24.0 के बाद से) का उपयोग कर सकते हैं ।

— joelostblom

@joelostblom का मेरा मतलब यह नहीं था कि "एक उपकरण या किसी अन्य व्यवहार को पुन: पेश करें" लेकिन जैसा कि "आमतौर पर प्रत्येक मैट्रिक्स में सभी तत्वों को प्रत्येक पंक्ति / स्तंभ के लिए अलग-अलग पैमाने होने के बजाय एक ही पैमाने पर होता है"। जैसा कि आप बताते हैं, axis=Noneकि मेरी राय में, यह आपके उत्तर का हिस्सा होना चाहिए (विशेषकर क्योंकि यह 0 का दस्तावेज नहीं लगता है )

— टोनी पेना-अल्बा

@ ToniPenya-Alba मैंने पहले से ही axis=Noneऊपर दिए गए विस्तृत उत्तर का हिस्सा बना लिया था, साथ में कुछ अन्य विकल्पों के साथ क्योंकि मैं आपसे सहमत हूं कि इनमें से कुछ विकल्प आमतौर पर वांछित व्यवहार को सक्षम करते हैं। मैंने कल प्रलेखन की कमी पर भी ध्यान दिया और एक पीआर खोला ।

— जोएलोस्टब्लॉम

Answer 4

उपयोगी sns.heatmapएपीआई यहाँ है । मापदंडों की जांच करें, उनमें से एक अच्छी संख्या है। उदाहरण:

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)

Answer 5

यदि आप पंडों डेटाफ़्रेम से एक इंटरैक्टिव हीटमैप चाहते हैं और आप एक ज्यूपिटर नोटबुक चला रहे हैं, तो आप इंटरएक्टिव विजेट क्लस्टरग्राम-विजेट की कोशिश कर सकते हैं , यहाँ एनबीएव्यूअर पर इंटरैक्टिव नोटबुक देखें , यहाँ प्रलेखन

और बड़े डेटासेट के लिए आप इन-डेवलपमेंट Clustergrammer2 WebGL विजेट (उदाहरण नोटबुक यहां ) आज़मा सकते हैं

Comments

वाह यह बहुत साफ है! अजगर के लिए आने वाले कुछ अच्छे पैकेजों को देखने के लिए अच्छा है - आर मैजिक का उपयोग करने के लिए थक गए

— सोस

Answer 6

कृपया ध्यान दें कि seabornकेवल लेखक चाहते हैं seaborn.heatmap श्रेणीबद्ध डेटाफ्रेम के साथ काम । यह सामान्य नहीं है।

यदि आपका सूचकांक और कॉलम संख्यात्मक और / या डेटाटाइम मान हैं, तो यह कोड आपकी अच्छी सेवा करेगा।

Matplotlib हीट-मैपिंग फ़ंक्शन pcolormeshको सूचकांकों के बजाय डिब्बे की आवश्यकता होती है , इसलिए आपके डेटाफ़्रेम सूचकांकों से डिब्बे बनाने के लिए कुछ फैंसी कोड हैं (भले ही आपका सूचकांक समान रूप से स्थान नहीं है!)।

बाकी बस np.meshgridऔर है 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)

इसका उपयोग करके कॉल करें heatmap(df), और इसका उपयोग करके देखें plt.show()।