Come trovare un intervallo di confidenza per il numero totale di eventi

Ho un rilevatore che rileverà un evento con una certa probabilità p . Se il rivelatore dice che si è verificato un evento, allora è sempre così, quindi non ci sono falsi positivi. Dopo averlo eseguito per qualche tempo, ricevo k eventi rilevati. Vorrei calcolare quale fosse il numero totale di eventi che si sono verificati, rilevati o meno, con una certa sicurezza, pari al 95%.

Ad esempio, supponiamo che vengano rilevati 13 eventi. Vorrei poter calcolare che ci sono stati tra 13 e 19 eventi con una sicurezza del 95% basata su p .

Ecco cosa ho provato finora:

La probabilità di rilevare k eventi se ci fossero n totali è:

binomial(n, k) * p^k * (1 - p)^(n - k)

La somma di quella sopra n da k all'infinito è:

1/p

Ciò significa che la probabilità che ci siano n eventi totali è:

f(n) = binomial(n, k) * p^(k + 1) * (1 - p)^(n - k)

Quindi, se voglio essere sicuro al 95%, dovrei trovare la prima somma parziale f(k) + f(k+1) + f(k+2) ... + f(k+m)che è almeno 0,95 e la risposta è [k, k+m]. È questo l'approccio corretto? C'è anche una formula chiusa per la risposta?

Vorrei scegliere di utilizzare la distribuzione binomiale negativa , che restituisce la probabilità che ci siano X fallimenti prima del successo k_th, quando la probabilità costante di un successo è p.

Usando un esempio

k=17 # number of successes
p=.6 # constant probability of success

la media e sd per i fallimenti sono date da

mean.X <- k*(1-p)/p
sd.X <- sqrt(k*(1-p)/p^2) 

La distribuzione degli errori X avrà approssimativamente quella forma

plot(dnbinom(0:(mean.X + 3 * sd.X),k,p),type='l')

Quindi, il numero di guasti sarà (con una sicurezza del 95%) approssimativamente tra

qnbinom(.025,k,p)
[1] 4

e

qnbinom(.975,k,p)
[1] 21

Quindi inervale sarebbe [k + qnbinom (.025, k, p), k + qnbinom (.975, k, p)] (usando i numeri dell'esempio [21,38])

Supponendo di voler scegliere una distribuzione per n, p (n), è possibile applicare la legge di Bayes.

Sai che la probabilità che si verifichino k eventi dato che n si sono effettivamente verificati è regolata da una distribuzione binomiale

$p(k|n) = {n \choose k} p^k (1-p)^{(n-k)}$

La cosa che vuoi veramente sapere è la probabilità che n si siano effettivamente verificati, dato che hai osservato k. Di Bayes laici:

$p(n|k) = \frac{p(k|n)p(n)}{p(k)}$

Applicando il teorema della probabilità totale, possiamo scrivere:

$p(n|k) = \frac{p(k|n)p(n)}{\sum_{n'} p(k|n')p(n')}$

Quindi, senza ulteriori informazioni, sulla distribuzione di si può davvero andare oltre.$p(n)$

Tuttavia, se vuoi scegliere una distribuzione per per la quale esiste un valore maggiore di quale , o sufficientemente vicino a zero, puoi fare un po 'meglio. Ad esempio, supponiamo che la distribuzione di sia uniforme nell'intervallo . questo caso:$p(n)$$n$$p(n) = 0$$n$$[0,n_{max}]$

$p(n) = \frac{1}{n_{max}}$

La formulazione bayesiana semplifica:

$p(n|k) = \frac{p(k|n)}{\sum_{n'} p(k|n')}$

Per quanto riguarda la parte finale del problema, concordo sul fatto che l'approccio migliore è eseguire una somma cumulativa su , generare la funzione di distribuzione della probabilità cumulativa e iterare fino al raggiungimento del limite di 0,95.$p(n|k)$

Dato che questa domanda è migrata da SO, il codice di esempio del giocattolo in Python è allegato di seguito

import numpy.random

p = 0.8
nmax = 200

def factorial(n):
    if n == 0:
        return 1
    return reduce( lambda a,b : a*b, xrange(1,n+1), 1 )

def ncr(n,r):
    return factorial(n) / (factorial(r) * factorial(n-r))

def binomProbability(n, k, p):
    p1 = ncr(n,k)
    p2 = p**k
    p3 = (1-p)**(n-k)
    return p1*p2*p3

def posterior( n, k, p ):
    def p_k_given_n( n, k ):
        return binomProbability(n, k, p)
    def p_n( n ):
        return 1./nmax
    def p_k( k ):
        return sum( [ p_n(nd)*p_k_given_n(nd,k) for nd in range(k,nmax) ] )
    return (p_k_given_n(n,k) * p_n(n)) / p_k(k)


observed_k   = 80
p_n_given_k  = [ posterior( n, observed_k, p ) for n in range(0,nmax) ]
cp_n_given_k = numpy.cumsum(p_n_given_k)
for n in xrange(0,nmax):
    print n, p_n_given_k[n], cp_n_given_k[n]

Se si misurano eventi e si conosce che l'efficienza di rilevamento è è possibile correggere automaticamente il risultato misurato fino al conteggio "vero" .$k$$p$$k_\mathrm{true} = k/p$

La tua domanda è quindi di trovare l'intervallo di dove cadrà il 95% delle osservazioni. È possibile utilizzare il metodo Feldman-Cousins per stimare questo intervallo. Se hai accesso a ROOT c'è una classe per fare questo calcolo per te.$k_\mathrm{true}$

Dovresti calcolare i limiti superiore e inferiore con Feldman-Cousins ​​dal numero non corretto di eventi e quindi ridimensionarli fino al 100% con . In questo modo il numero effettivo di misurazioni determina la tua incertezza, non un numero in scala che non è stato misurato.$k$$1/p$

{
gSystem->Load("libPhysics");

const double lvl = 0.95;
TFeldmanCousins f(lvl);

const double p = 0.95;
const double k = 13;
const double k_true = k/p;

const double k_bg = 0;

const double upper = f.CalculateUperLimit(k, k_bg) / p;
const double lower = f.GetLowerLimit() / p;

std::cout << "["
  lower <<"..."<<
  k_true <<"..."<<
  upper <<
  "]" << std::endl;
}

Penso che tu abbia frainteso lo scopo degli intervalli di confidenza. Gli intervalli di confidenza consentono di valutare dove si trova il vero valore del parametro. Quindi, nel tuo caso, puoi costruire un intervallo di confidenza per . Non ha senso costruire un intervallo per i dati.$p$

Detto questo, una volta che hai una stima di puoi calcolare la probabilità che osserverai diverse realizzazioni come 14, 15 ecc. Usando il pdf binomiale.$p$