Pandas & NumPy Academy · पाठ

ANOVA और पोस्ट-हॉक परीक्षण

एक-मार्गी ANOVA से तीन या अधिक समूहों के माध्यों की तुलना कीजिए और अलग-अलग युग्मों की पहचान के लिए Tukey HSD चलाइए।

पाठ 4, कुल 4 में से13 चरण

ANOVA और पोस्ट-हॉक परीक्षण, CoddyKit पर Pandas & NumPy Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Pandas & NumPy Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

एकाधिक T-Tests क्यों नहीं?

तीन या अधिक समूहों के माध्यों की तुलना करते समय, कई t-tests चलाने से Type I त्रुटि दर (झूठी सकारात्मक दर) बढ़ जाती है। समूह A बनाम B, A बनाम C और B बनाम C के परीक्षणों में प्रत्येक के लिए α=0.05 रखने पर, कुल झूठी सकारात्मक संभावना 5% नहीं बल्कि लगभग 14% हो जाती है। Analysis of Variance (ANOVA) एक ही परीक्षण में सभी समूहों का एक साथ परीक्षण करके इस समस्या को हल करता है और झूठी सकारात्मक दर को ठीक α पर बनाए रखता है। समग्र प्रश्न—'क्या किसी भी समूह में अंतर है?'—के लिए एक ANOVA सभी युग्मवार t-tests का स्थान लेता है।

वन-वे ANOVA: समग्र दृष्टिकोण

One-way ANOVA यह जाँचता है कि तीन या अधिक समूहों के माध्य में महत्वपूर्ण अंतर है या नहीं। यह कुल विचरण को समूहों के बीच के विचरण (समूह-सदस्यता द्वारा समझाया गया) और समूहों के भीतर के विचरण (यादृच्छिक शोर) में विभाजित करता है। F-सांख्यिकी इन दोनों का अनुपात है: F = (समूहों के बीच का विचरण) / (समूहों के भीतर का विचरण)। बड़ा F यह दर्शाता है कि शोर की तुलना में समूहों के अंतर बड़े हैं, जिससे p-value छोटी होती है। शून्य परिकल्पना है: H₀: सभी समूहों के माध्य समान हैं।

import numpy as np
from scipy import stats

np.random.seed(0)
# Three product variants with different conversion rates
group_a = np.random.normal(10.0, 2.0, 50)  # baseline
group_b = np.random.normal(11.5, 2.0, 50)  # slightly better
group_c = np.random.normal(13.0, 2.0, 50)  # clearly better

f_stat, p = stats.f_oneway(group_a, group_b, group_c)
print(f'F-statistic: {f_stat:.3f}')
print(f'p-value: {p:.6f}')
print('At least one group differs?', 'Yes' if p < 0.05 else 'No')

पैंडस DataFrames के साथ ANOVA

व्यवहार में, आपका डेटा एक लॉन्ग-फ़ॉर्मेट DataFrame में होता है, जिसमें एक कॉलम समूह-लेबल और दूसरा माप रखता है। प्रत्येक समूह को एक Series के रूप में निकालकर stats.f_oneway() में दें। वैकल्पिक रूप से, यदि आपके पास वाइड-फ़ॉर्मेट DataFrame है (प्रत्येक समूह के लिए एक कॉलम), तो प्रत्येक कॉलम सीधे दें। यह फ़ंक्शन किसी भी संख्या में स्थितीय आर्ग्युमेंट स्वीकार करता है, जिससे इसे 4, 5 या उससे अधिक समूहों तक बढ़ाना आसान हो जाता है।

import pandas as pd
import numpy as np
from scipy import stats

np.random.seed(1)
df = pd.DataFrame({
    'group': ['A']*40 + ['B']*40 + ['C']*40 + ['D']*40,
    'score': np.concatenate([
        np.random.normal(70, 10, 40),
        np.random.normal(75, 10, 40),
        np.random.normal(80, 10, 40),
        np.random.normal(72, 10, 40)
    ])
})

groups = [group['score'].values
          for _, group in df.groupby('group')]

f, p = stats.f_oneway(*groups)
print(f'F={f:.3f}, p={p:.4f}')
print(df.groupby('group')['score'].mean().round(2))

ANOVA की मान्यताएँ

