গড় নিরঙ্কুশ বিচ্যুতি এবং বড় ডেটা সেটের জন্য অনলাইন অ্যালগরিদম


16

আমার কিছুটা সমস্যা আছে যা আমাকে ফ্রিকে আউট করে তুলছে। বহুবিধ সময় সিরিজের অনলাইন অধিগ্রহণের প্রক্রিয়াটির জন্য আমাকে প্রক্রিয়া লিখতে হবে। প্রতিটি সময়ের ব্যবধানে (উদাহরণস্বরূপ 1 সেকেন্ড), আমি একটি নতুন নমুনা পাই যা মূলত আকার N এর একটি ভাসমান বিন্দু ভেক্টর I

  1. প্রতিটি নতুন নমুনার জন্য, আমি সেই নমুনার জন্য শতাংশগুলি গণনা করি (ভেক্টরকে সাধারণীকরণের মাধ্যমে যাতে উপাদানগুলির যোগফল 1 হয়)।

  2. আমি একইভাবে গড় শতাংশের ভেক্টর গণনা করি তবে অতীতের মানগুলি ব্যবহার করে।

  3. প্রতিটি অতীত মানের জন্য, আমি সেই ধাপের সাথে সম্পর্কিত নমুনা সম্পর্কিত ভেক্টরের পরম বিচ্যুতি গণনা করি ২ য় ধাপে গণনা করা বৈশ্বিক গড় শতকরা ভেক্টর এর সাথে, পরম বিচ্যুতি সর্বদা 0 এর মধ্যে একটি সংখ্যার (যখন ভেক্টর গড়ের সমান হয়) ভেক্টর) এবং 2 (যখন এটি সম্পূর্ণ আলাদা)।

  4. পূর্ববর্তী সমস্ত নমুনাগুলির জন্য বিচরণের গড় ব্যবহার করে আমি গড় নিখুঁত বিচ্যুতি গণনা করি, যা আবার 0 এবং 2 এর মধ্যে একটি সংখ্যা।

  5. নতুন নমুনা অন্যান্য নমুনার সাথে সামঞ্জস্যপূর্ণ কিনা তা সনাক্ত করতে আমি গড় নিরঙ্কুশ বিচ্যুতি ব্যবহার করি (৪ র্থ ধাপে সম্পূর্ণ সেটটির গড় নিরঙ্কুশ বিচ্যুতির সাথে এর নিরঙ্কুশ বিচ্যুতি তুলনা করে)।

যেহেতু প্রতিবারই একটি নতুন নমুনা বিশ্বব্যাপী গড় পরিবর্তনগুলি সংগ্রহ করা হয় (এবং সেই সাথে নিখুঁত বিচ্যুতিও পরিবর্তিত হয়), পুরো ডেটা একাধিকবার সেট না করে এই মানটি গণনা করার কোনও উপায় আছে কি? (গ্লোবাল গড় শতাংশের গণনা করার জন্য এক সময়, এবং পরম বিচ্যুতি সংগ্রহের জন্য এক সময়)। ঠিক আছে, আমি জানি পুরো সেটটি স্ক্যান না করে গ্লোবাল গড় গণনা করা একেবারে সহজ, যেহেতু প্রতিটি মাত্রার যোগফল সংরক্ষণ করার জন্য আমাকে কেবল একটি অস্থায়ী ভেক্টর ব্যবহার করতে হবে, তবে এর অর্থ নিরঙ্কুশ বিচ্যুতি সম্পর্কে কী? এর গণনায় abs()অপারেটর অন্তর্ভুক্ত রয়েছে , তাই আমার অতীতের সমস্ত ডেটা অ্যাক্সেস করা দরকার!

আপনার সাহায্যের জন্য ধন্যবাদ.

উত্তর:


6

