কিভাবে চলমান মান বিচ্যুতি দক্ষতার সাথে গণনা করতে?

Question 1

আমার কাছে সংখ্যার তালিকার একটি অ্যারে রয়েছে, যেমন:

[0] (0.01, 0.01, 0.02, 0.04, 0.03)
[1] (0.00, 0.02, 0.02, 0.03, 0.02)
[2] (0.01, 0.02, 0.02, 0.03, 0.02)
     ...
[n] (0.01, 0.00, 0.01, 0.05, 0.03)

আমি যা করতে চাই তা হ'ল সমস্ত অ্যারে উপাদান জুড়ে একটি তালিকার প্রতিটি সূচীতে দক্ষতার গড় এবং স্ট্যান্ডার্ড বিচ্যুতি গণনা করা।

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

স্ট্যান্ডার্ড বিচ্যুতিটি করতে, আমি আবার লুপ করব, এখন আমার কাছে গড় গণনা করা হয়েছে।

আমি দু'বার অ্যারে দিয়ে যাওয়া এড়াতে চাই, একবার গড়ের জন্য এবং তারপরে একবার এসডির জন্য (আমার কোনও অর্থ হওয়ার পরে)।

উভয় মান গণনা করার জন্য কি কেবল একবার অ্যারে দিয়ে যাওয়া জন্য কার্যকর পদ্ধতি আছে? বর্ণিত ভাষায় যে কোনও কোড (যেমন পার্ল বা পাইথন) বা সিউডোকোড ভাল।

Question 2

উত্তরটি হল ওয়েলফোর্ডের অ্যালগরিদম ব্যবহার করা যা "স্পষ্ট পদ্ধতি" এর পরে খুব স্পষ্টভাবে সংজ্ঞায়িত:

উইকিপিডিয়া: বৈকল্পিক গণনা করার জন্য অ্যালগরিদম

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

আপনি ভেরিয়েন্স গণনা (স্কোয়ার বিচ্যুতি) এর নমুনাগুলির সংখ্যা (এন) এবং এন -1 দ্বারা ভাগ করার পার্থক্যটিও সন্ধান করতে পারেন। এন -১ দ্বারা ভাগ করা নমুনা থেকে বৈকল্পিকতার একটি নিরপেক্ষ অনুমানের দিকে পরিচালিত করে, যেখানে এন দ্বারা বিভাজনকে গড় মূল্যকে কম মূল্য দেয় (কারণ এটি নমুনার গড় এবং প্রকৃত অর্থের মধ্যে বৈকল্পিকতা বিবেচনা করে না)।

আমি এই বিষয়টিতে দুটি ব্লগ এন্ট্রি লিখেছি যা কীভাবে অনলাইনে পূর্ববর্তী মানগুলি মুছতে হবে তা সহ আরও বিশদে চলে যায়:

আপনি আমার জাভা বাস্তবায়নও একবার দেখে নিতে পারেন; জাভাডোক, উত্স এবং ইউনিট পরীক্ষা সবই অনলাইনে রয়েছে:

Question 3

মূল উত্তরটি হ'ল এক্স এর উভয়ই যোগফল সংগ্রহ করুন (একে 'Sum_x1' বলুন) এবং এক্স ² (একে 'Sum_x2' বলুন) আপনি যাওয়ার সময়। স্ট্যান্ডার্ড বিচ্যুতির মানটি তখন:

stdev = sqrt((sum_x2 / n) - (mean * mean))

কোথায়

mean = sum_x / n

এটি নমুনা স্ট্যান্ডার্ড বিচ্যুতি; আপনি বিভাজক হিসাবে 'n - 1' এর পরিবর্তে 'n' ব্যবহার করে জনসংখ্যার মানক বিচ্যুতি পান।

আপনি যদি বড় আকারের নমুনাগুলি নিয়ে কাজ করে থাকেন তবে দুটি বৃহত সংখ্যার মধ্যে পার্থক্য নেওয়ার সংখ্যার স্থায়িত্ব সম্পর্কে আপনাকে চিন্তার প্রয়োজন হতে পারে। আরও তথ্যের জন্য অন্যান্য উত্তরে (উইকিপিডিয়া ইত্যাদি) বাহ্যিক রেফারেন্সে যান।

