Cómo encontrar un intervalo de confianza para el número total de eventos

Tengo un detector que detectará un evento con cierta probabilidad p . Si el detector dice que ocurrió un evento, entonces ese es siempre el caso, por lo que no hay falsos positivos. Después de ejecutarlo durante algún tiempo, me detectan k eventos. Me gustaría calcular cuál fue el número total de eventos que ocurrieron, detectados o no, con cierta confianza, digamos 95%.

Entonces, por ejemplo, digamos que tengo 13 eventos detectados. Me gustaría poder calcular que hubo entre 13 y 19 eventos con un 95% de confianza basado en p .

Esto es lo que he probado hasta ahora:

La probabilidad de detectar k eventos si hubiera n total es:

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

La suma de eso sobre n desde k hasta el infinito es:

1/p

Lo que significa que la probabilidad de que haya n eventos totales es:

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

Entonces, si quiero estar 95% seguro, debería encontrar la primera suma parcial f(k) + f(k+1) + f(k+2) ... + f(k+m)que es al menos 0.95 y la respuesta es [k, k+m]. ¿Es este el enfoque correcto? ¿También hay una fórmula cerrada para la respuesta?

Elegiría usar la distribución binomial negativa , que devuelve la probabilidad de que haya X fallas antes del k_ésimo éxito, cuando la probabilidad constante de éxito es p.

Usando un ejemplo

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

la media y la desviación estándar para las fallas están dadas por

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

La distribución de las fallas X tendrá aproximadamente esa forma

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

Entonces, el número de fallas será (con un 95% de confianza) aproximadamente entre

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

y

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

Entonces, tu inerval sería [k + qnbinom (.025, k, p), k + qnbinom (.975, k, p)] (usando los números del ejemplo [21,38])

Suponiendo que desea elegir una distribución para n, p (n), puede aplicar la ley de Bayes.

Usted sabe que la probabilidad de que ocurran k eventos dado que n realmente ha ocurrido se rige por una distribución binomial

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

Lo que realmente quiere saber es la probabilidad de que se hayan producido n eventos, dado que observó k. Por Bayes Lay:

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

Al aplicar el teorema de probabilidad total, podemos escribir:

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

Entonces, sin más información, sobre la distribución de , realmente no puede ir más allá.$p(n)$

Sin embargo, si desea elegir una distribución para para la cual haya un valor mayor que , o lo suficientemente cerca de cero, puede hacerlo un poco mejor. Por ejemplo, suponga que la distribución de es uniforme en el rango . este caso:$p(n)$$n$$p(n) = 0$$n$$[0,n_{max}]$

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

La formulación bayesiana se simplifica a:

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

En cuanto a la parte final del problema, estoy de acuerdo en que el mejor enfoque es realizar una suma acumulativa sobre , generar la función de distribución de probabilidad acumulativa e iterar hasta alcanzar el límite de 0.95.$p(n|k)$

Dado que esta pregunta migró de SO, el código de muestra de juguete en python se adjunta a continuación

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]

Si mide eventos y sabe que su eficiencia de detección es , puede corregir automáticamente el resultado medido hasta el recuento "verdadero" .$k$$p$$k_\mathrm{true} = k/p$

Su pregunta es entonces acerca de encontrar el rango de donde caerá el 95% de las observaciones. Puedes usar el método Feldman-Cousins para estimar este intervalo. Si tiene acceso a ROOT, hay una clase para hacer este cálculo por usted.$k_\mathrm{true}$

Calcularía los límites superior e inferior con Feldman-Cousins ​​a partir del número no corregido de eventos y luego los escalaría hasta el 100% con . De esta manera, el número real de mediciones determina su incertidumbre, no un número escalado que no se midió.$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;
}

Creo que entendiste mal el propósito de los intervalos de confianza. Los intervalos de confianza le permiten evaluar dónde se encuentra el verdadero valor del parámetro. Entonces, en su caso, puede construir un intervalo de confianza para . No tiene sentido construir un intervalo para los datos.$p$

Dicho esto, una vez que tenga una estimación de , puede calcular la probabilidad de observar diferentes realizaciones, como 14, 15, etc. utilizando el binomial pdf.$p$