कर्नेल डेन्सिटी एस्टीमेशन: सिद्धांत से व्यवहार तक

क्या आपने कभी किसी वितरण को विज़ुअलाइज़ करने की कोशिश की है, और हर बार बिन साइज़ बदलते ही हिस्टोग्राम का आकार बदल जाता है?

आमतौर पर यह ऐसे होता है। आप 10 बिन चुनते हैं और एक स्मूथ कर्व दिखता है। फिर 30 पर स्विच करते हैं तो कई पीक दिखती हैं। डेटा वही रहता है, लेकिन अलग-अलग बिन काउंट अलग-अलग व्याख्याएँ देते हैं। हिस्टोग्राम की सबसे बड़ी समस्या यही है: वे आपको वास्तविक वितरण नहीं दिखाते, बल्कि उसका एक संस्करण दिखाते हैं। और वह संस्करण एक ऐसे पैरामीटर से प्रभावित होता है जिसे आपने मनमाने ढंग से सेट किया है।

KDE एक अलग तरीका अपनाता है। डेटा को बिन में बांटने के बजाय, यह हर डेटा पॉइंट पर एक छोटी, स्मूथ कर्व रखता है और सभी को जोड़ देता है। इससे पीछे छिपे वितरण का एक एकल, निरंतर अनुमान मिलता है।

इस लेख में, आपको KDE के पीछे की अंतर्दृष्टि, सूत्र का वॉकथ्रू, बैंडविड्थ किस तरह स्मूथनेस नियंत्रित करती है उसका विवरण, और Python तथा R में व्यावहारिक उदाहरण मिलेंगे।

क्या आप हिस्टोग्राम में नए हैं? यहाँ फ्रीक्वेंसी हिस्टोग्राम पर एक विस्तृत गाइड है जो आपको शुरुआत करने में मदद करेगा।

कर्नेल डेन्सिटी एस्टीमेशन क्या है?

कर्नेल डेन्सिटी एस्टीमेशन एक नॉनपैरामेट्रिक विधि है जो किसी डेटासेट के प्रायिकता घनत्व फलन का आकलन करती है।

इसे अलग बनाने वाली चीज़ है इसका नॉनपैरामेट्रिक होना।

पैरामेट्रिक विधियों में, आप मान लेते हैं कि आपका डेटा किसी खास वितरण का अनुसरण करता है—जैसे नॉर्मल, एक्सपोनेंशियल—और फिर उसे फिट करने के लिए पैरामीटर खोजते हैं। यदि वह मान गलत हुआ, तो आपका मॉडल गलत होगा। KDE ऐसे अनुमान नहीं लगाता। यह डेटा को खुद बोलने देता है और सीधे प्रेक्षणों से अंतर्निहित वितरण का अनुमान बनाता है।

आउटपुट एक स्मूथ कर्व होता है जो बताता है कि मान कहाँ आने की संभावना है—और वह संभावना कितनी है। कर्व के ऊँचे हिस्से घने क्षेत्रों को दर्शाते हैं। निचले हिस्से विरल क्षेत्रों को।

कर्नेल डेन्सिटी एस्टीमेशन का उपयोग क्यों करें?

वितरण को विज़ुअलाइज़ करने के लिए हिस्टोग्राम डिफ़ॉल्ट टूल है, लेकिन इसकी एक समस्या है: जो आकार आप देखते हैं वह आपके चुने गए बिन की संख्या पर निर्भर करता है। और वह बिन पैरामीटर आपको ही चुनना होता है। दो लोग एक ही डेटासेट को देखकर केवल अलग बिन काउंट चुनकर एकदम अलग निष्कर्ष निकाल सकते हैं।

KDE में, डेटा को बिन में ठूँसने के बजाय, यह एक स्मूथ, निरंतर कर्व देता है जो आपके द्वारा मनमाने ढंग से सेट किए गए पैरामीटर पर निर्भर होकर नहीं बदलता।

यह कुछ बातों के लिए खास काम का है:

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

