0-सेंसर्ड मल्टीवेरेट सामान्य के माध्य और विचरण क्या हैं?


9

चलो ZN(μ,Σ) में हो Rd। माध्य और सहसंयोजक मैट्रिक्स क्या हैंZ+=max(0,Z) (अधिकतम गणना तत्व के साथ)?

यह उदाहरण के लिए आता है, क्योंकि अगर हम एक गहरे नेटवर्क के अंदर ReLU सक्रियण फ़ंक्शन का उपयोग करते हैं, और CLT के माध्यम से मान लेते हैं कि किसी दिए गए लेयर में इनपुट लगभग सामान्य हैं, तो यह आउटपुट का वितरण है।

(मुझे यकीन है कि कई लोगों ने इससे पहले गणना की है, लेकिन मैं कहीं भी सूचीबद्ध परिणाम को यथोचित पठनीय तरीके से नहीं पा सका।)


यह आपके उत्तर को सरल करेगा - शायद बहुत - यह मानने के लिए कि आप इसे दो अलग-अलग प्रश्नों के परिणामों के संयोजन से प्राप्त कर सकते हैं: (1) एक काटे गए सामान्य वितरण के क्षण क्या हैं और (2) मिश्रण के क्षण क्या हैं ? उत्तरार्द्ध सीधा है और आपको जो कुछ भी करने की ज़रूरत है वह पूर्व के लिए परिणाम है।
whuber

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

सही: मुझे यकीन है कि आपके बीजगणित ने मेरे द्वारा बताए गए के समान है, इसलिए ऐसा लगता है कि हम बीजगणित को सरल बनाने के लिए सराहना साझा करते हैं। बीजगणित को कम करने का एक आसान तरीका है विकर्ण तत्वों को मानकीकृत करनाΣएकता के लिए, क्योंकि वह सब कुछ प्रत्येक चर के लिए माप की एक इकाई स्थापित करना है। उस बिंदु पर आप सीधे मिश्रण के क्षणों के लिए (सरल, स्पष्ट) भावों में रोसेनबॉम के परिणामों को सीधे प्लग कर सकते हैं। चाहे वह बीजगणितीय सरलीकरण के लायक भी हो, स्वाद की बात हो सकती है: सरलीकरण के बिना, यह एक सरल, मॉड्यूलर कंप्यूटर प्रोग्राम की ओर जाता है।
whuber

1
मुझे लगता है कि कोई ऐसा प्रोग्राम लिख सकता है जो रोसनबॉम के परिणामों के साथ सीधे क्षणों की गणना करता है और उचित रूप से मिश्रण करता है, और फिर उन्हें मूल स्थान में वापस स्थानांतरित करता है और उन्हें स्केल करता है। शायद मैं जिस तरह से यह किया है की तुलना में तेजी से होता।
डगल

जवाबों:


7

हम पहले इसे केवल कुछ निश्चित क्षणों पर निर्भर करने के लिए कम कर सकते हैं

E[Z+]=[E[(Zi)+]]iCov(Z+)=[Cov((Zi)+,(Zj)+)]ij,
और क्योंकि हम एक सामान्य वितरण के कुछ आयामों का समन्वय-वार रूपांतरण कर रहे हैं, हमें केवल 1d सेंसर वाले सामान्य और दो 1d सेंसर किए गए मानदंडों के सहवास के माध्य और विचरण के बारे में चिंता करने की आवश्यकता है।

हम कुछ परिणामों का उपयोग करेंगे

एस रोसेनबाम (1961)। एक काटे गए बीवरिएट सामान्य वितरण के क्षण । जेआरएसएस बी, वॉल्यूम 23 पीपी 405-408। ( जस्टर )

रोसेनबाम मानते हैं

[X~Y~]N([00],[1ρρ1]),
और घटना के लिए छंटनी पर विचार करता है V={X~aX,Y~aY}

विशेष रूप से, हम निम्नलिखित तीन परिणामों का उपयोग करेंगे, उसका (1), (3), और (5)। सबसे पहले, निम्नलिखित को परिभाषित करें:

qx=ϕ(ax)qy=ϕ(ay)Qx=Φ(ax)Qy=Φ(ay)Rxy=Φ(ρaxay1ρ2)Ryx=Φ(ρayax1ρ2)rxy=1ρ22πϕ(h22ρhk+k21ρ2)

अब, रोसेनबौम से पता चलता है कि:

(1)Pr(V)E[X~V]=qxRxy+ρqyRyx(3)Pr(V)E[X~2V]=Pr(V)+axqxRxy+ρ2ayqyRyx+ρrxy(5)Pr(V)E[X~Y~V]=ρPr(V)+ρaxqxRxy+ρayqyRyx+rxy.

(1) और (3) के विशेष मामले पर विचार करना भी उपयोगी होगा ay=, यानी 1 डी ट्रंकेशन:

(*)Pr(V)E[X~V]=qx(**)Pr(V)E[X~2V]=Pr(V)=Qx.

हम अब विचार करना चाहते हैं

[XY]=[μxμy]+[σx00σy][X~Y~]N([μXμY],[σx2ρσxσyρσxσyσy2])=N(μ,Σ).

हम इस्तेमाल करेंगे

ax=μxσxay=μyσy,
जिसके मूल्य हैं X~ तथा Y~ कब X=0, Y=0

अब, (*) का उपयोग करते हुए, हम प्राप्त करते हैं