আপনি যদি কিছু অসম্পূর্ণতা গ্রহণ করতে পারেন তবে এই সমস্যাটি বিন্নের গণনা দ্বারা সহজেই সমাধান করা যেতে পারে । অর্থাৎ কিছু বড় সংখ্যা বাছুন ( এম = 1000 বলুন ), তারপরে বি i , j এর জন্য i = 1 এম এবং জে = 1 এন এর জন্য কিছু পূর্ণসংখ্যার বিন্যাস আরম্ভ করুন , যেখানে এন ভেক্টরের আকার শূন্য হিসাবে রয়েছে। তারপরে আপনি যখন কোনও শতাংশের ভেক্টরের k ম পর্যবেক্ষণ দেখবেন, ইনক্রিমেন্ট B i , j যদি এই ভেক্টরের j ম উপাদানটির মধ্যে থাকে (MM=1000Bi,ji=1এমj=1এনএনBi, এবং আমি / এম ,ভেক্টরের এন উপাদানগুলিলুপিং। (আমি ধরে নিচ্ছি যে আপনার ইনপুট ভেক্টরগুলি নেতিবাচক নয়, যাতে আপনি যখন আপনার 'শতাংশগুলি' গণনা করেন তখন ভেক্টরগুলি [ 0 , 1 ] এর মধ্যে থাকে are)(আমি-1)/এমআমি/এমএন[0,1]

সময়ে যে কোনও সময়ে, আপনি বিনগুলি থেকে গড় ভেক্টর এবং গড় নিখুঁত বিচ্যুতি অনুমান করতে পারেন। জাতীয় ভেক্টর পর্যবেক্ষণ করার পরে , গড়ের j তম উপাদানটি ˉ X j = 1 দ্বারা অনুমান করা হয় Kjএবংজে জম মৌলিক নিখুঁত বিচ্যুতির উপাদানটি1দ্বারা অনুমান করা হয়

X¯j=1Kii1/2MBi,j,
j
1Ki|Xj¯i1/2M|Bi,

সম্পাদনা করুন : এটি এমন একটি আরও সাধারণ পদ্ধতির একটি নির্দিষ্ট ক্ষেত্রে যেখানে আপনি একটি অভিজ্ঞতাগত ঘনত্বের প্রাক্কলন তৈরি করছেন। এটি পলিনোমিয়ালস, স্প্লাইনস ইত্যাদির সাহায্যে করা যেতে পারে তবে বাইনিং পদ্ধতির বর্ণনা ও প্রয়োগ করা সবচেয়ে সহজ।


বাহ, সত্যিই আকর্ষণীয় পদ্ধতির। আমি এটি সম্পর্কে জানতাম না, এবং আমি এটি মনে রাখব। দুর্ভাগ্যক্রমে, এই ক্ষেত্রে এটি কার্যকর হবে না, যেহেতু মেমরির ব্যবহারের দৃষ্টিকোণ থেকে আমার সত্যিকারের প্রতিবন্ধী প্রয়োজনীয়তা রয়েছে, সুতরাং এম সত্যিই ছোট হওয়া উচিত, এবং আমার ধারণা অনেক বেশি নির্ভুলতা ক্ষতি হতে পারে।
gianluca

@ গিজিনালুকা: মনে হচ্ছে আপনার কাছে ১. প্রচুর ডেটা, ২. সীমিত মেমরি রিসোর্স, ৩. উচ্চ নির্ভুলতার প্রয়োজনীয়তা রয়েছে। আমি দেখতে পাচ্ছি কেন এই সমস্যা আপনাকে মুক্ত করছে! সম্ভবত, @ কেওয়াক দ্বারা উল্লিখিত হিসাবে, আপনি স্প্রেডের আরও কিছু পরিমাপ গণনা করতে পারেন: এমএডি, আইকিউআর, মানক বিচ্যুতি। এগুলির সকলেরই এমন পদ্ধতির রয়েছে যা আপনার সমস্যার জন্য কাজ করতে পারে।
shabbychef

জিয়ানলুকা:> আপনি যে মেমরি, অ্যারে এবং সঠিকতা চান তার আকার সম্পর্কে আরও পরিমাণগত ধারণা দিন। এটি ভাল হতে পারে যে আপনার প্রশ্নের উত্তর @ স্ট্যাকওভারফ্লো যদিও দেওয়া হবে।
ব্যবহারকারী 60

4

আমি বিলোপকে বিচ্যুতিটি মাঝারিভাবে দক্ষতার সাথে গণনা করার জন্য নিম্নলিখিত পদ্ধতিটি ব্যবহার করেছি (দ্রষ্টব্য, এটি একটি প্রোগ্রামার পদ্ধতির, কোনও পরিসংখ্যানবিদ নয়, তাই নির্দ্বিধায় শ্যাব্বিচেফের মতো চালাক কৌশল হতে পারে যা আরও কার্যকর হতে পারে)।

সতর্কতা: এটি কোনও অনলাইন অ্যালগরিদম নয়। এটির O(n)স্মৃতি দরকার । তদ্ব্যতীত, এটির O(n)মতো ডেটাসেটগুলির জন্য [1, -2, 4, -8, 16, -32, ...](যেমন সম্পূর্ণ পুনঃব্যবহারের সমান) এর ক্ষেত্রে সবচেয়ে খারাপ পরিস্থিতি রয়েছে । [1]

তবে এটি এখনও অনেক ব্যবহারের ক্ষেত্রে ভাল অভিনয় করে কারণ এটি এখানে পোস্ট করা উপযুক্ত। উদাহরণস্বরূপ, প্রতিটি আইটেমটি আসার সাথে সাথে 10000 এলোমেলো সংখ্যার পরম বিচ্যুতি গণনা করার জন্য , আমার অ্যালগরিদমটি এক সেকেন্ডেরও কম সময় নেয়, যখন পুরো পুনরুদ্ধারটি 17 সেকেন্ডেরও বেশি সময় নেয় (আমার মেশিনে, প্রতি মেশিনে পৃথক হবে এবং ইনপুট ডেটা অনুযায়ী)। আপনাকে স্মৃতিতে পুরো ভেক্টর বজায় রাখতে হবে যা কিছু ব্যবহারের ক্ষেত্রে বাধা হতে পারে। অ্যালগরিদমের রূপরেখা নিম্নরূপ:

  1. অতীত পরিমাপগুলি সঞ্চয় করতে একক ভেক্টর না রেখে তিনটি বাছাই করা অগ্রাধিকারের সারি (একটি মিনিট / সর্বোচ্চ গাদা জাতীয় কিছু) ব্যবহার করুন। এই তিনটি ইনপুটটিকে তিনটিতে বিভক্ত করে: গড়ের চেয়ে বড় আইটেম, গড়ের চেয়ে কম আইটেম এবং গড়ের সমান আইটেম।
  2. (প্রায়) আপনি যখনই কোনও আইটেম যুক্ত করেন তখন গড় পরিবর্তন হয়, তাই আমাদের পুনরায় ভাগ করা দরকার। গুরুত্বপূর্ণ বিষয়টি পার্টিশনের সাজানো প্রকৃতি যার অর্থ তালিকার প্রতিটি আইটেমকে প্রতিস্থাপনের জন্য স্ক্যান করার পরিবর্তে আমাদের কেবল সেই আইটেমগুলি পড়তে হবে যা আমরা চলছি। যদিও সবচেয়ে খারাপ ক্ষেত্রে এটি এখনও O(n)সরানো অপারেশনগুলির প্রয়োজন হবে, অনেকগুলি ব্যবহারের ক্ষেত্রে এটি এমন হয় না।
  3. কিছু চালাক বুককিপিং ব্যবহার করে, আমরা নিশ্চিত করতে পারি যে বিবর্তন এবং নতুন আইটেম যুক্ত করার সময়, ডিভেনশন সর্বদা সঠিকভাবে গণনা করা হয়।

পাইথনের কয়েকটি নমুনা কোড নীচে রয়েছে। নোট করুন যে এটি কেবল আইটেমগুলিকে তালিকায় যুক্ত করার অনুমতি দেয়, সরানো হয়নি not এটি সহজেই যুক্ত করা যেতে পারে তবে আমি এটি লেখার সময় আমার এটির কোনও প্রয়োজন ছিল না। নিজেরাই অগ্রাধিকারের সারিগুলি প্রয়োগ করার পরিবর্তে, আমি ড্যানিয়েল স্টুটজবাচের দুর্দান্ত ব্লিস্ট প্যাকেজ থেকে সোর্টলিস্ট ব্যবহার করেছি, যা অভ্যন্তরীণভাবে বি + ট্রি ব্যবহার করে ।

এমআইটি লাইসেন্সের আওতায় লাইসেন্স প্রাপ্ত এই কোডটি বিবেচনা করুন । এটি উল্লেখযোগ্যভাবে অনুকূলিত বা পালিশ করা যায় নি, তবে অতীতে আমার পক্ষে কাজ করেছে। নতুন সংস্করণ এখানে উপলব্ধ হবে । আপনার যদি কোনও প্রশ্ন থাকে বা কোনও বাগ খুঁজে পান তবে আমাকে জানান।

from blist import sortedlist
import operator

class deviance_list:
    def __init__(self):
        self.mean =  0.0
        self._old_mean = 0.0
        self._sum =  0L
        self._n =  0  #n items
        # items greater than the mean
        self._toplist =  sortedlist()
        # items less than the mean
        self._bottomlist = sortedlist(key = operator.neg)
        # Since all items in the "eq list" have the same value (self.mean) we don't need
        # to maintain an eq list, only a count
        self._eqlistlen = 0

        self._top_deviance =  0
        self._bottom_deviance =  0

    @property
    def absolute_deviance(self):
        return self._top_deviance + self._bottom_deviance

    def append(self,  n):
        # Update summary stats
        self._sum += n
        self._n +=  1
        self._old_mean =  self.mean
        self.mean =  self._sum /  float(self._n)

        # Move existing things around
        going_up = self.mean > self._old_mean
        self._rebalance(going_up)

        # Add new item to appropriate list
        if n >  self.mean:
            self._toplist.add(n)
            self._top_deviance +=  n -  self.mean
        elif n == self.mean: 
            self._eqlistlen += 1
        else:
            self._bottomlist.add(n)
            self._bottom_deviance += self.mean -  n


    def _move_eqs(self,  going_up):
        if going_up:
            self._bottomlist.update([self._old_mean] *  self._eqlistlen)
            self._bottom_deviance += (self.mean - self._old_mean) * self._eqlistlen
            self._eqlistlen = 0
        else:
            self._toplist.update([self._old_mean] *  self._eqlistlen)
            self._top_deviance += (self._old_mean - self.mean) * self._eqlistlen
            self._eqlistlen = 0


    def _rebalance(self, going_up):
        move_count,  eq_move_count = 0, 0
        if going_up:
            # increase the bottom deviance of the items already in the bottomlist
            if self.mean !=  self._old_mean:
                self._bottom_deviance += len(self._bottomlist) *  (self.mean -  self._old_mean)
                self._move_eqs(going_up)


            # transfer items from top to bottom (or eq) list, and change the deviances
            for n in iter(self._toplist):
                if n < self.mean:
                    self._top_deviance -= n -  self._old_mean
                    self._bottom_deviance += (self.mean -  n)
                    # we increment movecount and move them after the list
                    # has finished iterating so we don't modify the list during iteration
                    move_count +=  1
                elif n == self.mean:
                    self._top_deviance -= n -  self._old_mean
                    self._eqlistlen += 1
                    eq_move_count +=  1
                else:
                    break
            for _ in xrange(0,  move_count):
                self._bottomlist.add(self._toplist.pop(0))
            for _ in xrange(0,  eq_move_count):
                self._toplist.pop(0)

            # decrease the top deviance of the items remain in the toplist
            self._top_deviance -= len(self._toplist) *  (self.mean -  self._old_mean)
        else:
            if self.mean !=  self._old_mean:
                self._top_deviance += len(self._toplist) *  (self._old_mean -  self.mean)
                self._move_eqs(going_up)
            for n in iter(self._bottomlist): 
                if n > self.mean:
                    self._bottom_deviance -= self._old_mean -  n
                    self._top_deviance += n -  self.mean
                    move_count += 1
                elif n == self.mean:
                    self._bottom_deviance -= self._old_mean -  n
                    self._eqlistlen += 1
                    eq_move_count +=  1
                else:
                    break
            for _ in xrange(0,  move_count):
                    self._toplist.add(self._bottomlist.pop(0))
            for _ in xrange(0,  eq_move_count):
                self._bottomlist.pop(0)

            # decrease the bottom deviance of the items remain in the bottomlist
            self._bottom_deviance -= len(self._bottomlist) *  (self._old_mean -  self.mean)


if __name__ ==  "__main__":
    import random
    dv =  deviance_list()
    # Test against some random data,  and calculate result manually (nb. slowly) to ensure correctness
    rands = [random.randint(-100,  100) for _ in range(0,  1000)]
    ns = []
    for n in rands: 
        dv.append(n)
        ns.append(n)
        print("added:%4d,  mean:%3.2f,  oldmean:%3.2f,  mean ad:%3.2f" %
              (n, dv.mean,  dv._old_mean,  dv.absolute_deviance / dv.mean))
        assert sum(ns) == dv._sum,  "Sums not equal!"
        assert len(ns) == dv._n,  "Counts not equal!"
        m = sum(ns) / float(len(ns))
        assert m == dv.mean,  "Means not equal!"
        real_abs_dev = sum([abs(m - x) for x in ns])
        # Due to floating point imprecision, we check if the difference between the
        # two ways of calculating the asb. dev. is small rather than checking equality
        assert abs(real_abs_dev - dv.absolute_deviance) < 0.01, (
            "Absolute deviances not equal. Real:%.2f,  calc:%.2f" %  (real_abs_dev,  dv.absolute_deviance))

[1] লক্ষণগুলি অব্যাহত থাকলে আপনার ডাক্তারের সাথে দেখা করুন।


2
আমি কিছু মিস করছি: আপনার যদি "স্মৃতিতে পুরো ভেক্টর বজায় রাখতে হয়," এটি "অনলাইন" অ্যালগরিদম হিসাবে কীভাবে যোগ্যতা অর্জন করবে ??
whuber

@ শুভর না, কিছু অনুপস্থিত, আমার ধারণা এটি কোনও অনলাইন অ্যালগরিদম নয়। এটির জন্য O(n)মেমরি দরকার এবং সবচেয়ে খারাপ ক্ষেত্রে যুক্ত প্রতিটি আইটেমের জন্য ও (এন) সময় লাগে। সাধারণত বিতরণ করা ডেটা (এবং সম্ভবত অন্যান্য বিতরণ) এ এটি বেশ দক্ষতার সাথে কাজ করে।
fmark

3

XXXss2/π )।