KDE के पीछे की अंतर्दृष्टि

आप हर डेटा पॉइंट लेते हैं और उसके ऊपर एक छोटी, स्मूथ कर्व रखते हैं। इस कर्व को कर्नेल कहते हैं। फिर इन सभी व्यक्तिगत कर्वों को जोड़ देते हैं।

अंत में आपको एक एकल स्मूथ कर्व मिलता है जो आपके डेटा की डेन्सिटी दिखाता है। जहाँ पॉइंट्स का क्लस्टर होता है, वहाँ कई कर्नेल ओवरलैप होकर जुड़ते हैं, इसलिए कर्व ऊपर उठता है। जहाँ डेटा विरल है, कर्नेल मुश्किल से ओवरलैप करते हैं और कर्व नीचा रहता है। हर पॉइंट अंतिम अनुमान में समान योगदान देता है।

मान लीजिए आपने छात्रों की एक कक्षा के फाइनल परीक्षा के अंक रिकॉर्ड किए। उन्हें हिस्टोग्राम में बिन करने के बजाय, KDE हर अंक पर एक छोटी स्मूथ कर्व रखता है। जहाँ अंक क्लस्टर होते हैं—मान लें 70–75 के आसपास—कर्वें एक-दूसरे पर चढ़ती हैं और अनुमान ऊपर जाता है। 95 अंक पाने वाला एक अकेला छात्र टेल पर बस एक छोटा उभार जोड़ता है।

नीचे दिया गया दृश्य यही दिखाता है। अधिकांश छात्रों ने औसत के आसपास अंक प्राप्त किए, और एक छात्र ने बहुत अधिक स्कोर किया:

KDE का विज़ुअलाइज़ेशन

कर्नेल डेन्सिटी एस्टीमेशन का सूत्र

KDE का सूत्र जितना दिखता है उतना डरावना नहीं है।

KDE सूत्र

हर हिस्से का मतलब यह है:

• n डेटा पॉइंट्स की संख्या है

• x_i आपके डेटासेट के व्यक्तिगत डेटा पॉइंट्स हैं

• K कर्नेल फ़ंक्शन है—हर पॉइंट पर रखी जाने वाली स्मूथ कर्व

• h बैंडविड्थ है—यह नियंत्रित करता है कि हर कर्नेल कितना चौड़ा हो

• x वह बिंदु है जहाँ आप डेन्सिटी का आकलन कर रहे हैं

सरल शब्दों में, सूत्र कहता है: किसी भी बिंदु x के लिए, देखें कि हर डेटा पॉइंट x_i उससे कितना पास है, उस निकटता को कर्नेल फ़ंक्शन K से वेट करें, और सभी n पॉइंट्स पर औसत लें। यह हर x के लिए रेंज में करें और आपको पूरा डेन्सिटी कर्व मिल जाएगा।

बैंडविड्थ h, भिन्न के हर में K के अंदर बैठता है। छोटा h कर्नेल को संकरा बनाता है, इसलिए केवल बहुत पास के पॉइंट्स अनुमान को प्रभावित करते हैं। बड़ा h प्रभाव को अधिक चौड़ा फैलाता है। इस पर आगे लेख में और बात करेंगे।

कर्नेल फ़ंक्शन क्या है?

कर्नेल वह स्मूथ कर्व है जिसे आप हर डेटा पॉइंट पर रखते हैं। यह परिभाषित करता है कि उस पॉइंट का प्रभाव अपने पड़ोसियों तक कैसे फैलता है।

हर कर्नेल किसी डेटा पॉइंट पर केंद्रित होता है और दूरी के आधार पर वेट देता है। केंद्र के पास के पॉइंट्स को उच्च वेट मिलता है। दूर के पॉइंट्स को कम या बिल्कुल नहीं। इस वेटिंग का सटीक आकार इस पर निर्भर करता है कि आपने कौन सा कर्नेल चुना है।

तीन सामान्य विकल्प हैं:

• Gaussian: घंटीनुमा कर्व। यह डेटासेट के हर पॉइंट को वेट देता है, और दूरी के साथ प्रभाव घटता है। यह अधिकांश लाइब्रेरीज़ में डिफ़ॉल्ट है और व्यवहार में अच्छा काम करता है
• Uniform: एक सपाट आयत। एक नियत दूरी के भीतर हर पॉइंट को समान वेट मिलता है, और बाहर के पॉइंट्स को कुछ नहीं। सरल, लेकिन कम स्मूथ अनुमान देता है
• Epanechnikov: परवलयिक आकार, जो माध्य वर्ग त्रुटि के लिहाज से गणितीय रूप से श्रेष्ठ है। यह Gaussian से अधिक सक्षम है, लेकिन व्यवहार में शायद ही कभी दृश्य अंतर लाता है।

अधिकांश मामलों में, कर्नेल का चुनाव ज़्यादा मायने नहीं रखता। एक ही बैंडविड्थ के साथ एक ही डेटा पर अलग-अलग दो कर्नेल लगभग समान कर्व देंगे। कहीं अधिक महत्त्वपूर्ण है बैंडविड्थ—और अगला भाग उसी पर है।

KDE में बैंडविड्थ की भूमिका

बैंडविड्थ वह एक पैरामीटर है जिसका KDE आउटपुट पर सबसे बड़ा प्रभाव होता है—आपके चुने कर्नेल से भी अधिक।

यह नियंत्रित करता है कि हर कर्नेल कितना चौड़ा हो। संकरा कर्नेल केवल पास के पॉइंट्स का प्रभाव खींचता है। चौड़ा कर्नेल उस प्रभाव को कहीं अधिक रेंज में फैला देता है। नतीजा या तो ऐसा कर्व होगा जो डेटा का बारीकी से अनुसरण करता है, या ऐसा जो उसे स्मूथ कर देता है।

छोटी बैंडविड्थ

छोटी बैंडविड्थ हर कर्नेल को टाइट और संकरा बना देती है। अनुमान हर डेटा पॉइंट पर तेज़ी से प्रतिक्रिया करता है—मतलब यह डेटा की असली संरचना भी पकड़ता है, और शोर भी।

व्यवहार में, यह कई छोटे पीक के साथ एक नुकीला कर्व दिखता है। इनमें से कुछ पीक आपके डेटा में वास्तविक क्लस्टर दिखाती हैं। बाकी बहुत कम स्मूथिंग के कारण बने आर्टिफैक्ट होते हैं। कौन-सा क्या है, यह बताना मुश्किल हो जाता है—और यही समस्या है।

छोटी बैंडविड्थ के साथ KDE

बड़ी बैंडविड्थ

बड़ी बैंडविड्थ हर कर्नेल को चौड़ा फैला देती है। आस-पास के कर्नेल ओवरलैप करते हैं, और अंतिम कर्व स्मूथ निकलता है।

यदि यह बहुत अधिक स्मूथ हो जाए, तो आप वास्तविक संरचना खोने लगते हैं। दो अलग-अलग क्लस्टर एक ही कर्व में धुंधले हो सकते हैं। हेवी टेल वाला वितरण सममित दिख सकता है। दृश्य प्रतिनिधित्व आपसे चीजें छिपा सकता है।

बड़ी बैंडविड्थ के साथ KDE

सही बैंडविड्थ खोजना

कोई सार्वभौमिक रूप से सही बैंडविड्थ नहीं होती। लक्ष्य ऐसा मान चुनना है जो शोर को छाँटने के लिए पर्याप्त स्मूथ हो, पर इतना भी नहीं कि वास्तविक पैटर्न मिट जाएँ।