Question 4

এখানে http://www.johndcook.com / স্ট্যান্ডার্ড_ডিয়েশন এইচটিএমএল থেকে ওয়েলফোর্ডের অ্যালগরিদম বাস্তবায়নের একটি আক্ষরিক খাঁটি পাইথন অনুবাদ রয়েছে :

https://github.com/liyanage/python-modules/blob/master/running_stats.py

import math

class RunningStats:

    def __init__(self):
        self.n = 0
        self.old_m = 0
        self.new_m = 0
        self.old_s = 0
        self.new_s = 0

    def clear(self):
        self.n = 0

    def push(self, x):
        self.n += 1

        if self.n == 1:
            self.old_m = self.new_m = x
            self.old_s = 0
        else:
            self.new_m = self.old_m + (x - self.old_m) / self.n
            self.new_s = self.old_s + (x - self.old_m) * (x - self.new_m)

            self.old_m = self.new_m
            self.old_s = self.new_s

    def mean(self):
        return self.new_m if self.n else 0.0

    def variance(self):
        return self.new_s / (self.n - 1) if self.n > 1 else 0.0

    def standard_deviation(self):
        return math.sqrt(self.variance())

ব্যবহার:

rs = RunningStats()
rs.push(17.0)
rs.push(19.0)
rs.push(24.0)

mean = rs.mean()
variance = rs.variance()
stdev = rs.standard_deviation()

print(f'Mean: {mean}, Variance: {variance}, Std. Dev.: {stdev}')

Question 5

সম্ভবত আপনি যা জিজ্ঞাসা করেছিলেন তা নয়, তবে ... আপনি যদি একটি নম্র অ্যারে ব্যবহার করেন তবে এটি দক্ষতার সাথে আপনার জন্য কাজটি করবে:

from numpy import array

nums = array(((0.01, 0.01, 0.02, 0.04, 0.03),
              (0.00, 0.02, 0.02, 0.03, 0.02),
              (0.01, 0.02, 0.02, 0.03, 0.02),
              (0.01, 0.00, 0.01, 0.05, 0.03)))

print nums.std(axis=1)
# [ 0.0116619   0.00979796  0.00632456  0.01788854]

print nums.mean(axis=1)
# [ 0.022  0.018  0.02   0.02 ]

যাইহোক, এই ব্লগ পোস্টে কিছু আকর্ষণীয় আলোচনা আছে এবং কম্পিউটিংয়ের মাধ্যম এবং বৈচিত্রগুলির জন্য এক-পাস পদ্ধতিতে মন্তব্য রয়েছে:

http://lingpipe-blog.com/2009/03/19/computing-sample-mean-variance-online-one-pass/

Question 6

পাইথন runstats মডিউল জিনিস শুধু এই সাজানোর জন্য। পিপিআই থেকে রানস্ট্যাটগুলি ইনস্টল করুন :

pip install runstats

রানস্ট্যাটস সংক্ষিপ্তসারগুলি ডেটা একক পাসে গড়, বৈকল্পিক, মান বিচ্যুতি, স্কিউনেস এবং কুর্তোসিস তৈরি করতে পারে। আমরা আপনার "চলমান" সংস্করণ তৈরি করতে এটি ব্যবহার করতে পারি।

from runstats import Statistics

stats = [Statistics() for num in range(len(data[0]))]

for row in data:

    for index, val in enumerate(row):
        stats[index].push(val)

    for index, stat in enumerate(stats):
        print 'Index', index, 'mean:', stat.mean()
        print 'Index', index, 'standard deviation:', stat.stddev()

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

দাবি অস্বীকার : আমি পাইথন রানস্ট্যাটস মডিউলটির লেখক।

Question 7

পরিসংখ্যান :: এই ধরণের গণনার জন্য বর্ণনামূলক একটি খুব শালীন পার্ল মডিউল:

#!/usr/bin/perl

use strict; use warnings;

use Statistics::Descriptive qw( :all );