One-way ANOVA की मान्यताएँ हैं: (1) स्वतंत्रता — प्रेक्षण एक-दूसरे से स्वतंत्र हों; (2) सामान्यता — प्रत्येक समूह में अवशेष लगभग normal हों (CLT के कारण बड़े नमूनों के लिए यह विधि मजबूत होती है); (3) सम-विचरणता — सभी समूहों में विचरण समान हों। विचरण की मान्यता की जाँच Levene's test (stats.levene(*groups)) से करें। यदि विचरण असमान हों, तो इसके बजाय Welch's ANOVA का उपयोग करें, जो pingouin लाइब्रेरी में उपलब्ध है या statsmodels के माध्यम से निकाला जा सकता है।

import numpy as np
from scipy import stats

np.random.seed(0)
g1 = np.random.normal(10, 2, 40)
g2 = np.random.normal(12, 2, 40)
g3 = np.random.normal(11, 8, 40)   # Much higher variance

# Test equal variances
stat_l, p_l = stats.levene(g1, g2, g3)
print(f'Levene\'s test: stat={stat_l:.3f}, p={p_l:.4f}')
if p_l < 0.05:
    print('Warning: Unequal variances! Standard ANOVA may be unreliable.')
    print('Consider Welch\'s ANOVA or Kruskal-Wallis.')

Kruskal-Wallis: गैर-पैरामीट्रिक ANOVA

जब ANOVA की मान्यताओं का उल्लंघन हो (गैर-सामान्य वितरण, छोटे नमूने, असमान विचरण), तो Kruskal-Wallis test गैर-पैरामीट्रिक विकल्प है। यह डेटा को रैंक में बदलकर और रैंक किए गए योगों की तुलना करके जाँचता है कि समूहों के वितरण अलग हैं या नहीं। scipy.stats.kruskal(*groups) का उपयोग करें। शून्य परिकल्पना यह है कि सभी समूहों का वितरण समान है (जब वितरण का आकार समान हो, तो यह समान माध्यों की जाँच के समतुल्य है)। यह हमेशा मान्य होता है, लेकिन जब मान्यताएँ पूरी होती हैं तब ANOVA की तुलना में कम प्रभावशाली होता है।

import numpy as np
from scipy import stats

np.random.seed(0)
# Non-normal data: customer satisfaction scores (1-10 scale)
g1 = np.random.choice(range(1, 11), 50, p=[0.05]*10)
g2 = np.random.choice(range(1, 11), 50, p=[0.02, 0.03, 0.05, 0.08, 0.12, 0.15, 0.20, 0.15, 0.12, 0.08])
g3 = np.random.choice(range(1, 11), 50, p=[0.15, 0.15, 0.15, 0.15, 0.10, 0.10, 0.08, 0.05, 0.04, 0.03])

stat, p = stats.kruskal(g1, g2, g3)
print(f'Kruskal-Wallis: H={stat:.3f}, p={p:.4f}')
print('Groups differ?', 'Yes' if p < 0.05 else 'No')

पोस्ट-हॉक परीक्षण: इनकी आवश्यकता क्यों है

महत्वपूर्ण ANOVA आपको बताता है कि कम-से-कम एक समूह का माध्य अलग है, लेकिन यह नहीं बताता कि कौन-से युग्म अलग हैं। Post-hoc tests सभी युग्मवार तुलनाएँ करते हैं और एकाधिक तुलनाओं के लिए सुधार लागू करते हैं। सबसे लोकप्रिय Tukey's Honest Significant Difference (Tukey HSD) है, जो family-wise error rate को ठीक α पर नियंत्रित करता है। यह statsmodels.stats.multicomp.pairwise_tukeyhsd() में उपलब्ध है। Post-hoc tests केवल महत्वपूर्ण ANOVA के बाद चलाएँ—गैर-महत्वपूर्ण परिणामों पर अंधाधुंध खोज के रूप में नहीं।

import numpy as np
import pandas as pd
from scipy import stats
from statsmodels.stats.multicomp import pairwise_tukeyhsd

np.random.seed(0)
data = np.concatenate([
    np.random.normal(70, 10, 40),
    np.random.normal(80, 10, 40),
    np.random.normal(75, 10, 40)
])
groups = ['A']*40 + ['B']*40 + ['C']*40

# First confirm ANOVA is significant
f, p = stats.f_oneway(*[data[i*40:(i+1)*40] for i in range(3)])
print(f'ANOVA p={p:.4f}')
if p < 0.05:
    print('Post-hoc Tukey HSD:')
    print(pairwise_tukeyhsd(data, groups, alpha=0.05))

Tukey HSD आउटपुट पढ़ना