এটি একটি আকর্ষণীয় ধারণা। আপনি এটিকে পরিপূরক করতে পারেন, সম্ভবত, বাইরের লোকদের অনলাইনে সনাক্তকরণের সাথে এবং এগুলি ব্যবহারের সাথে অনুমানটি পরিবর্তন করার সাথে সাথে যেতে পারেন।
whuber

আমি আমার দ্বিতীয় উত্তরে নথিবদ্ধ যে অনলাইন স্ট্যান্ডার্ড বিচ্যুতি গণনা করার জন্য আপনি সম্ভবত ওয়েলফোর্ডের পদ্ধতি ব্যবহার করতে পারেন।
fmark

1
তবে একটিটিকে অবশ্যই লক্ষ করা উচিত যে এইভাবে স্পষ্টত এমএডি হিসাবে অনুমানকারীদের দৃ rob়তা হারাতে পারে, যা কখনও কখনও সহজ বিকল্পগুলির বিরুদ্ধে তার পছন্দটিতে চালিত হয়।
কোয়ার্টজ

2

এমএডি (এক্স) হ'ল মাত্র দুটি সমান্তরাল মিডিয়ান গণনা, যার প্রত্যেকটি অনলাইন বাইনমেডিয়ান অ্যালগরিদমের মাধ্যমে তৈরি করা যায় ।

