एक विशाल रीड-एक बार डेटा सेट के मध्य का अनुमान लगाने के लिए एक अच्छा एल्गोरिथ्म क्या है?

Question

मैं एक अच्छे एल्गोरिथ्म (न्यूनतम संगणना, न्यूनतम भंडारण आवश्यकताओं का अर्थ) की तलाश कर रहा हूं ताकि किसी डेटा सेट के मध्य का अनुमान लगाया जा सके, जो स्टोर करने के लिए बहुत बड़ा है, जैसे कि प्रत्येक मूल्य को केवल एक बार पढ़ा जा सकता है (जब तक कि आप स्पष्ट रूप से उस मूल्य को संग्रहीत नहीं करते हैं)। माना जा सकता है कि डेटा पर कोई सीमा नहीं है।

अनुमान ठीक हैं, जब तक सटीकता ज्ञात है।

कोई संकेत?

Comments

शायद, Stackoverflow पर पूछने से बेहतर जवाब मिल सकता है।

@ श्रीकांत:> यह आँकड़ों में अनुसंधान का एक बहुत ही सक्रिय क्षेत्र है :) भंडारण के मामले में निचले सैद्धांतिक सीमाओं के निकटतम समाधान में कुछ बहुत ही चालाक संभावना निर्माण शामिल हैं। जब मैंने पहली बार इसे एक-दो महीने पहले देखा था तो सभी आश्चर्यचकित थे; आंख से मिलने की तुलना में यहां अधिक आँकड़े हैं।

— 14:60 पर user603

Answer 1

क्या आप डेटा सेट को बहुत छोटे डेटा सेट (100 या 1000 या 10,000 डेटा पॉइंट कह सकते हैं) में समूहीकृत कर सकते हैं। यदि आप तब प्रत्येक समूह के माध्यिका की गणना करते हैं। यदि आपने पर्याप्त डेटा सेटों के साथ ऐसा किया है, तो आप प्रत्येक छोटे सेटों के परिणामों के औसत की तरह कुछ प्लॉट कर सकते हैं और पर्याप्त छोटे डेटा सेटों को चलाकर इस woul को 'औसत' समाधान में परिवर्तित किया जा सकता है।

Comments

यह दिलचस्प है, और जहां कुछ सांख्यिकीय सलाह अंदर आ सकती हैं! मान लें कि मुझे 500,000 आईआईडी अंक मिले हैं (मैं कहता हूं) उनमें से 1,000 (और) के समूहों को देखता हूं, और प्रत्येक समूह के मध्य की गणना करता हूं। अब मुझे 500 पदक मिल गए हैं। क्या कोई सिद्धांत है जो मुझे इन 500 मध्यस्थों के आधार पर समग्र मंझले के लिए एक विश्वास अंतराल की गणना करने की अनुमति दे सकता है?

— पीटर जूल

इसलिए, एक लंबे समय से खोए हुए सहयोगी के अनुसार, सबसे अच्छा एप्रोपोच चिरंजीब बुरगोहाइन और सुभाष सूरी को लगता है। धाराओं पर मात्राएँ। cs.ucsb.edu/~suri/psdir/ency.pdf मैं भी इयान के दृष्टिकोण को पसंद करता हूं, क्योंकि छोटे डेटा सेट के ये मध्यस्थ सामान्य वितरण में परिवर्तित होंगे, और इसलिए मैं मध्यस्थों के लिए अंतर अंतराल बना सकता हूं।

— पीटर

Answer 2

कैसे एक binning प्रक्रिया की तरह कुछ के बारे में? मान लें कि (उदाहरण के लिए) आप जानते हैं कि मान 1 और 1 मिलियन के बीच हैं। N बिन सेट करें, आकार S का। इसलिए यदि S = 10000, तो आपके पास मानों के अनुरूप 100 डिब्बे होंगे [1: 10000, 10001: 20000, ..., 990001: 1000000]

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

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

संपादित करें:

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

Comments

