शीर्ष आवृत्तियों के सेट से जिप्फ़ के नियम गुणांक की गणना कैसे करें?

Question

मेरे पास कई क्वेरी आवृत्तियां हैं, और मुझे जिपफ के कानून के गुणांक का अनुमान लगाने की आवश्यकता है। ये शीर्ष आवृत्तियाँ हैं:

26486
12053
5052
3033
2536
2391
1444
1220
1152
1039

Comments

विकिपीडिया पृष्ठ के अनुसार जिपफ के कानून के दो मापदंड हैं। तत्वों की संख्या और प्रतिपादक। आपके मामले में क्या है , 10? और आवृत्तियों की गणना आपके आपूर्ति किए गए मूल्यों को सभी आपूर्ति किए गए मूल्यों के योग से विभाजित करके की जा सकती है? एस $N$$s$$N$

— mpiktas

चलो यह दस है, और आवृत्तियों की गणना आपके आपूर्ति मूल्यों को सभी आपूर्ति किए गए मूल्यों के योग से विभाजित करके की जा सकती है .. मैं कैसे अनुमान लगा सकता हूं?

— डाईगोलो

Answer 1

अपडेट मैंने @whuber सुझाव के अनुसार अधिकतम संभावना अनुमानक के साथ कोड को अपडेट किया है। लॉग सैद्धांतिक संभावनाओं और लॉग फ़्रीक्वेंसी के बीच अंतर के वर्गों को न्यूनतम करने पर हालांकि एक उत्तर देता है एक सांख्यिकीय प्रक्रिया होगी यदि यह दिखाया जा सकता है कि यह किसी प्रकार का एम-अनुमानक है। दुर्भाग्य से मैं ऐसा कोई भी नहीं सोच सकता था जो एक ही परिणाम दे सके।

यहाँ मेरा प्रयास है। मैं आवृत्तियों के लघुगणक की गणना करता हूं और उन्हें इस सूत्र द्वारा दी गई सैद्धांतिक संभावनाओं के लघुगणक में फिट करने का प्रयास करता हूं । अंतिम परिणाम उचित लगता है। यहाँ आर में मेरा कोड है।

fr <- c(26486, 12053, 5052, 3033, 2536, 2391, 1444, 1220, 1152, 1039)

p <- fr/sum(fr)

lzipf <- function(s,N) -s*log(1:N)-log(sum(1/(1:N)^s))

opt.f <- function(s) sum((log(p)-lzipf(s,length(p)))^2)

opt <- optimize(opt.f,c(0.5,10))

> opt
$minimum
[1] 1.463946

$objective
[1] 0.1346248

सबसे अच्छा द्विघात फिट तो ।$s=1.47$

R में अधिकतम संभावना mleफ़ंक्शन ( stats4पैकेज से) के साथ की जा सकती है , जो मानक त्रुटियों की गणना करने में मदद करता है (यदि सही नकारात्मक अधिकतम संभावना फ़ंक्शन की आपूर्ति की जाती है):

ll <- function(s) sum(fr*(s*log(1:10)+log(sum(1/(1:10)^s))))

fit <- mle(ll,start=list(s=1))

> summary(fit)
Maximum likelihood estimation

Call:
mle(minuslogl = ll, start = list(s = 1))

Coefficients:
  Estimate  Std. Error
s 1.451385 0.005715046

-2 log L: 188093.4 

यहाँ लॉग-लॉग स्केल में फिट का ग्राफ (जैसा कि @whuber ने सुझाया है):

s.sq <- opt$minimum
s.ll <- coef(fit)

plot(1:10,p,log="xy")
lines(1:10,exp(lzipf(s.sq,10)),col=2)
lines(1:10,exp(lzipf(s.ll,10)),col=3)

लाल रेखा वर्गों के योग का योग है, हरे रंग की रेखा अधिकतम-उपयुक्त है।

Comments

