मानक विचलन के लिए बूटस्ट्रैप विधियाँ

बूटस्ट्रैप: कंप्यूटर-युग की सांख्यिकीय क्रांति

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

बूटस्ट्रैप के पीछे की मुख्य अंतर्दृष्टि सुंदर रूप से सरल है: आपका प्रतिदर्श समष्टि का आपका सबसे अच्छा अनुमान है। अपने प्रतिदर्श से पुनःप्रतिचयन (प्रतिस्थापन के साथ) करके, आप अनुकरण करते हैं कि यदि आप बार-बार समष्टि से प्रतिचयन कर सकते तो क्या होता। यह दृष्टिकोण मानक विचलन के लिए विशेष रूप से मूल्यवान है, जहाँ पारंपरिक विश्वास अंतराल सूत्र सामान्यता मानते हैं—एक मान्यता जो व्यवहार में अक्सर विफल होती है।

बूटस्ट्रैप आधुनिक डेटा विज्ञान में आवश्यक बन गया है क्योंकि यह किसी भी सांख्यिकी (माध्यिका, सहसंबंध, प्रतिगमन गुणांक, तंत्रिका नेटवर्क भार) के साथ काम करता है और आपके डेटा के अंतर्निहित वितरण के बारे में कोई मान्यता नहीं रखता।

मानक विचलन के लिए बूटस्ट्रैप क्यों?

मानक विचलन के लिए पारंपरिक विश्वास अंतराल मानते हैं कि आपका डेटा सामान्य वितरण से आता है। जब यह मान्यता विफल हो (जो आम है), तो ये अंतराल बेहद गलत हो सकते हैं। बूटस्ट्रैप एक वितरण-मुक्त विकल्प प्रदान करता है।

मानक विचलन के लिए बूटस्ट्रैप के प्रमुख लाभ:

• कोई वितरण मान्यता नहीं: सामान्य, विषम, या भारी-पूँछ डेटा के साथ समान रूप से काम करता है
• छोटे प्रतिदर्श प्रदर्शन: n < 30 के साथ अक्सर प्राचलिक विधियों से अधिक सटीक
• जटिल सांख्यिकी संभालता है: समान दृष्टिकोण छँटे हुए SD, MAD, या कस्टम परिवर्तनशीलता मापों के लिए काम करता है
• दृश्य अंतर्दृष्टि: बूटस्ट्रैप वितरण आपको दिखाता है कि क्या हो रहा है, न कि केवल अंतिम संख्याएँ

बूटस्ट्रैप प्रक्रिया

बूटस्ट्रैप एल्गोरिथ्म उल्लेखनीय रूप से सीधा है। n प्रेक्षणों के अपने मूल प्रतिदर्श से:

कितने बूटस्ट्रैप प्रतिदर्श? मोटे अनुमानों और परिकल्पना परीक्षणों के लिए B = 1,000 अक्सर पर्याप्त है। विश्वास अंतरालों के लिए, B = 10,000 स्थिर शतमक प्रदान करता है। प्रकाशन-गुणवत्ता BCa अंतरालों के लिए, B = 15,000+ अनुशंसित है।

बूटस्ट्रैप विश्वास अंतराल विधियाँ

बूटस्ट्रैप प्रतिदर्शों से विश्वास अंतराल बनाने के लिए कई विधियाँ मौजूद हैं, प्रत्येक के अपने ट्रेड-ऑफ हैं:

1. शतमक विधि (सबसे सरल)

सबसे सहज दृष्टिकोण: सीधे बूटस्ट्रैप वितरण के शतमक लें।

10,000 बूटस्ट्रैप प्रतिदर्शों के लिए, यह 250वाँ और 9,750वाँ क्रमित मान है। सरल लेकिन जब बूटस्ट्रैप वितरण विषम हो तो पक्षपाती हो सकता है।

2. मूल (धुरी) बूटस्ट्रैप

प्रतिदर्श सांख्यिकी और बूटस्ट्रैप सांख्यिकी के बीच संबंध का उपयोग करता है:

जहाँ θ̂ मूल प्रतिदर्श SD है। यह शतमक अंतराल को प्रतिदर्श अनुमान के चारों ओर “प्रतिबिंबित” करता है।

3. BCa (पूर्वाग्रह-संशोधित और त्वरित)

सटीकता के लिए स्वर्ण मानक। BCa बूटस्ट्रैप वितरण में पूर्वाग्रह और त्वरण (प्राचल मान के साथ मानक त्रुटि कैसे बदलती है) दोनों के लिए समायोजन करता है। गणना में अधिक जटिल लेकिन द्वितीय-क्रम सटीक अंतराल प्रदान करता है।

हल किया गया उदाहरण: गैर-सामान्य डेटा

प्रतिक्रिया समय (ms में) के 15 माप पर विचार करें: 245, 312, 287, 456, 234, 298, 267, 523, 289, 301, 278, 645, 256, 289, 312। यह डेटा दाएँ-विषम है (कुछ बहुत धीमी प्रतिक्रियाएँ)।

बूटस्ट्रैप CI असममित है (उच्च पक्ष पर चौड़ा), जो डेटा की दाएँ-विषम प्रकृति को दर्शाता है। काई-वर्ग CI इस असममिति को पकड़ नहीं पाता।

Python कार्यान्वयन

कई CI विधियों के साथ संपूर्ण बूटस्ट्रैप कार्यान्वयन:

import numpy as np
from scipy import stats

def bootstrap_sd_ci(data, n_bootstrap=10000, ci=0.95, method='percentile'):
    """
    Bootstrap confidence interval for standard deviation.

    Parameters:
    -----------
    data : array-like - Original sample
    n_bootstrap : int - Number of bootstrap samples
    ci : float - Confidence level (e.g., 0.95)
    method : str - 'percentile', 'basic', or 'bca'

    Returns:
    --------
    tuple : (lower_bound, upper_bound, bootstrap_sds)
    """
    data = np.array(data)
    n = len(data)
    original_sd = np.std(data, ddof=1)

    # Generate bootstrap samples and calculate SDs
    bootstrap_sds = np.array([
        np.std(np.random.choice(data, size=n, replace=True), ddof=1)
        for _ in range(n_bootstrap)
    ])

    alpha = 1 - ci

    if method == 'percentile':
        lower = np.percentile(bootstrap_sds, 100 * alpha/2)
        upper = np.percentile(bootstrap_sds, 100 * (1 - alpha/2))

    elif method == 'basic':
        lower = 2*original_sd - np.percentile(bootstrap_sds, 100*(1-alpha/2))
        upper = 2*original_sd - np.percentile(bootstrap_sds, 100*alpha/2)

    elif method == 'bca':
        # Bias correction
        prop_less = np.mean(bootstrap_sds < original_sd)
        z0 = stats.norm.ppf(prop_less)

        # Acceleration (jackknife estimate)
        jackknife_sds = np.array([
            np.std(np.delete(data, i), ddof=1) for i in range(n)
        ])
        jack_mean = jackknife_sds.mean()
        a = np.sum((jack_mean - jackknife_sds)**3) / \
            (6 * np.sum((jack_mean - jackknife_sds)**2)**1.5)

        # Adjusted percentiles
        z_alpha = stats.norm.ppf([alpha/2, 1-alpha/2])
        adj_percentiles = stats.norm.cdf(
            z0 + (z0 + z_alpha) / (1 - a*(z0 + z_alpha))
        ) * 100
        lower = np.percentile(bootstrap_sds, adj_percentiles[0])
        upper = np.percentile(bootstrap_sds, adj_percentiles[1])

    return lower, upper, bootstrap_sds

# Example usage
response_times = [245, 312, 287, 456, 234, 298, 267, 523, 289, 301, 278, 645, 256, 289, 312]

for method in ['percentile', 'basic', 'bca']:
    lower, upper, _ = bootstrap_sd_ci(response_times, method=method)
    print(f"{method.upper():12s} 95% CI: [{lower:.1f}, {upper:.1f}]")