अधिकांश लाइब्रेरीज़ स्वचालित बैंडविड्थ चयन विधियाँ देती हैं। सिल्वरमैन का रूल ऑफ थम्ब सबसे आम है। यह आपके डेटा के सैंपल साइज़ और स्टैंडर्ड डिविएशन के आधार पर बैंडविड्थ चुनता है। यह मोटे तौर पर नॉर्मल वितरणों के लिए अच्छा काम करता है, लेकिन मल्टीमोडल वितरणों को ज़्यादा स्मूथ कर सकता है।

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

KDE बनाम हिस्टोग्राम

हिस्टोग्राम और KDE दोनों आपके डेटा का वितरण दिखाते हैं—लेकिन बिल्कुल अलग तरीके से।

हिस्टोग्राम

हिस्टोग्राम आपका डेटा पृथक बिन में विभाजित करता है और गिनता है कि हर बिन में कितने पॉइंट्स आते हैं। यह तेज़, सहज और गैर-तकनीकी दर्शकों को समझाना आसान है।

समस्या है बिन-संवेदनशीलता। यदि आप बिन की संख्या बदलते हैं, तो आकार बदलता है। कोई वस्तुनिष्ठ रूप से सही बिन काउंट नहीं है, यानी दो लोग केवल इसी एक चुनाव से अलग निष्कर्ष निकाल सकते हैं।

हिस्टोग्राम एक सीढ़ीनुमा, असतत आकार भी देते हैं। त्वरित नज़र के लिए यह ठीक है, लेकिन यह वास्तविक अंतर्निहित वितरण को धुंधला कर सकता है।

KDE

KDE बिना बिन के एक स्मूथ, निरंतर कर्व देता है। यह वितरण के वास्तविक आकार—जैसे स्क्यू, कई पीक, या हेवी टेल—को उजागर करने में बेहतर है, जिन्हें हिस्टोग्राम बिन-चॉइस पर निर्भर होकर छोड़ सकता है या गलत दिखा सकता है।

समझौता यह है कि KDE अपना एक पैरामीटर—बैंडविड्थ—लाता है और अधिक गणना माँगता है। इसे समझाना भी कम सहज है, क्योंकि y-अक्ष काउंट नहीं बल्कि प्रायिकता घनत्व दिखाता है, जो इस अवधारणा से अनभिज्ञ पाठकों को भ्रमित कर सकता है।

कब किसका उपयोग करें

जब आपको अपने डेटा का एक त्वरित, व्याख्यात्मक सारांश चाहिए या जब आपका श्रोता डेन्सिटी अनुमानों से परिचित न हो, तो हिस्टोग्राम का उपयोग करें। जब वितरण का आकार मायने रखता हो—जैसे समूहों की तुलना करते समय या अपने डेटा में कई मोड्स खोजने की कोशिश करते समय—तो KDE का उपयोग करें।

हिस्टोग्राम और KDE की तुलना

व्यवहार में, इन्हें अक्सर साथ में उपयोग किया जाता है: काउंट्स के लिए हिस्टोग्राम, और ऊपर ओवरले के रूप में आकार के लिए KDE कर्व।

Python में कर्नेल डेन्सिटी एस्टीमेशन

Python आपको KDE की गणना और प्लॉट करने के कुछ तरीके देता है—इस पर निर्भर कि आपको एक त्वरित चार्ट चाहिए या अनुमान पर अधिक नियंत्रण।

seaborn के साथ KDE का विज़ुअलाइज़ेशन

seaborn.kdeplot() से KDE प्लॉट पाने का सबसे तेज़ तरीका है। बस इतना ही करना होता है:

import seaborn as sns
import numpy as np

np.random.seed(42)
scores = np.concatenate([
    np.random.normal(65, 4, 60),
    np.random.normal(80, 3, 40)
])

sns.kdeplot(scores, bw_adjust=1)

seaborn के साथ KDE

पैरामीटर bw_adjust स्वचालित रूप से चुनी गई बैंडविड्थ को स्केल करता है। 1 से कम मान कर्व को टाइट करते हैं, 1 से ऊपर वाले उसे और स्मूथ बनाते हैं। यह seaborn द्वारा आंतरिक रूप से चुनी गई बैंडविड्थ पर एक गुणक है, इसलिए आपको कच्चा बैंडविड्थ मान खुद सेट करने की ज़रूरत नहीं।