আপনি অনলাইনে এখানে সম্পর্কিত কাগজ পাশাপাশি সি এবং ফরটারান কোডটি সন্ধান করতে পারেন ।

(স্মৃতি রক্ষার জন্য এটি কেবল শব্বিচেফের চতুর কৌশলটির উপরে একটি চালাক কৌশল ব্যবহার করা)।

সংযোজন:

কোয়ান্টাইল গণনা করার জন্য বহু পুরানো বহু পাসের পদ্ধতি রয়েছে। একটি জনপ্রিয় পদ্ধতি হ'ল প্রবাহ থেকে এলোমেলোভাবে নির্বাচিত পর্যবেক্ষণগুলির একটি নির্ধারিত আকারের জলাধার বজায় রাখা / আপডেট করা এবং এই জলাধারটিতে পুনরাবৃত্তভাবে কোয়ান্টাইলগুলি গণনা করুন ( এই পর্যালোচনাটি দেখুন)। এই (এবং সম্পর্কিত) পদ্ধতির উপরোক্ত প্রস্তাবিত প্রস্তাবটিকে ছাড়িয়ে যায়।


আপনি দয়া করে এমএডি এবং দুই মিডিয়ানের মধ্যকার সম্পর্কটি বিস্তারিতভাবে উল্লেখ করতে পারেন বা উল্লেখ করতে পারেন?
কোয়ার্টজ

