So finden Sie ein Konfidenzintervall für die Gesamtzahl der Ereignisse

Ich habe einen Detektor, der ein Ereignis mit einer gewissen Wahrscheinlichkeit p erkennt . Wenn der Detektor angibt, dass ein Ereignis aufgetreten ist, ist dies immer der Fall, sodass keine Fehlalarme vorliegen. Nachdem ich es einige Zeit ausgeführt habe, werden k Ereignisse erkannt. Ich möchte berechnen, wie viele Ereignisse insgesamt aufgetreten sind, erkannt oder auf andere Weise, mit einer gewissen Sicherheit, beispielsweise 95%.

Nehmen wir zum Beispiel an, ich bekomme 13 Ereignisse erkannt. Ich möchte berechnen können, dass es zwischen 13 und 19 Ereignisse mit 95% igem Vertrauen gab, basierend auf p .

Folgendes habe ich bisher versucht:

Die Wahrscheinlichkeit, k Ereignisse zu erkennen, wenn es insgesamt n gibt, ist:

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

Die Summe von n über k von k bis unendlich ist:

1/p

Dies bedeutet, dass die Wahrscheinlichkeit, dass insgesamt n Ereignisse vorliegen, wie folgt ist:

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

Wenn ich also zu 95% sicher sein möchte, sollte ich die erste Teilsumme finden, die f(k) + f(k+1) + f(k+2) ... + f(k+m)mindestens 0,95 beträgt, und die Antwort lautet [k, k+m]. Ist das der richtige Ansatz? Gibt es auch eine geschlossene Formel für die Antwort?

Ich würde die negative Binomialverteilung verwenden , die die Wahrscheinlichkeit zurückgibt, dass es vor dem k_-ten Erfolg X Fehler geben wird, wenn die konstante Wahrscheinlichkeit eines Erfolgs p ist.

An einem Beispiel

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

Der Mittelwert und die SD für die Fehler sind gegeben durch

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

Die Verteilung der Fehler X hat ungefähr diese Form

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

Die Anzahl der Fehler liegt also (mit 95% iger Sicherheit) ungefähr zwischen

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

und

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

Sie wären also [k + qnbinom (.025, k, p), k + qnbinom (.975, k, p)] (unter Verwendung der Zahlen des Beispiels [21,38]).

Angenommen, Sie möchten eine Verteilung für n, p (n) auswählen, können Sie das Bayes-Gesetz anwenden.

Sie wissen, dass die Wahrscheinlichkeit, dass k Ereignisse auftreten, wenn n tatsächlich aufgetreten ist, durch eine Binomialverteilung bestimmt wird

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

Was Sie wirklich wissen möchten, ist die Wahrscheinlichkeit, dass n Ereignisse tatsächlich aufgetreten sind, vorausgesetzt, Sie haben k beobachtet. Bei Bayes lag:

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

Durch Anwendung des Satzes der Gesamtwahrscheinlichkeit können wir schreiben:

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

Ohne weitere Informationen über die Verteilung von kann man also nicht wirklich weiter gehen.$p(n)$

Wenn Sie jedoch eine Verteilung für auswählen möchten, für die es einen Wert größer als ist oder ausreichend nahe bei Null liegt, können Sie dies etwas besser machen. Angenommen, die Verteilung von ist im Bereich gleichmäßig . dieser Fall:$p(n)$$n$$p(n) = 0$$n$$[0,n_{max}]$

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

Die Bayes'sche Formulierung vereinfacht sich zu:

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

Was den letzten Teil des Problems betrifft, stimme ich zu, dass der beste Ansatz darin besteht, eine kumulative Summierung über durchzuführen, die kumulative Wahrscheinlichkeitsverteilungsfunktion zu erzeugen und zu iterieren, bis die Grenze von 0,95 erreicht ist.$p(n|k)$

Da diese Frage von SO migriert wurde, wird unten ein Beispielcode für Spielzeug in Python angehängt

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]

Wenn Sie Ereignisse messen und wissen, dass Ihre Erkennungseffizienz , können Sie Ihr gemessenes Ergebnis automatisch bis zur "wahren" Anzahl korrigieren .$k$$p$$k_\mathrm{true} = k/p$

Ihre Frage ist dann, den Bereich von in den 95% der Beobachtungen fallen werden. Sie können die Feldman-Cousins-Methode verwenden , um dieses Intervall zu schätzen. Wenn Sie Zugriff auf ROOT haben, gibt es eine Klasse, die diese Berechnung für Sie durchführt.$k_\mathrm{true}$

Sie würden die oberen und unteren Grenzen mit Feldman-Cousins ​​aus der unkorrigierten Anzahl von Ereignissen berechnen und sie dann mit auf 100% skalieren . Auf diese Weise bestimmt die tatsächliche Anzahl der Messungen Ihre Unsicherheit, nicht irgendeine skalierte Zahl, die nicht gemessen wurde.$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;
}

Ich denke, Sie haben den Zweck von Konfidenzintervallen falsch verstanden. Mithilfe von Konfidenzintervallen können Sie beurteilen, wo sich der wahre Wert des Parameters befindet. In Ihrem Fall können Sie also ein Konfidenzintervall für . Es ist nicht sinnvoll, ein Intervall für die Daten zu erstellen.$p$

Wenn Sie jedoch eine Schätzung von , können Sie die Wahrscheinlichkeit berechnen, dass Sie verschiedene Realisierungen wie 14, 15 usw. mithilfe des Binomial-PDFs beobachten.$p$