Quali sono la media e la varianza di un normale multivariato censurato 0?


9

Lascia che sia in . Quali sono la matrice media e di covarianza di (con il massimo calcolato elementalmente)?ZN(μ,Σ)RdZ+=max(0,Z)

Ciò si verifica ad esempio perché, se utilizziamo la funzione di attivazione ReLU all'interno di una rete profonda e supponiamo tramite il CLT che gli ingressi di un determinato livello siano approssimativamente normali, allora questa è la distribuzione delle uscite.

(Sono sicuro che molte persone l'hanno calcolato prima, ma non sono riuscito a trovare il risultato elencato da nessuna parte in modo ragionevolmente leggibile.)


Semplificherebbe la tua risposta - forse molto - per osservare che puoi ottenerla combinando i risultati di due domande separate: (1) quali sono i momenti di una distribuzione normale troncata e (2) quali sono i momenti di una miscela ? Quest'ultimo è semplice e tutto ciò che devi fare è citare i risultati per il primo.
whuber

@whuber Hmm. Anche se non l'ho detto esplicitamente, questo è essenzialmente ciò che faccio nella mia risposta, tranne per il fatto che non ho trovato risultati per una distribuzione troncata bivariata con una media e una varianza generali e quindi ho dovuto comunque fare un po 'di ridimensionamento e spostamento. C'è un modo per ricavare, ad esempio, la covarianza senza fare la quantità di algebra che ho dovuto fare? Non sto certo affermando che qualcosa in questa risposta sia nuovo, solo che l'algebra era noiosa e soggetta a errori, e forse qualcun altro troverà utile la soluzione.
Dougal,

Esatto: sono sicuro che la tua algebra equivale a ciò che ho descritto, quindi sembra che condividiamo un apprezzamento per la semplificazione dell'algebra sia possibile. Un modo semplice per ridurre l'algebra è standardizzare gli elementi diagonali di in unità, perché tutto ciò che fa è stabilire un'unità di misura per ogni variabile. A quel punto puoi collegare direttamente i risultati di Rosenbaum alle espressioni (semplici, ovvie) per i momenti di miscele. Se anche valga la pena semplificare algebricamente potrebbe essere una questione di gusti: senza semplificazione, porta a un semplice programma modulare per computer. Σ
whuber

1
Suppongo che uno potrebbe scrivere un programma che calcola i momenti direttamente con i risultati di Rosenbaum e mescolando in modo appropriato, quindi li sposta e li ridimensiona nello spazio originale. Probabilmente sarebbe stato più veloce di come l'ho fatto.
Dougal,

Risposte:


7

Possiamo prima ridurlo per dipendere solo da alcuni momenti di distribuzioni normali troncate univariate / bivariate: nota ovviamente che

E[Z+]=[E[(Zi)+]]iCov(Z+)=[Cov((Zi)+,(Zj)+)]ij,
e poiché stiamo realizzando trasformazioni coordinate di alcune dimensioni di una distribuzione normale, abbiamo solo è necessario preoccuparsi della media e della varianza di una normale censurata 1d e della covarianza di due normali censurate 1d.

Useremo alcuni risultati di

S Rosenbaum (1961). Momenti di una distribuzione normale bivariata troncata . JRSS B, vol 23 pp 405-408. ( jstor )

Rosenbaum considera e considera il troncamento all'evento .

[X~Y~]N([00],[1ρρ1]),
V={X~aX,Y~aY}

In particolare, utilizzeremo i seguenti tre risultati, i suoi (1), (3) e (5). Innanzitutto, definire quanto segue:

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

Ora, Rosenbaum mostra che:

(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.

Sarà utile considerare anche il caso speciale di (1) e (3) con , ovvero un troncamento 1d: ay=

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

Ora vogliamo considerare

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

Useremo che sono i valori di e quando , .

ax=μxσxay=μyσy,
X~Y~X=0Y=0

Ora, usando (*), otteniamo e utilizzando entrambi i rendimenti (*) e (**) modo che

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
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.

Per trovare , avremo bisogno Cov(X+,Y+)

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,
e quindi sottraendo otteniamo E[X+]E[Y+]
Cov(X+,Y+)=(μxμy+Σxy)Pr(V)+μyσxqxRxy+μxσyqyRyx+σxσyrxy(Qxμx+qxσx)(Qyμy+qyσy).

Ecco un po 'di codice Python per calcolare i momenti:

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

e un test Monte Carlo che funziona:

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)))

che dà 0.000572145310512 0.00298692620286, indicando che l'aspettativa e la covarianza richieste corrispondono alle stime di Monte Carlo (basate su campioni).10,000,000


puoi riassumere quali sono questi valori finali? Sono stime dei parametri mu e L che hai generato? Forse stampare quei valori target?
AdamO,

No, i valori di ritorno sono e ; ciò che ho stampato è stata la distanza tra gli stimatori Monte Carlo di tali quantità e il valore calcolato. Potresti forse invertire queste espressioni per ottenere uno stimatore del momento corrispondente per e - Rosenbaum lo fa nella sua sezione 3 nel caso troncato - ma non è quello che volevo qui. \E(Z+)\Cov(Z+)LμΣ
Dougal,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.