y-अक्ष काउंट्स नहीं बल्कि प्रायिकता घनत्व दिखाता है। कर्व बताता है कि किसी मान के आने की सापेक्ष संभावना कितनी है। जितना ऊँचा, उतना अधिक डेटा वहाँ सघन है।

scipy के साथ KDE की गणना

यदि आपको सिर्फ प्लॉट नहीं बल्कि वास्तविक डेन्सिटी मान चाहिए, तो scipy.stats.gaussian_kde का उपयोग करें। यह आपको एक callable ऑब्जेक्ट देता है जिसे आप किसी भी बिंदु पर इवैल्युएट कर सकते हैं।

from scipy.stats import gaussian_kde
import numpy as np
import matplotlib.pyplot as plt

kde = gaussian_kde(scores, bw_method="scott")
x = np.linspace(45, 100, 500)
density = kde(x)

plt.plot(x, density)

bw_method="scott" स्कॉट का नियम उपयोग करता है ताकि बैंडविड्थ स्वतः चुनी जा सके। अधिकांश मामलों के लिए यह अच्छा डिफ़ॉल्ट है। आप बैंडविड्थ को मैन्युअल रूप से सेट करने के लिए स्केलर भी दे सकते हैं।

scipy और matplotlib के साथ KDE

R में कर्नेल डेन्सिटी एस्टीमेशन

R में KDE बेस भाषा में ही मौजूद है। आपको कोई अतिरिक्त पैकेज नहीं चाहिए।

density() से KDE की गणना

density() फ़ंक्शन एक संख्यात्मक वेक्टर लेता है और KDE ऑब्जेक्ट लौटाता है।

set.seed(42)
scores <- c(rnorm(60, mean = 65, sd = 4),
            rnorm(40, mean = 80, sd = 3))

kde <- density(scores, bw = "SJ")

आर्गुमेंट bw बैंडविड्थ चयन को नियंत्रित करता है। "SJ" शीथर-जोन्स विधि का उपयोग करता है, जो डिफ़ॉल्ट से बेहतर तरीके से मल्टीमोडल वितरणों को संभालता है। आप बैंडविड्थ को मैन्युअल रूप से सेट करने के लिए एक संख्यात्मक मान भी दे सकते हैं।

परिणाम एक लिस्ट ऑब्जेक्ट होता है जिसमें दो प्रमुख घटक होते हैं:

• kde$x: वे बिंदु जिन पर डेन्सिटी इवैल्युएट की गई
• kde$y: उसके अनुरूप डेन्सिटी मान

कर्व को प्लॉट करना

परिणाम को सीधे plot() में पास कर दें।

plot(kde,
     main = "Exam Score Distribution",
     xlab = "Score",
     ylab = "Density")

R में प्लॉट किया गया KDE

KDE को हिस्टोग्राम पर ओवरले करने के लिए, पहले hist() को freq = FALSE के साथ उपयोग करें, फिर lines() से कर्व जोड़ दें।

hist(scores, freq = FALSE, main = "Histogram + KDE", xlab = "Score")
lines(kde, col = "blue", lwd = 2)

R में KDE के साथ हिस्टोग्राम

freq = FALSE हिस्टोग्राम को डेन्सिटी पर स्केल करता है ताकि बार और कर्व दोनों एक ही y-अक्ष साझा करें।

KDE के फायदे और सीमाएँ

KDE सच में एक उपयोगी विज़ुअल है, लेकिन हर चीज़ की तरह, इसे हिस्टोग्राम्स के स्थान पर उपयोग करने से पहले कुछ समझौते जानना ज़रूरी है।

फायदे