वहाँ भी एक R पैकेज zipfR cran.r-project.org/web/packages/zipfR/index.html है। मैंने इसे हालांकि कोशिश नहीं की है।

— 14

@onestop, लिंक के लिए धन्यवाद। यह अच्छा होगा यदि कोई इस पैकेज का उपयोग करके इस प्रश्न का उत्तर देगा। मेरे समाधान में निश्चित रूप से गहराई का अभाव है, हालांकि यह किसी प्रकार का उत्तर देता है।

— 15

(+1) आप वास्तव में प्रभावशाली हैं। इतने सारे अलग अलग सांख्यिकीय क्षेत्रों में बहुत अच्छे योगदान!

— चेर

@chl, धन्यवाद! मुझे निश्चित रूप से लगता है कि मैं इस साइट में इस तरह की विशेषताओं के साथ अकेला नहीं हूं;)

— एमपीआईसीटीज

Answer 2

किसी भी अनुमान समस्या में हमारे सामने कई मुद्दे हैं :

1. पैरामीटर का अनुमान लगाएं।

2. उस अनुमान की गुणवत्ता का आकलन करें।

3. डेटा का अन्वेषण करें।

4. फिट का मूल्यांकन करें।

उन लोगों के लिए जो समझ और संचार के लिए सांख्यिकीय तरीकों का उपयोग करेंगे, पहले दूसरों के बिना कभी नहीं किया जाना चाहिए।

$i=1,2,\ldots,n$$i^{-s}$$s$$s\gt 0$

$$H_s(n)=\frac{1}{1^s} + \frac{1}{2^s} + \cdots + \frac{1}{n^s}.$$

$i$$1$$n$

$$\log(\Pr(i)) = \log\left(\frac{i^{-s}}{H_s(n)}\right) = -s\log(i) - \log(H_s(n)).$$

$f_i, i=1,2,\ldots, n$

$$\Pr(f_1,f_2,\ldots,f_n) = \Pr(1)^{f_1}\Pr(2)^{f_2}\cdots\Pr(n)^{f_n}.$$

इस प्रकार डेटा के लिए लॉग संभावना है

$$\Lambda(s) = -s \sum_{i=1}^n{f_i \log(i)} - \left(\sum_{i=1}^n{f_i}\right) \log\left(H_s(n)\right).$$

$s$

$\hat{s} = 1.45041$$\Lambda(\hat{s}) = -94046.7$$\hat{s}_{ls} = 1.463946$$\Lambda(\hat{s}_{ls}) = -94049.5$

$s$$[1.43922, 1.46162]$

ज़िपफ के नियम की प्रकृति को देखते हुए, इस फिट को ग्राफ करने का सही तरीका लॉग-लॉग प्लॉट पर है , जहां फिट रैखिक होगा (परिभाषा के अनुसार):

फिट और डेटा का पता लगाने की अच्छाई का मूल्यांकन करने के लिए, अवशिष्ट (डेटा / फिट, लॉग-लॉग कुल्हाड़ियों को फिर से देखें):

$\chi^2 = 656.476$

---

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

Comments

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

— कार्डिनल

@ कार्डिनल मैं आपके सामने कहना चाहता हूं। यदि आपके पास पूरी तरह से प्रतिक्रिया के लिए समय नहीं है, तो आपके विचार में "इन आंकड़ों के लिए सबसे अच्छा विचार" भी हो सकता है, यहां तक ​​कि एक स्केच भी आपका स्वागत है। मैं अनुमान लगा सकता हूं कि आप इसके साथ कहां जा रहे हैं: डेटा को रैंक किया गया है, एक प्रक्रिया जो निर्भरता पैदा करती है और मुझे रैंकिंग के संभावित प्रभावों को पहचानने के बिना व्युत्पन्न संभावना की रक्षा करने की आवश्यकता होनी चाहिए। साउंड औचित्य के साथ एक अनुमान प्रक्रिया को देखना अच्छा होगा। हालाँकि, मुझे उम्मीद है कि मेरे विश्लेषण को डेटासेट के विशाल आकार से बचाया जा सकता है।

