माटप्लोटलिब (हिस्टोग्राम) में बिन का आकार

Question

मैं एक हिस्टोग्राम बनाने के लिए matplotlib का उपयोग कर रहा हूं।

क्या डिब्बे की संख्या के विपरीत मैन्युअल रूप से डिब्बे के आकार को निर्धारित करने का कोई तरीका है?

Answer 1

वास्तव में, यह काफी आसान है: बिन की संख्या के बजाय आप बिन सीमाओं के साथ एक सूची दे सकते हैं। वे असमान रूप से वितरित किए जा सकते हैं, भी:

plt.hist(data, bins=[0, 10, 20, 30, 40, 50, 100])

यदि आप उन्हें समान रूप से वितरित करना चाहते हैं, तो आप बस सीमा का उपयोग कर सकते हैं:

plt.hist(data, bins=range(min(data), max(data) + binwidth, binwidth))

---

मूल उत्तर में जोड़ा गया

उपरोक्त लाइन dataकेवल पूर्णांक से भरे जाने के लिए काम करती है । जैसा कि मैक्रोकॉसम बताता है, तैरने के लिए आप इसका उपयोग कर सकते हैं:

import numpy as np
plt.hist(data, bins=np.arange(min(data), max(data) + binwidth, binwidth))

Comments

फ़्लैट्स के साथ काम करने के लिए np.arange (...) के साथ रेंज (...) बदलें।

— मैक्रोसोमीमे

यहाँ पर क्या है?

— UserYmY

मेरा मानना ​​है कि इस उदाहरण में बायनेरिज़ द्वारा पाया जा सकता है (data.max() - data.min()) / number_of_bins_you_want:। + binwidthबस को बदला जा सकता है 1कि यह एक अधिक आसानी से समझा उदाहरण बनाने के लिए।

— जरद

फ़्लोटिंग डेटा के लिए ऊपर कोडिंगकैट के उत्कृष्ट समाधान के अलावा, यदि आप चाहते हैं कि हिस्टोग्राम बार एक्स-टिक्स पर बार की सीमाओं के बजाय पूर्णांक x-ticks के आसपास केंद्रित हो, तो निम्न ट्वीक आज़माएं: bins = np.arange (dmin - 0.5) dmax + 0.5 + binwidth, binwidth)

— डेव्यू

विकल्प lw = 5, color = "white"या इसी तरह आवेषण सलाखों के बीच सफेद अंतराल

— PatrickT

Answer 2

एन बिन के लिए, बिन किनारों को N + 1 मानों की सूची द्वारा निर्दिष्ट किया जाता है जहां पहला N निचले बिन किनारों को देता है और +1 अंतिम बिन के ऊपरी किनारे को देता है।

कोड:

from numpy import np; from pylab import *

bin_size = 0.1; min_edge = 0; max_edge = 2.5
N = (max_edge-min_edge)/bin_size; Nplus1 = N + 1
bin_list = np.linspace(min_edge, max_edge, Nplus1)

ध्यान दें कि linspace, N_ 1 मान या N बिन में टूटी हुई min_edge से max_edge तक की सरणी बनाता है

Comments

ध्यान दें कि डिब्बे N + 1 (अंतिम) बिन के अपवाद के साथ उनकी निचली बाउंड और उनके ऊपरी बाउंड के अनन्य होते हैं, जो दोनों सीमाओं में शामिल है।

— गुनगुना

Answer 3

मुझे लगता है कि आपके पास न्यूनतम और अधिकतम डेटा की गणना करने के लिए आसान तरीका होगा, फिर गणना करें L = max - min। तब आप Lवांछित बिन चौड़ाई से विभाजित करते हैं (मैं मान रहा हूं कि बिन आकार से आपका क्या मतलब है) और इस मूल्य की छत को डिब्बे की संख्या के रूप में उपयोग करें।

Comments

ठीक यही मेरे मन में था, धन्यवाद। अगर वहाँ एक आसान तरीका था सोच रहा था, लेकिन यह लगता है धन्यवाद!

— सैम क्रीमर

राउंड नंबरों का उपयोग करके मुझे इस दृष्टिकोण के साथ एक गोल बिन आकार नहीं मिलता है। किसी को भी अनुभव किया?

— ब्रैड उरानी

Answer 4

मुझे चीजों को स्वचालित रूप से और "अच्छे" मूल्यों पर पड़ने के लिए डिब्बे पसंद है। निम्नलिखित काफी अच्छी तरह से काम करता है।

import numpy as np
import numpy.random as random
import matplotlib.pyplot as plt
def compute_histogram_bins(data, desired_bin_size):
    min_val = np.min(data)
    max_val = np.max(data)
    min_boundary = -1.0 * (min_val % desired_bin_size - min_val)
    max_boundary = max_val - max_val % desired_bin_size + desired_bin_size
    n_bins = int((max_boundary - min_boundary) / desired_bin_size) + 1
    bins = np.linspace(min_boundary, max_boundary, n_bins)
    return bins

if __name__ == '__main__':
    data = np.random.random_sample(100) * 123.34 - 67.23
    bins = compute_histogram_bins(data, 10.0)
    print(bins)
    plt.hist(data, bins=bins)
    plt.xlabel('Value')
    plt.ylabel('Counts')
    plt.title('Compute Bins Example')
    plt.grid(True)
    plt.show()