E[X+]=Pr(X+>0)E[XX>0]+Pr(X+=0)0=Pr(X>0)(μx+σxE[X~X~ax])=Qxμx+qxσx,
और (*) और (**) दोनों पैदावार का उपयोग करके
E[X+2]=Pr(X+>0)E[X2X>0]+Pr(X+=0)0=Pr(X~ax)E[(μx+σxX~)2X~ax]=Pr(X~ax)E[μx2+μxσxX~+σx2X~2X~ax]=Qxμx2+qxμxσx+Qxσx2
so that
Var[X+]=E[X+2]E[X+]2=Qxμx2+qxμxσx+Qxσx2Qx2μx2qx2σx22qxQxμxσx=Qx(1Qx)μx2+(12Qx)qxμxσx+(Qxqx2)σx2.

To find Cov(X+,Y+), we will need

E[X+Y+]=Pr(V)E[XYV]+Pr(¬V)0=Pr(V)E[(μx+σxX~)(μy+σyY~)V]=μxμyPr(V)+μyσxPr(V)E[X~V]+μxσyPr(V)E[Y~V]+σxσyPr(V)E[X~Y~V]=μxμyPr(V)+μyσx(qxRxy+ρqyRyx)+μxσy(ρqxRxy+qyRyx)+σxσy(ρPr(V)ρμxqxRxy/σxρμyqyRyx/σy+rxy)=(μxμy+σxσyρ)Pr(V)+(μyσx+μxσyρρμxσy)qxRxy+(μyσxρ+μxσyρμyσx)qyRyx+σxσyrxy=(μxμy+Σxy)Pr(V)+μyσxqxRxy+μxσyqyRyx+σxσyrxy,
and then subtracting E[X+]E[Y+] we get
Cov(X+,Y+)=(μxμy+Σxy)Pr(V)+μyσxqxRxy+μxσyqyRyx+σxσyrxy(Qxμx+qxσx)(Qyμy+qyσy).

Here's some Python code to compute the moments:

import numpy as np
from scipy import stats

def relu_mvn_mean_cov(mu, Sigma):
    mu = np.asarray(mu, dtype=float)
    Sigma = np.asarray(Sigma, dtype=float)
    d, = mu.shape
    assert Sigma.shape == (d, d)

    x = (slice(None), np.newaxis)
    y = (np.newaxis, slice(None))

    sigma2s = np.diagonal(Sigma)
    sigmas = np.sqrt(sigma2s)
    rhos = Sigma / sigmas[x] / sigmas[y]

    prob = np.empty((d, d))  # prob[i, j] = Pr(X_i > 0, X_j > 0)
    zero = np.zeros(d)
    for i in range(d):
        prob[i, i] = np.nan
        for j in range(i + 1, d):
            # Pr(X > 0) = Pr(-X < 0); X ~ N(mu, S) => -X ~ N(-mu, S)
            s = [i, j]
            prob[i, j] = prob[j, i] = stats.multivariate_normal.cdf(
                zero[s], mean=-mu[s], cov=Sigma[np.ix_(s, s)])

    mu_sigs = mu / sigmas

    Q = stats.norm.cdf(mu_sigs)
    q = stats.norm.pdf(mu_sigs)
    mean = Q * mu + q * sigmas

    # rho_cs is sqrt(1 - rhos**2); but don't calculate diagonal, because
    # it'll just be zero and we're dividing by it (but not using result)
    # use inf instead of nan; stats.norm.cdf doesn't like nan inputs
    rho_cs = 1 - rhos**2
    np.fill_diagonal(rho_cs, np.inf)
    np.sqrt(rho_cs, out=rho_cs)

    R = stats.norm.cdf((mu_sigs[y] - rhos * mu_sigs[x]) / rho_cs)

    mu_sigs_sq = mu_sigs ** 2
    r_num = mu_sigs_sq[x] + mu_sigs_sq[y] - 2 * rhos * mu_sigs[x] * mu_sigs[y]
    np.fill_diagonal(r_num, 1)  # don't want slightly negative numerator here
    r = rho_cs / np.sqrt(2 * np.pi) * stats.norm.pdf(np.sqrt(r_num) / rho_cs)

    bit = mu[y] * sigmas[x] * q[x] * R
    cov = (
        (mu[x] * mu[y] + Sigma) * prob
        + bit + bit.T
        + sigmas[x] * sigmas[y] * r
        - mean[x] * mean[y])

    cov[range(d), range(d)] = (
        Q * (1 - Q) * mu**2 + (1 - 2 * Q) * q * mu * sigmas
        + (Q - q**2) * sigma2s)

    return mean, cov

and a Monte Carlo test that it works:

np.random.seed(12)
d = 4
mu = np.random.randn(d)
L = np.random.randn(d, d)
Sigma = L.T.dot(L)
dist = stats.multivariate_normal(mu, Sigma)

mn, cov = relu_mvn_mean_cov(mu, Sigma)

samps = dist.rvs(10**7)
mn_est = samps.mean(axis=0)
cov_est = np.cov(samps, rowvar=False)
print(np.max(np.abs(mn - mn_est)), np.max(np.abs(cov - cov_est)))

which gives 0.000572145310512 0.00298692620286, indicating that the claimed expectation and covariance match Monte Carlo estimates (based on 10,000,000 samples).


can you summarize what those final values are? Are they estimates of the parameters mu and L you generated? Maybe print those target values?
AdamO

No, the return values are \E(Z+) and \Cov(Z+); what I printed was the L distance between Monte Carlo estimators of those quantities and the computed value. You could maybe invert these expressions to get a moment-matching estimator for μ and Σ – Rosenbaum actually does that in his section 3 in the truncated case – but that's not what I wanted here.
Dougal
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.