Tukey HSD तालिका में समूहों के प्रत्येक युग्म के लिए एक पंक्ति होती है। जिन कॉलम पर ध्यान देना चाहिए वे हैं: meandiff (युग्म के बीच माध्य का अंतर), lower और upper (अंतर के लिए 95% confidence interval), तथा reject (यदि युग्म α पर महत्वपूर्ण रूप से अलग है तो True)। ऐसा CI जिसमें शून्य शामिल नहीं होता, यह दर्शाता है कि युग्म में महत्वपूर्ण अंतर है। जिन समूहों के CI एक-दूसरे को ओवरलैप करते हैं, वे एक-दूसरे से महत्वपूर्ण रूप से अलग नहीं होते।

import numpy as np
from statsmodels.stats.multicomp import pairwise_tukeyhsd

np.random.seed(42)
data = np.concatenate([
    np.random.normal(10, 2, 60),  # Group A
    np.random.normal(13, 2, 60),  # Group B (clearly higher)
    np.random.normal(10.5, 2, 60) # Group C (barely different from A)
])
groups = ['A']*60 + ['B']*60 + ['C']*60

result = pairwise_tukeyhsd(data, groups, alpha=0.05)
print(result)
# A-B: reject=True (B is higher)
# A-C: reject=False (barely different)
# B-C: reject=True (B is higher)

Bonferroni और Benjamini-Hochberg सुधार

Tukey HSD के विकल्प के रूप में, आप युग्मवार t-tests पर Bonferroni correction लागू कर सकते हैं: सभी t-tests चलाएँ, फिर सीमा को α/k करें, जहाँ k तुलनाओं की संख्या है। यह रूढ़िवादी है—इससे वास्तविक अंतर छूट सकते हैं। Benjamini-Hochberg False Discovery Rate (FDR) correction कम रूढ़िवादी है: यह झूठी खोजों के अपेक्षित अनुपात को नियंत्रित करता है, जिससे थोड़ी अधिक झूठी सकारात्मकताओं की कीमत पर अधिक वास्तविक सकारात्मक परिणाम मिलते हैं। statsmodels.stats.multitest.multipletests(p_values, method='fdr_bh') का उपयोग करें।

import numpy as np
from scipy import stats
from statsmodels.stats.multitest import multipletests

np.random.seed(0)
groups = [np.random.normal(10 + i*1.5, 2, 40) for i in range(4)]
names = ['A', 'B', 'C', 'D']

# All pairwise t-tests
p_values = []
pairs = []
for i in range(len(groups)):
    for j in range(i+1, len(groups)):
        _, p = stats.ttest_ind(groups[i], groups[j])
        p_values.append(p)
        pairs.append(f'{names[i]}-{names[j]}')

# Benjamini-Hochberg correction
reject, adj_p, _, _ = multipletests(p_values, method='fdr_bh')
for pair, p, ap, r in zip(pairs, p_values, adj_p, reject):
    print(f'{pair}: raw_p={p:.4f}, adj_p={ap:.4f}, significant={r}')

ANOVA के लिए प्रभाव आकार: Eta-Squared

ANOVA के लिए Cohen's d के समान माप eta-squared (η²) है: समूह-सदस्यता द्वारा समझाए गए कुल विचरण का अनुपात। η² = SS_between / SS_total। मान: < 0.01 छोटा, 0.06 मध्यम और > 0.14 बड़ा प्रभाव दर्शाता है। Partial eta-squared (η²_p) प्रकाशित शोध में अधिक सामान्य है: इसमें कुल विचरण के बजाय केवल समूह-विचरण और त्रुटि-विचरण के योग से भाग दिया जाता है। प्रभाव के केवल सांख्यिकीय रूप से पता चलने के बजाय व्यावहारिक रूप से सार्थक होने को दिखाने के लिए, ANOVA p-value के साथ हमेशा η² की गणना करें।

import numpy as np
from scipy import stats

np.random.seed(0)
groups = [
    np.random.normal(10, 2, 50),
    np.random.normal(12, 2, 50),
    np.random.normal(14, 2, 50)
]

all_data = np.concatenate(groups)
grand_mean = all_data.mean()

ss_between = sum(len(g) * (g.mean() - grand_mean)**2 for g in groups)
ss_total = sum((x - grand_mean)**2 for g in groups for x in g)
eta_sq = ss_between / ss_total

f, p = stats.f_oneway(*groups)
print(f'F={f:.3f}, p={p:.4f}')
print(f'Eta-squared: {eta_sq:.4f} ({eta_sq:.1%} of variance explained)')

टू-वे ANOVA का परिचय