মেডআমি=1এন|এক্সআমি-মেডআমি=1এন|

হেইম, আমি আসলে বোঝাতে চাইছি যদি আপনি ব্যাখ্যা করতে পারেন যে এই সম্পর্কটি কীভাবে দুই মধ্যস্থদের একযোগে থাকতে দেয়; এগুলি আমার উপর নির্ভরশীল বলে মনে হয়, যেহেতু বাইরের মধ্যকের ইনপুটগুলি সমস্ত অভ্যন্তরের গণনায় প্রতিটি যুক্ত নমুনায় পরিবর্তিত হতে পারে। কীভাবে আপনি এগুলি সমান্তরালভাবে সম্পাদন করবেন?
কোয়ার্টজ

আমাকে বিশদ বিবরণের জন্য বিনমিডিয়ান পেপারে ফিরে যেতে হবে ... তবে মিডিয়ানের একটি গুণিত মান দেওয়া হয়েছে (মিআমি=1এনএক্সআমি) এবং এর একটি নতুন মান এক্সএন+ +1 অ্যালগরিদম গণনা করতে পারে মিআমি=1এন+ +1এক্সআমি তুলনায় অনেক দ্রুত হে(এন) বিন যা সনাক্ত করে এক্সএন+ +1জন্যে। আমি দেখতে পাচ্ছি না যে এই অন্তর্দৃষ্টিটি কীভাবে উন্মাদ গুনে বাইরের মধ্যস্থকে সাধারণীকরণ করা যায়নি।
ব্যবহারকারী 60

