dan nasıl numune alınır


19

Bir yoğunluğuna göre örnek istediğiniz ve kesinlikle olumlu. (Motivasyon: Bu, Gamma yoğunluğunun şekil parametresinin önceden tekdüze olması durumunda Gibbs örneklemesi için yararlı olabilir.)

f(a)cada1Γ(a)1(1,)(a)
cd

Herkes bu yoğunluktan kolayca nasıl numune alacağını biliyor mu? Belki standarttır ve bilmediğim bir şeydir?

Az ya da çok çalışacak aptal bir reddetme örnekleme algoritması düşünebilirsiniz (mod of , örnek büyük bir kutuda üniforma ve ), ancak (i) hiç verimli değilse ve (ii) bir bilgisayarın orta düzeyde bile kolayca işlemesi için çok büyük olursa reddetme büyük c ve d . (Büyük c ve d modlarının yaklaşık olarak a = cd'de olduğuna dikkat edin .) f ( a , u ) [ 0 , 10 a ] × [ 0 , f ( a ) ] u > f ( a ) f ( a ) c d c d a = c daf(a,u)[0,10a]×[0,f(a)]u>f(a)f(a)cdcda=cd

Herhangi bir yardım için şimdiden teşekkürler!


+1 iyi soru. Standart bir yaklaşım olup olmadığından emin değilim.
suncoolsu

Devroye'nin metni gibi "açık" yerlerde henüz (fikirler için) kontrol ettiniz mi?
kardinal

Evet, Devroye'nin metninden bir dizi fikir denedim. en yaklaşımlar daha basit işlevlerle, (cdf bulmak için) ayrışma ya entegrasyonunu gerektiren görünmektedir gerçi ..., zor beni her yerde çoğu ile almak için yapılmış, ya da daha basit fonksiyonları ile sınırlayan vardır ... ancak Γ işlevi tüm bunları zorlaştırır. Herhangi birinin bu alt problemlere yaklaşımları nerede arayacağı konusunda fikirleri varsa - örneğin, Γ fonksiyonunun burada olduğu gibi (sadece normalleştirici bir sabit olarak değil) "önemli" bir şekilde ortaya çıktığı - bu benim için çok yararlı olabilir ! Γ(a)ΓΓ
NF

ve c d 2 durumu arasında büyük bir fark vardır . Bu iki durumu da ele almanız mı gerekiyor? cd<2cd2
whuber

1
Bu doğru - teşekkürler. olduğunu varsayabiliriz . cd2
NF

Yanıtlar:


21

Reddetme örneklemesi olduğunda son derece iyi çalışır ve c d exp ( 2 ) için makul olur .cdexp(5)cdexp(2)

Matematiği biraz basitleştirmek için , x = a yazın ve şunu not edin:k=cdx=a

f(x)kxΓ(x)dx

için . Ayar x = u 3 / 2 verirx1x=u3/2

f(u)ku3/2Γ(u3/2)u1/2du

için . Ne zaman k exp ( 5 ) , bu dağıtım son derece yakın Normal etmektir (ve yanı yaklaştıkça k büyüdükçe). Özellikle,u1kexp(5)k

  1. modunu sayısal olarak bulun (örneğin, Newton-Raphson kullanarak).f(u)

  2. F ( u ) modu hakkında ikinci sıraya genişletin .logf(u)

Bu, yaklaşık bir Normal dağılımın parametrelerini verir. Yüksek doğrulukta, bu yaklaşık Normal , aşırı kuyruklar dışında hükmeder. ( K < exp ( 5 ) olduğunda , tahakkümü sağlamak için Normal pdf'yi biraz ölçeklendirmeniz gerekebilir.)f(u)k<exp(5)

Bu ön çalışmayı verilen herhangi bir değeri için yaptıktan ve sabit bir M > 1 (aşağıda açıklandığı gibi) tahmin ettikten sonra , rastgele bir varyasyon elde etmek aşağıdakilerle ilgilidir:kM>1

  1. Hakim Normal dağılımdan g ( u ) bir değeri çizin .ug(u)

  2. Eğer ya da yeni bir tek tip değişken eğer X aşan f ( u ) / ( E g ( u ) ) , aşama 1 'e geri döner.u<1Xf(u)/(Mg(u))

  3. Takım .x=u3/2

Değerlendirmelerine beklenen sayısı nedeniyle arasında tutarsızlıklara g ve f daha dağılımı özellikleri nedeniyle ret sadece biraz daha büyük 1. (bazı ek değerlendirmeler daha oluşacak olan 1 , hatta zaman k olarak düşük olduğu gibi 2 gibi sıklığı oluşumlar azdır.)fgf1k2

Plot of f and g for k=5

Bu grafik, Şekil logaritma bir g ve f bir fonksiyonu olarak u için . Grafikler çok yakın olduğu için neler olup bittiğini görmek için oranlarını incelememiz gerekiyor:k=exp(5)

plot of log ratio

Bu, günlük oranı ; logaritmanın dağılımın ana kısmı boyunca pozitif olmasını sağlamak için M = exp ( 0.004 ) faktörü dahil edilmiştir; yani, muhtemelen ihmal edilebilir olasılık bölgeleri dışında M g ( u ) f ( u ) sağlamak . M'yi yeterince büyük yaparak , M glog(exp(0.004)g(u)/f(u))M=exp(0.004)Mg(u)f(u)MMgen uç kuyruklar dışında hepsine hakimdir (zaten bir simülasyonda seçilme şansı yoktur). Bununla birlikte, M büyüdükçe reddedilme sıklığı artar. Gibi k büyük büyür, M çok yakın şekilde seçilebilir 1 pratikte ceza alınmaz, hangi.fMkM1

Benzer bir yaklaşım için bile geçerlidir , ancak exp ( 2 ) < k < exp ( 5 ) olduğunda oldukça büyük M değerleri gerekebilir , çünkü f ( u ) belirgin şekilde asimetriktir. Örneğin, k = exp ( 2 ) ile , oldukça doğru bir g elde etmek için M = 1 ayarlamamız gerekir :k>exp(2)Mexp(2)<k<exp(5)f(u)k=exp(2)gM=1

Plot for k=2

Üst kırmızı eğri, grafiğidir, alt mavi eğri ise log ( f ( u ) ) grafiğidir . Reddi örnekleme f göreli exp ( 1 ) g kötü değil hala: Bütün deneme 2/3 hakkında neden olacaktır çaba üç katına, reddedilmesine çizer. Sağ arka ( u > 10 ya da x > 10 3 / 2 ~ 30log(exp(1)g(u))log(f(u))fexp(1)gu>10x>103/230) (Nedeniyle ret örnekleme temsil altında olacak artık baskındır f fazla bu kuyruk içerir orada daha az), fakat exp ( - 20 ) ~ 10 - 9 toplam olasılık.exp(1)gfexp(20)109

Özetlemek gerekirse, modu hesaplamak ve güç serisinin kuadratik modunu mod etrafında değerlendirmek için yapılan ilk çabadan sonra - en fazla onlarca işlev değerlendirmesi gerektiren bir çaba - reddeden örnekleme kullanabilirsiniz değişken başına 1 ve 3 (ya da öylesine) değerlendirmeler arasında beklenen bir maliyet. Maliyet çarpanı olarak hızla 1 damla k = C d 5 artışlara.f(u)k=cd

Sadece bir beraberlik bile gereklidir, bu yöntem makul. Aynı k değeri için birçok bağımsız çekilişe ihtiyaç duyulduğunda kendi başına gelir , çünkü o zaman ilk hesaplamaların yükü birçok çekiliş üzerinden itfa edilir.fk


ek

@Cardinal, oldukça makul bir şekilde, devam eden bazı el sallama analizlerinin desteklenmesini istedi. Özellikle, neden dönüşümü gerektiği yapmak dağılımı yaklaşık olarak normal?x=u3/2

Box-Cox dönüşümleri teorisinin ışığında, dağılımı "daha" Normal kılacak (sabit bir α için , umarım birlikten çok farklı olmayan) biçiminde bir güç dönüşümü aramak doğaldır . Tüm Normal dağılımların basit bir şekilde karakterize edildiğini hatırlayın: pdf'lerinin logaritmaları tamamen kuadratiktir, sıfır doğrusal terim vardır ve daha yüksek mertebe terimleri yoktur. Bu nedenle, herhangi bir pdf alabilir ve logaritmasını (en yüksek) tepe noktası etrafında bir kuvvet serisi olarak genişleterek Normal dağılımla karşılaştırabiliriz. En azından üçüncüyü yapan bir α değeri arıyoruzx=uααα power vanish, at least approximately: that is the most we can reasonably hope that a single free coefficient will accomplish. Often this works well.

But how to get a handle on this particular distribution? Upon effecting the power transformation, its pdf is

f(u)=kuαΓ(uα)uα1.

Take its logarithm and use Stirling's asymptotic expansion of log(Γ):

log(f(u))log(k)uα+(α1)log(u)αuαlog(u)+uαlog(2πuα)/2+cuα

(for small values of c, which is not constant). This works provided α is positive, which we will assume to be the case (for otherwise we cannot neglect the remainder of the expansion).

Compute its third derivative (which, when divided by 3!, will be the coefficient of the third power of u in the power series) and exploit the fact that at the peak, the first derivative must be zero. This simplifies the third derivative greatly, giving (approximately, because we are ignoring the derivative of c)

12u(3+α)α(2α(2α3)u2α+(α25α+6)uα+12cα).

When k is not too small, u will indeed be large at the peak. Because α is positive, the dominant term in this expression is the 2α power, which we can set to zero by making its coefficient vanish:

2α3=0.

That's why α=3/2 works so well: with this choice, the coefficient of the cubic term around the peak behaves like u3, which is close to exp(2k). Once k exceeds 10 or so, you can practically forget about it, and it's reasonably small even for k down to 2. The higher powers, from the fourth on, play less and less of a role as k gets large, because their coefficients grow proportionately smaller, too. Incidentally, the same calculations (based on the second derivative of log(f(u)) at its peak) show the standard deviation of this Normal approximation is slightly less than 23exp(k/6), with the error proportional to exp(k/2).


(+1) Great answer. Perhaps you could expand briefly on the motivation for your choice of transformation variable.
cardinal

Nice addition. This makes a very, very complete answer!
cardinal

11

I like @whuber's answer very much; it's likely to be very efficient and has a beautiful analysis. But it requires some deep insight with respect to this particular distribution. For situations where you don't have that insight (so for different distributions), I also like the following approach which works for all distributions where the PDF is twice differentiable and that second derivative has finitely many roots. It requires quite a bit of work to set up, but then afterwards you have an engine that works for most distributions you can throw at it.

Basically, the idea is to use a piecewise linear upper bound to the PDF which you adapt as you are doing rejection sampling. At the same time you have a piecewise linear lower bound for the PDF which prevents you from having to evaluate the PDF too frequently. The upper and lower bounds are given by chords and tangents to the PDF graph. The initial division into intervals is such that on each interval, the PDF is either all concave or all convex; whenever you have to reject a point (x, y) you subdivide that interval at x. (You can also do an extra subdivision at x if you had to compute the PDF because the lower bound is really bad.) This makes the subdivisions occur especially frequently where the upper (and lower) bounds are bad, so you get a really good approximation of your PDF essentially for free. The details are a little tricky to get right, but I've tried to explain most of them in this series of blog posts - especially the last one.

Those posts don't discuss what to do if the PDF is unbounded either in domain or in values; I'd recommend the somewhat obvious solution of either doing a transformation that makes them finite (which would be hard to automate) or using a cutoff. I would choose the cutoff depending on the total number of points you expect to generate, say N, and choose the cutoff so that the removed part has less than 1/(10N) probability. (This is easy enough if you have a closed form for the CDF; otherwise it might also be tricky.)

This method is implemented in Maple as the default method for user-defined continuous distributions. (Full disclosure - I work for Maplesoft.)


I did an example run, generating 10^4 points for c = 2, d = 3, specifying [1, 100] as the initial range for the values:

graph

There were 23 rejections (in red), 51 points "on probation" which were at the time in between the lower bound and the actual PDF, and 9949 points which were accepted after checking only linear inequalities. That's 74 evaluations of the PDF in total, or about one PDF evaluation per 135 points. The ratio should get better as you generate more points, since the approximation gets better and better (and conversely, if you generate only few points, the ratio is worse).


And by the way - if you need to evaluate the PDF only very infrequently because you have a good lower bound for it, you can afford to take longer for it, so you can just use a bignum library (maybe even MPFR?) and evaluate the Gamma function in that without too much fear of overflow.
Erik P.

(+1) This is a nice approach. Thanks for sharing it.
whuber

The overflow problem is handled by exploiting (simple) relationships among Gammas. The idea is that after normalizing the peak to be around 1, the only calculations that matter are of the form Γ(exp(cd))/Γ(x) where x is fairly close to exp(k)--all the rest will be so close to zero you can neglect them. That ratio can be simplified to finding two values of Γ for arguments between 1 and 2 plus a sum of a small number of logarithms: no overflow there.
whuber

@whuber re: Gammas: Ah yes - I see that you had suggested this above as well. Thanks!
Erik P.

3

You could do it by numerically executing the inversion method, which says that if you plug uniform(0,1) random variables in the inverse CDF, you get a draw from the distribution. I've included some R code below that does this, and from the few checks I've done, it is working well, but it is a bit sloppy and I'm sure you could optimize it.

If you're not familiar with R, lgamma() is the log of the gamma function; integrate() calculates a definite 1-D integral; uniroot() calculates a root of a function using 1-D bisection.

# density. using the log-gamma gives a more numerically stable return for 
# the subsequent numerical integration (will not work without this trick)
f = function(x,c,d) exp( x*log(c) + (x-1)*log(d) - lgamma(x) )

# brute force calculation of the CDF, calculating the normalizing constant numerically
F = function(x,c,d) 
{
   g = function(x) f(x,c,d)
   return( integrate(g,1,x)$val/integrate(g,1,Inf)$val )
}

# Using bisection to find where the CDF equals p, to give the inverse CDF. This works 
# since the density given in the problem corresponds to a continuous CDF. 
F_1 = function(p,c,d) 
{
   Q = function(x) F(x,c,d)-p
   return( uniroot(Q, c(1+1e-10, 1e4))$root )
}

# plug uniform(0,1)'s into the inverse CDF. Testing for c=3, d=4. 
G = function(x) F_1(x,3,4)
z = sapply(runif(1000),G)

# simulated mean
mean(z)
[1] 13.10915

# exact mean
g = function(x) f(x,3,4)
nc = integrate(g,1,Inf)$val
h = function(x) f(x,3,4)*x/nc
integrate(h,1,Inf)$val
[1] 13.00002 

# simulated second moment
mean(z^2)
[1] 183.0266

# exact second moment
g = function(x) f(x,3,4)
nc = integrate(g,1,Inf)$val
h = function(x) f(x,3,4)*(x^2)/nc
integrate(h,1,Inf)$val
[1] 181.0003

# estimated density from the sample
plot(density(z))

# true density 
s = seq(1,25,length=1000)
plot(s, f(s,3,4), type="l", lwd=3)

The main arbitrary thing I do here is assuming that (1,10000) is a sufficient bracket for the bisection - I was lazy about this and there might be a more efficient way to choose this bracket. For very large values, the numerical calculation of the CDF (say, >100000) fails, so the bracket must be below this. The CDF is effectively equal to 1 at those points (unless c,d are very large), so something could probably be included that would prevent miscalculation of the CDF for very large input values.

Edit: When cd is very large, a numerical problem occurs with this method. As whuber points out in the comments, once this has occurred, the distribution is essentially degenerate at it's mode, making it a trivial sampling problem.


1
The method is correct, but awfully painful! How many function evaluations do you suppose are needed for a single random variate? Thousands? Tens of thousands?
whuber

There is a lot of computing, but it doesn't actually take very long - certainly much faster than rejection sampling. The simulation I showed above took less than a minute. The problem is that when cd is large, it still breaks. This is basically because it has to calculate the equivalent of (cd)x for large x. Any solution proposed will have that problem though - I'm trying to figure out if there's a way to do this on the log scale and transforming back.
Macro

1
A minute for 1,000 variates isn't very good: you will wait hours for one good Monte-Carlo simulation. You can go four orders of magnitude faster using rejection sampling. The trick is to reject with a close approximation of f rather than with respect to a uniform distribution. Concerning the calculation: compute alog(cd)log(Γ(a)) (by computing log Gamma directly, of course), then exponentiate. That avoids overflow.
whuber

That is what I do for the computation - it still doesn't avoid overflow. You can't exponentiate a number greater than around 500 on a computer. That quantity gets much larger than that. I mean "pretty good" comparing it with the rejection sampling the OP mentioned.
Macro

1
I did notice that the "standard deviation rule" that normals follow (68% within 1, 95% within 2, 99.7% within 3) did apply. So basically for large cd it's a point mass at the mode. From what you say, the threshold where this occurs before the numerical problems, so this still works. Thanks for the insight
Macro
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.