— whuber

@कार्डिनल, हम पर फ़र्मेट न करें :) यदि आपके पास अन्य उत्तरदाताओं की तुलना में कुछ अलग अंतर्दृष्टि है, तो इसे अलग-अलग उत्तर में व्यक्त करने के लिए स्वतंत्र महसूस करें, भले ही यह प्रति उत्तर एक वैध उत्तर का गठन नहीं करेगा। में math.SE उदाहरण के लिए ऐसी स्थितियों काफी अक्सर सामने आते हैं।

— mpiktas

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

— whuber

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

— कार्डिनल

Answer 3

$s$

PyMC3 जैसी संभाव्य प्रोग्रामिंग भाषाओं में से एक इस अनुमान को अपेक्षाकृत सरल बनाती है। अन्य भाषाओं में स्टेन शामिल हैं जिनमें महान विशेषताएं और सहायक समुदाय हैं।

यहाँ मॉडल (पर भी ऑप्स डेटा पर फिट की मेरी अजगर कार्यान्वयन है Github ):

import theano.tensor as tt
import numpy as np
import pymc3 as pm
import matplotlib.pyplot as plt

data = np.array( [26486, 12053, 5052, 3033, 2536, 2391, 1444, 1220, 1152, 1039] )

N = len( data )

print( "Number of data points: %d" % N )

def build_model():
    with pm.Model() as model:
        # unsure about the prior...
        #s = pm.Normal( 's', mu=0.0, sd=100 )
        #s = pm.HalfNormal( 's', sd=10 )
        s = pm.Gamma('s', alpha=1, beta=10)

        def logp( f ):
            r = tt.arange( 1, N+1 )
            return -s * tt.sum( f * tt.log(r) ) - tt.sum( f ) * tt.log( tt.sum(tt.power(1.0/r,s)) )

        pm.DensityDist( 'obs', logp=logp, observed={'f': data} )

    return model


def run( n_samples=10000 ):
    model = build_model()
    with model:
        start = pm.find_MAP()
        step = pm.NUTS( scaling=start )
        trace = pm.sample( n_samples, step=step, start=start )

    pm.summary( trace )
    pm.traceplot( trace )
    pm.plot_posterior( trace, kde_plot=True )
    plt.show()

if __name__ == '__main__':
    run()

$s$$s$

कुछ बुनियादी नमूना निदान प्रदान करने के लिए, हम देख सकते हैं कि नमूना "अच्छी तरह से मिश्रण कर रहा था" क्योंकि हम ट्रेस में कोई संरचना नहीं देखते हैं:

कोड को चलाने के लिए, एक को थीनो और PyMC3 संकुल के साथ पायथन की आवश्यकता होती है।

उनके शानदार जवाब और टिप्पणियों के लिए @ w-huber को धन्यवाद!

Answer 4

यहां वीजीएएम का उपयोग करके परिणामों को फिट करने, मूल्यांकन करने और परिणामों का पता लगाने का मेरा प्रयास है:

require("VGAM")

freq <- dzipf(1:100, N = 100, s = 1)*1000 #randomizing values
freq <- freq  + abs(rnorm(n=1,m=0, sd=100)) #adding noize

zdata <- data.frame(y = rank(-freq, ties.method = "first") , ofreq = freq)
fit = vglm(y ~ 1, zipf, zdata, trace = TRUE,weight = ofreq,crit = "coef")
summary(fit)

s <- (shat <- Coef(fit)) # the coefficient we've found
probs <- dzipf(zdata$y, N = length(freq), s = s) # expected values
chisq.test(zdata$ofreq, p = probs) 
plot(zdata$y,(zdata$ofreq),log="xy") #log log graph
lines(zdata$y, (probs)*sum(zdata$ofreq),  col="red") # red line, num of predicted frequency

    Chi-squared test for given probabilities