my $data = [
    [ 0.01, 0.01, 0.02, 0.04, 0.03 ],
    [ 0.00, 0.02, 0.02, 0.03, 0.02 ],
    [ 0.01, 0.02, 0.02, 0.03, 0.02 ],
    [ 0.01, 0.00, 0.01, 0.05, 0.03 ],
];

my $stat = Statistics::Descriptive::Full->new;
# You also have the option of using sparse data structures

for my $ref ( @$data ) {
    $stat->add_data( @$ref );
    printf "Running mean: %f\n", $stat->mean;
    printf "Running stdev: %f\n", $stat->standard_deviation;
}
__END__

আউটপুট:

C:\Temp> g
Running mean: 0.022000
Running stdev: 0.013038
Running mean: 0.020000
Running stdev: 0.011547
Running mean: 0.020000
Running stdev: 0.010000
Running mean: 0.020000
Running stdev: 0.012566

Question 8

কটাক্ষপাত আছে PDL (উচ্চারিত "মূত্রত্যাগ!")।

এটি পার্ল ডেটা ল্যাঙ্গুয়েজ যা উচ্চ নির্ভুলতার গণিত এবং বৈজ্ঞানিক কম্পিউটিংয়ের জন্য ডিজাইন করা হয়েছে।

এখানে আপনার পরিসংখ্যান ব্যবহার করে একটি উদাহরণ দেওয়া আছে ....

use strict;
use warnings;
use PDL;

my $figs = pdl [
    [0.01, 0.01, 0.02, 0.04, 0.03],
    [0.00, 0.02, 0.02, 0.03, 0.02],
    [0.01, 0.02, 0.02, 0.03, 0.02],
    [0.01, 0.00, 0.01, 0.05, 0.03],
];

my ( $mean, $prms, $median, $min, $max, $adev, $rms ) = statsover( $figs );

say "Mean scores:     ", $mean;
say "Std dev? (adev): ", $adev;
say "Std dev? (prms): ", $prms;
say "Std dev? (rms):  ", $rms;

যা উত্পাদন করে:

Mean scores:     [0.022 0.018 0.02 0.02]
Std dev? (adev): [0.0104 0.0072 0.004 0.016]
Std dev? (prms): [0.013038405 0.010954451 0.0070710678 0.02]
Std dev? (rms):  [0.011661904 0.009797959 0.0063245553 0.017888544]

কটাক্ষপাত আছে PDL :: আদিম সম্পর্কে আরও তথ্যের জন্য statsover ফাংশন। এটি মনে করে যে ADEV হল "স্ট্যান্ডার্ড বিচ্যুতি"।

তবে এটি পিআরএমএস হতে পারে (যা সিনানের পরিসংখ্যান :: বর্ণনামূলক উদাহরণ দেখায়) বা আরএমএস (যা আরসের নুমপি উদাহরণ দেখায়)। আমার ধারণা এই তিনটির মধ্যে একটি অবশ্যই সঠিক ;-)

আরও পিডিএলের তথ্যের জন্য একবার দেখুন:

pdl.perl.org (অফিসিয়াল পিডিএল পৃষ্ঠা)।
পার্লমনসকে পিডিএলের দ্রুত রেফারেন্স গাইড
পিডিএলে ডাবের নিবন্ধ ড
পিডিএল উইকি
পিডিএল জন্য উইকিপিডিয়া এন্ট্রি
পিডিএলের জন্য সোর্সফোর্জ প্রকল্প পৃষ্ঠা

Question 9

আপনার অ্যারে কত বড়? এটি কোটি কোটি উপাদান দীর্ঘ না হলে এটিকে দু'বার লুপ করার বিষয়ে চিন্তা করবেন না। কোডটি সহজ এবং সহজেই পরীক্ষিত।

আমার অগ্রাধিকারটি হ'ল আপনার অ্যারেগুলিকে অ্যারে 2D অ্যারে রূপান্তর করতে এবং আখর্ট স্ট্যান্ডার্ড বিচ্যুতি আনার জন্য নম্পি অ্যারে ম্যাথ এক্সটেনশনটি ব্যবহার করা হবে:

>>> x = [ [ 1, 2, 4, 3, 4, 5 ], [ 3, 4, 5, 6, 7, 8 ] ] * 10
>>> import numpy
>>> a = numpy.array(x)
>>> a.std(axis=0) 
array([ 1. ,  1. ,  0.5,  1.5,  1.5,  1.5])
>>> a.mean(axis=0)
array([ 2. ,  3. ,  4.5,  4.5,  5.5,  6.5])

যদি এটি কোনও বিকল্প না হয় এবং আপনার খাঁটি পাইথন সমাধানের প্রয়োজন হয় তবে পড়া চালিয়ে যান ...

যদি আপনার অ্যারে হয়

x = [ 
      [ 1, 2, 4, 3, 4, 5 ],
      [ 3, 4, 5, 6, 7, 8 ],
      ....
]

তারপরে স্ট্যান্ডার্ড বিচ্যুতিটি হ'ল:

d = len(x[0])
n = len(x)
sum_x = [ sum(v[i] for v in x) for i in range(d) ]
sum_x2 = [ sum(v[i]**2 for v in x) for i in range(d) ]
std_dev = [ sqrt((sx2 - sx**2)/N)  for sx, sx2 in zip(sum_x, sum_x2) ]

যদি আপনি কেবল একবার আপনার অ্যারে লুপ করার জন্য দৃ determined় সংকল্পবদ্ধ হন তবে চলমান অঙ্কগুলি একত্রিত হতে পারে।

sum_x  = [ 0 ] * d
sum_x2 = [ 0 ] * d
for v in x:
   for i, t in enumerate(v):
   sum_x[i] += t
   sum_x2[i] += t**2

এটি উপরের তালিকাটি বোঝার সমাধানের মতো প্রায় মার্জিত নয়।

Question 10

আপনি স্ট্যান্ডার্ড বিচ্যুতি সম্পর্কিত উইকিপিডিয়া নিবন্ধটি বিশেষত র‌্যাপিড গণনা পদ্ধতি সম্পর্কে বিভাগটিতে দেখতে পারেন।

পাইথন ব্যবহার করে এমন একটি নিবন্ধও পেয়েছি, এতে আপনাকে খুব বেশি পরিবর্তন ছাড়াই কোডটি ব্যবহার করতে সক্ষম হওয়া উচিত: পরমানু বার্তা - স্ট্যান্ডার্ড বিচ্যুতিগুলি চালানো ।

Question 11

আমি মনে করি এই সমস্যাটি আপনাকে সহায়তা করবে। আদর্শ বিচ্যুতি

Question 12

কার্যকরী প্রোগ্রামিং শৈলীতে একাধিক লাইনে ছড়িয়ে থাকা এখানে একটি "ওয়ান-লাইনার" রয়েছে:

def variance(data, opt=0):
    return (lambda (m2, i, _): m2 / (opt + i - 1))(
        reduce(
            lambda (m2, i, avg), x:
            (
                m2 + (x - avg) ** 2 * i / (i + 1),
                i + 1,
                avg + (x - avg) / (i + 1)
            ),
            data,
            (0, 0, 0)))

Question 13

n=int(raw_input("Enter no. of terms:"))

L=[]

for i in range (1,n+1):

    x=float(raw_input("Enter term:"))

    L.append(x)

sum=0

for i in range(n):

    sum=sum+L[i]

avg=sum/n

sumdev=0

for j in range(n):

    sumdev=sumdev+(L[j]-avg)**2

dev=(sumdev/n)**0.5

print "Standard deviation is", dev

Question 14

নীচের উত্তরটির বর্ণনা হিসাবে: পান্ডা / স্কিপি / নম্পি কি একাগ্র স্ট্যান্ডার্ড বিচ্যুতি ফাংশন সরবরাহ করে? পাইথন পান্ডাস মডিউলটিতে চলমান বা ক্রমগত স্ট্যান্ডার্ড বিচ্যুতি গণনা করার জন্য একটি পদ্ধতি রয়েছে । তার জন্য আপনাকে আপনার ডেটাগুলিকে একটি পান্ডাস ডেটাফ্রেমে রূপান্তর করতে হবে (বা একটি সিরিজ এটি যদি 1 ডি হয়) তবে এর জন্য কার্যকারিতা রয়েছে।