बिनिंग दृष्टिकोण के साथ समस्या यह है कि हमारे पास डेटा के लिए एक अच्छा ऊपरी सीमा नहीं है, और इसलिए सबसे बड़े बिन के लिए मध्य बिंदु बहुत बड़ा होना चाहिए। इसलिए, हमें बड़ी संख्या में डिब्बे (उस के लिए पर्याप्त मेमोरी नहीं) की आवश्यकता होगी, या बहुत विस्तृत डिब्बे होंगे (जो तब काफी गलत जवाब देगा।) और डेटा बहुत विरल नहीं है।

— पीटर 13

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

— रसेलपीयरस

drknexus - क्योंकि हम नहीं जानते कि सबसे बड़ा बिन क्या होना चाहिए।

— पीटरआर

क्या आपके पास कोई अंतर्ज्ञान है कि सीमा क्या होगी? यदि आपको पूरा यकीन है कि आधे से अधिक उत्तर नंबर N से नीचे होंगे, तो आप अपने अंतिम बिन को जितना चाहें उतना बड़ा बना सकते हैं। हो सकता है कि आपका अंतिम बिन सभी संख्या 1 ट्रिलियन से अधिक हो - क्या यह पर्याप्त उच्च होगा? आधुनिक प्रणालियों में स्मृति की मात्रा के साथ आप बहुत सारे स्टोर कर सकते हैं और काफी उच्च रिज़ॉल्यूशन प्राप्त कर सकते हैं। डेटा संरचनाओं के संदर्भ में, हम यहां कुछ भी फैंसी और मेमोरी इंटेंसिव नहीं बोल रहे हैं।

— क्रिसमिलर

कोई अंतर्ज्ञान? हाँ। और आपका दृष्टिकोण सामान्य रूप से काम कर सकता है। हालाँकि, इस मामले में हमारे पास बहुत सारी मेमोरी / संगणना नहीं हो सकती है। यह एक नेटवर्किंग एप्लिकेशन में है जहां डिवाइस प्रति सेकंड हजारों आइटम देख सकता है, और इस उद्देश्य के लिए बहुत कम प्रसंस्करण बचा है। आदर्श / विशिष्ट परिदृश्य नहीं, मुझे पता है, लेकिन यह वही है जो इसे दिलचस्प बनाता है!

— पीटर जूल

Answer 3

मैं आपको एक ऐसे ही सवाल के जवाब के लिए फिर से निर्देशित करता हूं । संक्षेप में, यह एक बार पढ़ा है, 'फ्लाई ऑन' एल्गोरिथ्म सबसे खराब स्थिति जटिलता है जो (सटीक) माध्य की गणना करता है।$O(n)$

Answer 4

रिवेस्ट-Tarjan-चयन एल्गोरिथ्म (कभी कभी भी कहा जाता है मंझला के- माध्यिकाओं एल्गोरिथ्म) यदि आप किसी भी छंटाई के बिना रैखिक समय में मंझला तत्व की गणना करने देगा। बड़े डेटा सेट के लिए यह लॉग-लीनियर सॉर्टिंग की तुलना में काफी तेज हो सकता है। हालाँकि, यह आपकी मेमोरी स्टोरेज समस्या को हल नहीं करेगा।

Answer 5

मैंने एक स्वच्छ पायथन मॉड्यूल में स्टोरिंग अवलोकनों के बिना क्वांटाइल्स और हिस्टोग्राम की गतिशील गणना के लिए पी-स्क्वायर एल्गोरिदम लागू किया, जिसे मैंने लाइवस्टैट्स कहा था । यह आपकी समस्या को काफी प्रभावी ढंग से हल करना चाहिए।

Comments

(+1) उस लिंक को रोकने और प्रदान करने के लिए धन्यवाद, शॉन!

— whuber

Answer 6

मुझे ऐसा कभी नहीं करना पड़ा, इसलिए यह सिर्फ एक सुझाव है।

मैं दो (अन्य) संभावनाएं देखता हूं।

आधा डेटा

1. आधे डेटा में लोड करें और सॉर्ट करें
2. शेष मूल्यों में अगला पढ़ें और अपनी सॉर्ट की गई सूची के खिलाफ तुलना करें।
   1. यदि नया मान बड़ा है, तो उसे छोड़ दें।
   2. और मान को क्रमबद्ध सूची में रखा और उस सूची से सबसे बड़ा मूल्य निकाल दिया।

नमूने का वितरण