data:  zdata$ofreq
X-squared = 99.756, df = 99, p-value = 0.4598

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

Answer 5

$x = 1$$\hat{w_{x=1}}$

$$\hat{s_{UWSE}} = H_{10}^{-1}(\frac{1}{\hat{w_{x=1}}})$$

$\hat{w_{x=1}} = 0.4695599775$

$$\hat{s_{UWSE}} = 1.4$$

फिर, यूडब्ल्यूएसई केवल एक सुसंगत अनुमान प्रदान करता है - कोई विश्वास अंतराल नहीं, और हम सटीकता में कुछ व्यापार बंद देख सकते हैं। ऊपर दिए गए mpiktas का समाधान भी UWSE का एक अनुप्रयोग है - हालांकि प्रोग्रामिंग की आवश्यकता है। आकलनकर्ता की पूरी व्याख्या के लिए देखें: https://paradsp.wordpress.com/ - नीचे सभी तरह से।

Comments

यूडब्ल्यूएसई जिपफ के कानून से कैसे संबंधित है?

— माइकल आर। चेरिक

UWSE (यूनिक वेट स्पेस एस्टिमेशन) इस तथ्य का उपयोग करता है कि किसी दिए गए N के लिए पैरामीटर s के विभिन्न मूल्यों में शीर्ष-प्रायिकता / आवृत्ति अद्वितीय है। जिपफ के नियम के संबंध में, यह हमें बता रहा है कि रैंक, एन और एक सर्वोच्च आवृत्ति के लिए कई आइटम दिए गए हैं, शेष वस्तुओं (2, ..., एन) के लिए केवल एक ही तरीका है जो हम कर सकते हैं "nth आइटम 1 / n ^ s गुना है जितना कि सबसे अधिक लगातार आइटम, कुछ s के लिए"। दूसरे शब्दों में, इस जानकारी को देखते हुए, जिपफ के कानून को रखने का केवल एक ही तरीका है - बेशक, यह मानते हुए कि जिपफ का कानून वास्तव में पकड़ में है।

— CYP450

Answer 6

मेरा समाधान mpiktas द्वारा प्रदान किए गए उत्तरों के पूरक होने का प्रयास करता है और पायथन में एक कार्यान्वयन कर रहा है। हमारी आवृत्तियों और रेंज x हैं:

freqs = np.asarray([26486, 12053, 5052, 3033, 2536, 2391, 1444, 1220, 1152, 1039])
x = np.asarray([1, 2, 3, 4, 5 ,6 ,7 ,8 ,9, 10])

जैसा कि हमारे कार्य को सभी सीमा में परिभाषित नहीं किया गया है, हमें यह जांचने की आवश्यकता है कि हम हर बार इसे गणना करते समय सामान्य कर रहे हैं। असतत मामले में, एक साधारण सन्निकटन सभी y (x) के योग से विभाजित होता है। इस तरह हम विभिन्न मापदंडों की तुलना कर सकते हैं।

f,ax = plt.subplots()
ax.plot(x, f1, 'o')
ax.set_xscale("log")
ax.set_yscale("log")

def loglik(b):  
    # Power law function
    Probabilities = x**(-b)

    # Normalized
    Probabilities = Probabilities/Probabilities.sum()

    # Log Likelihoood
    Lvector = np.log(Probabilities)

    # Multiply the vector by frequencies
    Lvector = np.log(Probabilities) * freqs

    # LL is the sum
    L = Lvector.sum()

    # We want to maximize LogLikelihood or minimize (-1)*LogLikelihood
    return(-L)

s_best = minimize(loglik, [2])
print(s_best)
ax.plot(x, freqs[0]*x**-s_best.x)

परिणाम हमें पिछले उत्तरों की तरह 1.450408 की ढलान देता है।