1

নিম্নলিখিতটি একটি নির্ভুল আনুমানিকতা সরবরাহ করে, যদিও ত্রুটিটি ইনপুট ডেটার বিতরণের উপর নির্ভর করবে। এটি একটি অনলাইন অ্যালগরিদম, তবে কেবল পরম বিচ্যুতিটির প্রায় কাছাকাছি। এটি অনলাইনে বৈকল্পিক গণনা করার জন্য একটি সুপরিচিত অ্যালগরিদমের উপর ভিত্তি করে , যা 1960 এর দশকে ওয়েলফোর্ডের দ্বারা বর্ণিত । তাঁর অ্যালগরিদমটি আর-তে অনুবাদ হয়েছে, দেখে মনে হচ্ছে:

M2 <- 0
mean <- 0
n <- 0

var.online <- function(x){
    n <<- n + 1
    diff <- x - mean
    mean <<- mean + diff / n
    M2 <<- M2 + diff * (x - mean)
    variance <- M2 / (n - 1)
    return(variance)
}

এটি আর এর বিল্টিন ভেরিয়েন্স ফাংশনের সাথে খুব অনুরূপভাবে সম্পাদন করে:

set.seed(2099)
n.testitems <- 1000
n.tests <- 100
differences <- rep(NA, n.tests)
for (i in 1:n.tests){
        # Reset counters
        M2 <- 0
        mean <- 0
        n <- 0

        xs <- rnorm(n.testitems)
        for (j in 1:n.testitems){
                v <- var.online(xs[j])
        }

        differences[i] <- abs(v - var(xs))

}
summary(differences)
     Min.   1st Qu.    Median      Mean   3rd Qu.      Max. 
0.000e+00 2.220e-16 4.996e-16 6.595e-16 9.992e-16 1.887e-15 

নিরঙ্কুশ বিচ্যুতি গণনা করতে অ্যালগরিদম পরিবর্তন করে কেবল একটি অতিরিক্ত sqrtকল জড়িত । যাইহোক, sqrtফলাফলগুলিতে প্রতিফলিত হওয়া অপ্রতুলতার পরিচয় দেয়:

absolute.deviance.online <- function(x){
    n <<- n + 1
    diff <- x - mean
    mean <<- mean + diff / n
    a.dev <<- a.dev + sqrt(diff * (x - mean))
    return(a.dev)
}

উপরের হিসাবে গণনা করা ত্রুটিগুলি, বৈকল্পিক গণনার চেয়ে অনেক বেশি বড়:

    Min.  1st Qu.   Median     Mean  3rd Qu.     Max. 
0.005126 0.364600 0.808000 0.958800 1.360000 3.312000 

তবে আপনার ব্যবহারের ক্ষেত্রে নির্ভর করে ত্রুটির এই পরিমাণটি গ্রহণযোগ্য হতে পারে।

পার্থক্যের হিস্টোগ্রাম


এটি নিম্নলিখিত কারণে সঠিক উত্তর দেয় না: Σআমিএক্সআমিΣআমিএক্সআমি। আপনি প্রাক্তনটি গণনা করছেন, অপরটি পরে চান wants
shabbychef

আমি একমত যে পদ্ধতিটি সঠিক নয়। যাইহোক, আপনার অক্ষমতা নির্ণয়ের সাথে আমি একমত নই। বৈকল্পিক গণনা করার জন্য ওয়েলফোর্ডের পদ্ধতিতে, যেখানে স্কয়ার্টও থাকে না, তেমন ত্রুটি রয়েছে। তবে, nবড় হওয়ার সাথে সাথে error/nআশ্চর্যজনকভাবে দ্রুত এলোমেলোভাবে ছোট হয়ে যায়।
fmark

ওয়েলফোর্ডের পদ্ধতিতে কোনও স্কয়ার্ট নেই কারণ এটি বৈকল্পিক গণনা করছে, মানক বিচ্যুতি নয়। স্কয়ারটি গ্রহণ করে দেখে মনে হচ্ছে আপনি স্ট্যান্ডার্ড বিচ্যুতিটি অনুমান করছেন, গড় নিরঙ্কুশ বিচ্যুতি নয়। আমি কিছু অনুপস্থিত করছি?
shabbychef

@ শ্যাববিচেফ ভেলফোর্ডস-এর প্রতিটি পুনরাবৃত্তি নিখুঁত বিচ্যুতি, স্কোয়ারে নতুন ডেটাপয়েন্টের অবদান গণনা করছে। সুতরাং আমি প্রতিটি অবদানের বর্গমূল নিখুঁত বিচ্যুতিতে ফিরে পেতে স্কোয়ার করি। আপনি লক্ষ করতে পারেন, উদাহরণস্বরূপ, মানক বিচ্যুতির ক্ষেত্রে পরে না গিয়ে ডিভ্যান্স যোগে যোগ করার আগে আমি ব-দ্বীপের বর্গমূল গ্রহণ করি।
fmark

3
আমি সমস্যাটি দেখতে পাচ্ছি; ভেলফোর্ডস এই পদ্ধতির সাহায্যে সমস্যাটিকে অস্পষ্ট করে তোলে: গড়ের চূড়ান্ত প্রাক্কলনের পরিবর্তে গড়টির অনলাইন অনুমান ব্যবহৃত হয়। যদিও ভ্যালিফোর্ডের পদ্ধতিটি বৈকল্পিকতার জন্য সঠিক (রাউন্ডঅফ অবধি), এই পদ্ধতিটি নয়। সমস্যা না কারণে sqrtঅনির্দিষ্টতা। কারণ এটি চলমান গড় অনুমানটি ব্যবহার করে। এটি কখন ভেঙে দেবে তা দেখার জন্য, xs <- sort(rnorm(n.testitems)) যখন আমি আপনার কোডটি দিয়ে চেষ্টা করব (ফিরে আসার জন্য এটি ঠিক করার পরে a.dev / n), আমি 9% -16% এর ক্রমযুক্ত আপেক্ষিক ত্রুটি পেয়েছি। সুতরাং এই পদ্ধতিটি আক্রমণের অনুমতি ছাড়াই নয়, যা বিপর্যয়ের কারণ হতে পারে ...
shabbychef
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.