परिणाम में बिन आकार के अच्छे अंतराल पर डिब्बे हैं।

[-70. -60. -50. -40. -30. -20. -10.   0.  10.  20.  30.  40.  50.  60.]

Comments

वास्तव में मैं क्या देख रहा था! हालांकि, कुछ मामलों में फ्लोटिंग पॉइंट सटीक होने के कारण n_bins को गोल किया जाता है। के लिए उदाहरण के लिए desired_bin_size=0.05, min_boundary=0.850, max_boundary=2.05की गणना n_binsहो जाता है int(23.999999999999993)जो 23 के बजाय 24 में और इसलिए एक बिन भी कुछ परिणाम नहीं। पूर्णांक रूपांतरण से पहले एक राउंडिंग ने मेरे लिए काम किया:n_bins = int(round((max_boundary - min_boundary) / desired_bin_size, 0)) + 1

— एम। श्लेनकर

Answer 5

मैं मात्रा का उपयोग करने के लिए डिब्बे की वर्दी और नमूने के लिए फिट है:

bins=df['Generosity'].quantile([0,.05,0.1,0.15,0.20,0.25,0.3,0.35,0.40,0.45,0.5,0.55,0.6,0.65,0.70,0.75,0.80,0.85,0.90,0.95,1]).to_list()

plt.hist(df['Generosity'], bins=bins, normed=True, alpha=0.5, histtype='stepfilled', color='steelblue', edgecolor='none')

Comments

महान विचार। आप द्वारा np.arange(0, 1.01, 0.5)या मात्रा की सूची को बदल सकते हैं np.linspace(0, 1, 21)। कोई किनारा नहीं है, लेकिन मुझे लगता है कि बक्से में समान क्षेत्र है, लेकिन एक्स अक्ष में अलग चौड़ाई है?

— टॉमस गैंडर

Answer 6

मेरे पास ओपी के रूप में एक ही मुद्दा था (मुझे लगता है!), लेकिन मैं इसे उस तरीके से काम करने के लिए नहीं पा सका जो कि लास्टलडा ने निर्दिष्ट किया था। मुझे नहीं पता कि मैंने प्रश्न की ठीक से व्याख्या की है, लेकिन मुझे एक और समाधान मिल गया है (यह संभवतः इसे करने का एक बहुत बुरा तरीका है)।

यह वह तरीका था जो मैंने किया था:

plt.hist([1,11,21,31,41], bins=[0,10,20,30,40,50], weights=[10,1,40,33,6]);

जो इसे बनाता है:

तो पहला पैरामीटर मूल रूप से बिन को 'इनिशियलाइज़' करता है - मैं विशेष रूप से एक संख्या बना रहा हूं जो कि मैं डिब्बे पैरामीटर में निर्धारित सीमा के बीच में हूं।

इसे प्रदर्शित करने के लिए, पहले पैरामीटर ([१,११,२१,३१,४१]) में सरणी देखें और दूसरे पैरामीटर में ('0,10,20,30,40,50) पर' डिब्बे 'सरणी दें। :

• नंबर 1 (पहले एरे से) 0 और 10 के बीच पड़ता है ('बिन्स ऐरे' में)
• संख्या 11 (पहले सरणी से) 11 और 20 के बीच ('डिब्बे' सरणी में) आती है
• संख्या 21 (पहली सरणी से) 21 और 30 ('बिन' सरणी) में होती है, आदि।

फिर मैं प्रत्येक बिन के आकार को परिभाषित करने के लिए 'वेट' पैरामीटर का उपयोग कर रहा हूं। यह वेट पैरामीटर के लिए उपयोग की जाने वाली सरणी है: [10,1,40,33,6]।

तो 0 से 10 बिन को मान 10 दिया जाता है, 11 से 20 बिन को 1 का मान दिया जाता है, 21 से 30 बिन को 40 का मूल्य दिया जाता है, आदि।

Comments

मुझे लगता है कि आपको एक बुनियादी गलतफहमी है कि हिस्टोग्राम फ़ंक्शन कैसे काम करता है। यह कच्चे डेटा की उम्मीद करता है। इसलिए, आपके उदाहरण में, आपके डेटा ऐरे में 0 मान 10 के बीच 10 मान होना चाहिए, 10 और 20 के बीच 1 मान, और इसी तरह। फिर फ़ंक्शन योग-अप और ड्राइंग करता है। आप ऊपर जो कर रहे हैं वह वर्कअराउंड है क्योंकि आपके पास पहले से ही रकम है (जो कि आप "वेट" विकल्प) का दुरुपयोग करके ग्राफ में डालें। आशा है कि इससे कुछ भ्रम दूर होगा।

— कोडिंगकैट

Answer 7

पूर्णांक x- मानों के साथ एक हिस्टोग्राम के लिए जिसका मैंने उपयोग किया

plt.hist(data, np.arange(min(data)-0.5, max(data)+0.5))
plt.xticks(range(min(data), max(data)))

0.5 की ऑफसेट एक्स-अक्ष मूल्यों पर डिब्बे को केंद्र में रखता है। plt.xticksकॉल हर पूर्णांक के लिए एक टिक कहते हैं।