Question 15

আমি আপডেটটি এভাবে প্রকাশ করতে চাই:

def running_update(x, N, mu, var):
    '''
        @arg x: the current data sample
        @arg N : the number of previous samples
        @arg mu: the mean of the previous samples
        @arg var : the variance over the previous samples
        @retval (N+1, mu', var') -- updated mean, variance and count
    '''
    N = N + 1
    rho = 1.0/N
    d = x - mu
    mu += rho*d
    var += rho*((1-rho)*d**2 - var)
    return (N, mu, var)

যাতে এক-পাসের ক্রিয়াকলাপটি এরকম দেখায়:

def one_pass(data):
    N = 0
    mu = 0.0
    var = 0.0
    for x in data:
        N = N + 1
        rho = 1.0/N
        d = x - mu
        mu += rho*d
        var += rho*((1-rho)*d**2 - var)
        # could yield here if you want partial results
   return (N, mu, var)

নোট করুন যে এটি নমুনা বৈকল্পিক (1 / N) গণনা করছে, জনসংখ্যার বৈচিত্রের নিরপেক্ষ অনুমান (যেটি 1 / (এন -1) নরমালাইজেশন ফ্যাক্টর ব্যবহার করে) নয়। অন্যান্য উত্তরগুলির মতো নয়, চলকটি, varযা চলমান বৈকল্পিকগুলি অনুসরণ করছে তা নমুনার সংখ্যার অনুপাতে বৃদ্ধি পায় না। সর্বদা এটি এখন পর্যন্ত দেখা নমুনাগুলির সেটের কেবলমাত্র বৈকল্পিকতা (বৈকল্পটি পাওয়ার ক্ষেত্রে কোনও চূড়ান্ত "এন দ্বারা বিভাজন নেই")।

একটি শ্রেণিতে এটি দেখতে এই রকম হবে:

class RunningMeanVar(object):
    def __init__(self):
        self.N = 0
        self.mu = 0.0
        self.var = 0.0
    def push(self, x):
        self.N = self.N + 1
        rho = 1.0/N
        d = x-self.mu
        self.mu += rho*d
        self.var += + rho*((1-rho)*d**2-self.var)
    # reset, accessors etc. can be setup as you see fit

এটি ওজনযুক্ত নমুনাগুলির জন্যও কাজ করে:

def running_update(w, x, N, mu, var):
    '''
        @arg w: the weight of the current sample
        @arg x: the current data sample
        @arg mu: the mean of the previous N sample
        @arg var : the variance over the previous N samples
        @arg N : the number of previous samples
        @retval (N+w, mu', var') -- updated mean, variance and count
    '''
    N = N + w
    rho = w/N
    d = x - mu
    mu += rho*d
    var += rho*((1-rho)*d**2 - var)
    return (N, mu, var)

Question 16

আপনি পাইথনের সাথে চলমান মান বিচ্যুতি কীভাবে বাস্তবায়ন করতে পারেন তার একটি ব্যবহারিক উদাহরণ এখানে numpy:

a = np.arange(1, 10)
s = 0
s2 = 0
for i in range(0, len(a)):
    s += a[i]
    s2 += a[i] ** 2 
    n = (i + 1)
    m = s / n
    std = np.sqrt((s2 / n) - (m * m))
    print(std, np.std(a[:i + 1]))

এটি গণিত স্ট্যান্ডার্ড বিচ্যুতি এবং নমির সাথে গণনা করা একটি চেক স্ট্যান্ডার্ড বিচ্যুতি মুদ্রণ করবে:

0.0 0.0
0.5 0.5
0.8164965809277263 0.816496580927726
1.118033988749895 1.118033988749895
1.4142135623730951 1.4142135623730951
1.707825127659933 1.707825127659933
2.0 2.0
2.29128784747792 2.29128784747792
2.5819888974716116 2.581988897471611

আমি কেবল এই থ্রেডে বর্ণিত সূত্রটি ব্যবহার করছি:

stdev = sqrt((sum_x2 / n) - (mean * mean))