अन्य विकल्प, नमूना वितरण से जुड़े एक सन्निकटन का उपयोग करना है। यदि आपका डेटा सामान्य है, तो मध्यम n के लिए मानक त्रुटि है:

1.253 * sd / sqrt (n)

N के आकार को निर्धारित करने के लिए जिससे आप खुश होंगे, मैंने R में एक त्वरित मोंटे-कार्लो सिमुलेशन चलाया

n = 10000
outside.ci.uni = 0
outside.ci.nor = 0
N=1000
for(i in 1:N){
  #Theoretical median is 0
  uni = runif(n, -10, 10)
  nor  = rnorm(n, 0, 10)

  if(abs(median(uni)) > 1.96*1.253*sd(uni)/sqrt(n))
    outside.ci.uni = outside.ci.uni + 1

  if(abs(median(nor)) > 1.96*1.253*sd(nor)/sqrt(n))
    outside.ci.nor = outside.ci.nor + 1
}

outside.ci.uni/N
outside.ci.nor/N

N = 10000 के लिए, समान औसत अनुमान का 15% CI के बाहर था।

Comments

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

— पीटर आरआर

Answer 7

आप समूहीकृत आवृत्ति वितरण के आधार पर एक माध्यिका खोजने की कोशिश कर सकते हैं, यहां कुछ विवरण हैं

Answer 8

स्टैकओवरफ़्लो पर पूछे गए प्रश्न का उत्तर यहां दिया गया है: https://stackoverflow.com/questions/1058813/on-line-iterator-algorithms-for-estimating-statutic-median-mode-skewness-2144754#2144754

पुनरावृति अद्यतन माध्यिका + = एटा * sgn (नमूना - माध्यिका) लगता है कि यह एक रास्ता हो सकता है।

Comments

लेकिन फिर एटा का चयन कैसे करें, और क्या स्टिस का मतलब सांख्यिकीय रूप से है? इस परिणाम से मंझले के लिए आत्मविश्वास अंतराल कैसे बनाएं?

— पीटर जूल

@PeterR, हे, क्या अंतिम समाधान आप इस्तेमाल किया है?

— आकाश गोयल

Answer 9

Remedian एल्गोरिथ्म (पीडीएफ) कम भंडारण आवश्यकताओं और अच्छी तरह से परिभाषित सटीकता के साथ एक एक से पारित मंझला अनुमान देता है।

बेस बी के साथ रिमेडियन, बी टिप्पणियों के समूहों के मध्यस्थों की गणना करके आगे बढ़ता है, और तब तक इन मध्यस्थों का ध्यान रखता है, जब तक कि केवल एक अनुमान नहीं रहता है। इस विधि को केवल आकार b (जहाँ n = b ^ k) के k सरणियों की आवश्यकता है ...

Answer 10

यदि आपके द्वारा उपयोग किए जा रहे मान एक निश्चित सीमा के भीतर हैं, तो 1 से 100000 कहें, आप पूर्णांक के साथ एक बड़ी संख्या में मानों (जैसे प्रविष्टियों के खरबों) पर माध्यिका की कुशलता से गणना कर सकते हैं (यह कोड BSD ea से लिया गया है) -utils / सैम stats.cpp)

class ibucket {
public:
    int tot;
    vector<int> dat;
    ibucket(int max) {dat.resize(max+1);tot=0;}
    int size() const {return tot;};

    int operator[] (int n) const {
        assert(n < size());
        int i;
        for (i=0;i<dat.size();++i) {
            if (n < dat[i]) {
                return i;
            }
            n-=dat[i];
        }
    }

    void push(int v) {
        assert(v<dat.size());
        ++dat[v];
        ++tot;
    }
};


template <class vtype>
double quantile(const vtype &vec, double p) {
        int l = vec.size();
        if (!l) return 0;
        double t = ((double)l-1)*p;
        int it = (int) t;
        int v=vec[it];
        if (t > (double)it) {
                return (v + (t-it) * (vec[it+1] - v));
        } else {
                return v;
        }
}

Comments

इसके अलावा, यह वास्तविक समय के मध्यस्थों, आदि के लिए सीमित संख्या में डिब्बे का उपयोग करने के लिए बढ़ाया जा सकता है

— एरिक एरोनिटी