Two-way ANOVA एक साथ दो श्रेणीबद्ध कारकों तक one-way ANOVA का विस्तार करता है। उदाहरण के लिए, यह जाँचना कि परीक्षा के अंकों में शिक्षण विधि और विद्यार्थी के अनुभव स्तर—दोनों के आधार पर—अंतर है या नहीं। यह interaction effect का भी परीक्षण करता है: क्या शिक्षण विधि का प्रभाव अनुभव स्तर पर निर्भर करता है? statsmodels में Two-way ANOVA को ols('score ~ C(method) + C(level) + C(method):C(level)', data=df).fit() और anova_lm(model) के माध्यम से लागू किया जाता है। यह अधिक उन्नत प्रयोगात्मक डिज़ाइन की नींव है।

import pandas as pd
import numpy as np
from statsmodels.formula.api import ols
from statsmodels.stats.anova import anova_lm

np.random.seed(0)
df = pd.DataFrame({
    'method': ['trad']*60 + ['active']*60,
    'level': ['beginner']*30 + ['advanced']*30 + ['beginner']*30 + ['advanced']*30,
    'score': (np.random.normal(70, 8, 30).tolist() +
              np.random.normal(80, 8, 30).tolist() +
              np.random.normal(75, 8, 30).tolist() +
              np.random.normal(88, 8, 30).tolist())
})

model = ols('score ~ C(method) + C(level) + C(method):C(level)', data=df).fit()
print(anova_lm(model, typ=2)[['F', 'PR(>F)']].round(4))

Repeated Measures ANOVA

Repeated measures ANOVA का उपयोग तब किया जाता है जब उन्हीं subjects को कई बार मापा जाता है—उदाहरण के लिए, उपचार के 0, 30 और 60 मिनट बाद reaction time का परीक्षण। यह paired t-test का बहु-समूह सामान्यीकरण है। व्यक्तिगत अंतरों का लेखा-जोखा रखने के कारण इसमें one-way ANOVA की तुलना में अधिक statistical power होती है। Python में post-hoc analysis के लिए pingouin.rm_anova() या pg.pairwise_tests() का उपयोग करें। जब sphericity का उल्लंघन हो (जिसकी जाँच Mauchly's test से की जाती है), तो Greenhouse-Geisser corrected p-values का उपयोग करें।

import pandas as pd
import numpy as np

# Example structure for repeated measures (pingouin library)
np.random.seed(0)
subjects = list(range(20)) * 3   # 20 subjects, 3 time points
timepoints = ['T0']*20 + ['T1']*20 + ['T2']*20
scores = np.concatenate([
    np.random.normal(50, 10, 20),   # baseline
    np.random.normal(55, 10, 20),   # improved
    np.random.normal(60, 10, 20)    # further improved
])

df_rm = pd.DataFrame({'subject': subjects, 'time': timepoints, 'score': scores})
print(df_rm.groupby('time')['score'].mean().round(2))
# Use pingouin.rm_anova(data=df_rm, dv='score', within='time', subject='subject')

त्वरित जाँच

इस lesson से Data Analysis की अवधारणाओं की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

Lesson Recap

इस lesson में आपने सीखा: scipy.stats.f_oneway() समग्र Type I error rate को नियंत्रित करते हुए जाँचता है कि किसी समूह के माध्य में अंतर है या नहीं; post-hoc tests (Tukey HSD) महत्वपूर्ण ANOVA के बाद यह पहचानते हैं कि कौन-से विशिष्ट युग्म अलग हैं; और Kruskal-Wallis तब गैर-पैरामीट्रिक fallback है जब normality या समान-विचरण की मान्यताओं का उल्लंघन हो। अब हम capstone project शुरू करेंगे, जिसमें सभी कौशलों को एक end-to-end data pipeline में जोड़ा जाएगा।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

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

पाठ्यक्रम: 30
पाठ: 120

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “ANOVA और पोस्ट-हॉक परीक्षण” पाठ निःशुल्क है?

हाँ—“ANOVA और पोस्ट-हॉक परीक्षण” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Pandas & NumPy Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Pandas & NumPy Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“ANOVA और पोस्ट-हॉक परीक्षण” में मैं क्या सीखूँगा?

एक-मार्गी ANOVA से तीन या अधिक समूहों के माध्यों की तुलना कीजिए और अलग-अलग युग्मों की पहचान के लिए Tukey HSD चलाइए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Pandas & NumPy Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Pandas & NumPy Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Pandas & NumPy Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“ANOVA और पोस्ट-हॉक परीक्षण” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Pandas & NumPy Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Pandas & NumPy Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Pandas & NumPy Academy पर वापस जाएँ