सबसे बड़ा लाभ यह है कि KDE आपके डेटा के वितरण के बारे में कोई मान्यताओं की आवश्यकता नहीं रखता। आपको पहले से यह तय नहीं करना पड़ता कि आपका डेटा नॉर्मल है, एक्सपोनेंशियल है, या कुछ और। आकार डेटा से खुद आता है, जो KDE को मल्टीमोडल वितरणों और उन सभी मामलों को संभालने के लिए पर्याप्त लचीला बनाता है जो मानक पैरामेट्रिक फ़ॉर्म में फिट नहीं होते।

आउटपुट भी एक स्मूथ, निरंतर कर्व होता है, न कि एक सीढ़ीनुमा एप्रॉक्सिमेशन। यह पैटर्न—जैसे कई पीक या लंबी टेल—को पहचानना आसान बनाता है, जिन्हें हिस्टोग्राम बिन-चॉइस पर निर्भर होकर छिपा सकता है।

और क्योंकि KDE कच्चे डेटा पर काम करता है, बिना पहले कोई मॉडल फिट किए, यह किसी भी अन्वेषणात्मक विश्लेषण में अच्छा पहला कदम है।

सीमाएँ

बैंडविड्थ चयन मुख्य कमजोरी है। यदि आप इसे गलत चुनते हैं, तो अनुमान या तो शोर के पीछे भागेगा, या डेटा के वास्तविक पैटर्न को स्मूथ करके मिटा देगा। सिल्वरमैन के नियम जैसी स्वचालित विधियाँ मोटे तौर पर नॉर्मल डेटा के लिए अच्छी हैं, लेकिन जटिल वितरणों पर गुमराह कर सकती हैं। नतीजे पर भरोसा करने से पहले अक्सर कुछ बैंडविड्थ मानों को मैन्युअल रूप से जाँचना पड़ता है।

स्केल पर प्रदर्शन समस्या बन सकता है। KDE हर इवैल्युएशन लोकेशन पर हर डेटा पॉइंट के लिए कर्नेल फ़ंक्शन का मूल्यांकन करता है, यानी जैसे-जैसे डेटासेट बड़ा होता है, गणना तेज़ी से बढ़ती है। अधिकांश अन्वेषणात्मक कार्य के लिए यह मुद्दा नहीं है, लेकिन लाखों पॉइंट्स वाले डेटासेट पर यह धीमा हो सकता है।

सीमा-प्रभाव अधिक सूक्ष्म समस्या हैं। मानक KDE मानता है कि डेटा दोनों दिशाओं में अनंत तक जा सकता है। जब आपके डेटा की कठोर सीमा होती है—जैसे मान शून्य से नीचे नहीं जा सकते—तो अनुमान उस सीमा के पार प्रायिकता द्रव्यमान लीक कर देता है, जिससे किनारे के पास कर्व कृत्रिम रूप से नीचा बन जाता है। सीमा-सुधारित KDE संस्करण मौजूद हैं, लेकिन मानक लाइब्रेरीज़ में वे कम ही लागू होते हैं।

निष्कर्ष

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

बैंडविड्थ वह एक पैरामीटर है जो सच में मायने रखता है। कुछ मान आज़माएँ, कर्व की तुलना करें, स्वचालित विकल्पों का उपयोग करें, और निष्कर्ष निकालने से पहले सुनिश्चित करें कि अनुमान आपके डेटा के बारे में आपकी जानकारी से मेल खाता है।

KDE की सहज समझ बनाने का सबसे अच्छा तरीका है इसे वास्तविक डेटा पर चलाना। कोई ऐसा डेटासेट चुनें जिससे आप पहले से परिचित हों, KDE लागू करें, और हिस्टोग्राम से तुलना करें—देखें आपने अब तक क्या मिस किया था।

डेटा विज़ुअलाइज़ेशन में रुचि है? यदि आप Python उपयोग कर रहे हैं तो हमारे Seaborn के साथ डेटा विज़ुअलाइज़ेशन कोर्स देखें, या यदि आप R उपयोग कर रहे हैं तो ggplot2 के साथ डेटा विज़ुअलाइज़ेशन कोर्स देखें।