La versione sintetizzata della mia domanda
(26 dicembre 2018)
Sto cercando di riprodurre Figura 2.2 dal computer Età Statistical Inference da Efron e Hastie, ma per qualche motivo che io non sono in grado di capire, i numeri non sono corrispondenti a quelli del libro.
Supponiamo che stiamo cercando di decidere tra due possibili funzioni di densità di probabilità per i dati osservati , una densità di ipotesi nulla e una densità alternativa . Una regola di prova dice quale scelta, o , faremo osservare i dati . Ogni regola del genere ha due probabilità di errore frequentist associate: la scelta quando in realtà generato , e viceversa,
Permettere essere il rapporto di verosimiglianza ,
Quindi, il lemma di Neyman-Pearson afferma che la regola di prova del modulo è l'algoritmo di verifica delle ipotesi ottimale
Per e dimensione del campione quali sarebbero i valori per e per un taglio ?
- Dalla Figura 2.2 dell'Inferenza statistica sull'era dei computer di Efron e Hastie abbiamo:
- e per un taglio
- ho trovato e per un taglio usando due approcci diversi: A) simulazione e B) analiticamente .
Gradirei se qualcuno potesse spiegarmi come ottenere e per un taglio . Grazie.
La versione sintetizzata della mia domanda finisce qui. Da adesso troverai:
- Nella sezione A) dettagli e codice python completo del mio approccio di simulazione .
- Nella sezione B) dettagli e codice python completo dell'approccio analitico .
A) Il mio approccio alla simulazione con codice e spiegazioni complete di Python
(20 dicembre 2018)
Dal libro ...
Nello stesso spirito, il lemma di Neyman-Pearson fornisce un algoritmo di verifica delle ipotesi ottimale. Questa è forse la più elegante delle costruzioni frequentiste. Nella sua formulazione più semplice, il lemma NP presuppone che stiamo cercando di decidere tra due possibili funzioni di densità di probabilità per i dati osservati, una densità di ipotesi nulla e una densità alternativa . Una regola di prova dice quale scelta, o , faremo osservare i dati . Ogni regola del genere ha due probabilità di errore frequentist associate: la scelta quando in realtà generato , e viceversa,
Permettere essere il rapporto di verosimiglianza ,
(Fonte: Efron, B., & Hastie, T. (2016). Inferenza statistica sull'era dei computer: algoritmi, prove e scienza dei dati. Cambridge: Cambridge University Press. )
Quindi, ho implementato il codice Python di seguito ...
import numpy as np
def likelihood_ratio(x, f1_density, f0_density):
return np.prod(f1_density.pdf(x)) / np.prod(f0_density.pdf(x))
Ancora una volta, dal libro ...
e definire la regola di prova di
(Fonte: Efron, B., & Hastie, T. (2016). Inferenza statistica sull'era dei computer: algoritmi, prove e scienza dei dati. Cambridge: Cambridge University Press. )
Quindi, ho implementato il codice Python di seguito ...
def Neyman_Pearson_testing_rule(x, cutoff, f0_density, f1_density):
lr = likelihood_ratio(x, f1_density, f0_density)
llr = np.log(lr)
if llr >= cutoff:
return 1
else:
return 0
Finalmente, dal libro ...
Dove è possibile concludere che un taglio implicherà e .
Quindi, ho implementato il codice Python di seguito ...
def alpha_simulation(cutoff, f0_density, f1_density, sample_size, replicates):
NP_test_results = []
for _ in range(replicates):
x = f0_density.rvs(size=sample_size)
test = Neyman_Pearson_testing_rule(x, cutoff, f0_density, f1_density)
NP_test_results.append(test)
return np.sum(NP_test_results) / float(replicates)
def beta_simulation(cutoff, f0_density, f1_density, sample_size, replicates):
NP_test_results = []
for _ in range(replicates):
x = f1_density.rvs(size=sample_size)
test = Neyman_Pearson_testing_rule(x, cutoff, f0_density, f1_density)
NP_test_results.append(test)
return (replicates - np.sum(NP_test_results)) / float(replicates)
e il codice ...
from scipy import stats as st
f0_density = st.norm(loc=0, scale=1)
f1_density = st.norm(loc=0.5, scale=1)
sample_size = 10
replicates = 12000
cutoffs = []
alphas_simulated = []
betas_simulated = []
for cutoff in np.arange(3.2, -3.6, -0.4):
alpha_ = alpha_simulation(cutoff, f0_density, f1_density, sample_size, replicates)
beta_ = beta_simulation(cutoff, f0_density, f1_density, sample_size, replicates)
cutoffs.append(cutoff)
alphas_simulated.append(alpha_)
betas_simulated.append(beta_)
e il codice ...
import matplotlib.pyplot as plt
%matplotlib inline
# Reproducing Figure 2.2 from simulation results.
plt.xlabel('$\\alpha$')
plt.ylabel('$\\beta$')
plt.xlim(-0.1, 1.05)
plt.ylim(-0.1, 1.05)
plt.axvline(x=0, color='b', linestyle='--')
plt.axvline(x=1, color='b', linestyle='--')
plt.axhline(y=0, color='b', linestyle='--')
plt.axhline(y=1, color='b', linestyle='--')
figure_2_2 = plt.plot(alphas_simulated, betas_simulated, 'ro', alphas_simulated, betas_simulated, 'k-')
per ottenere qualcosa del genere:
sembra simile alla figura originale del libro, ma le 3 tuple dalla mia simulazione ha valori diversi di e rispetto a quelli del libro per lo stesso valore soglia . Per esempio:
- dal libro che abbiamo
- dalla mia simulazione abbiamo:
Sembra che il taglio dalla mia simulazione è equivalente al cutoff dal libro.
Gradirei se qualcuno potesse spiegarmi cosa sto facendo di sbagliato qui. Grazie.
B) Il mio approccio di calcolo con codice e spiegazioni complete di Python
(26 dicembre 2018)
Ancora cercando di capire la differenza tra i risultati della mia simulazione ( alpha_simulation(.), beta_simulation(.)
) e quelli presentati nel libro, con l'aiuto di un mio statistico (Sofia) amico, abbiamo calcolato e analiticamente invece che tramite simulazione, quindi ...
Una volta quello
poi
Inoltre,
così,
Pertanto, eseguendo alcune semplificazioni algebriche (come sotto), avremo:
Quindi se
quindi, per avremo:
con il risultato di
Per calcolare e , lo sappiamo:
così,
Per ...
così, ho implementato il codice Python di seguito:
def alpha_calculation(cutoff, m_0, m_1, variance, sample_size):
c = cutoff
n = sample_size
sigma = np.sqrt(variance)
k = (c*variance)/(n*(m_1-m_0)) + (m_1+m_0)/2.0
z_alpha = (k-m_0)/(sigma/np.sqrt(n))
# Pr{z_score >= z_alpha}
return 1.0 - st.norm(loc=0, scale=1).cdf(z_alpha)
Per ...
risultante nel codice Python di seguito:
def beta_calculation(cutoff, m_0, m_1, variance, sample_size):
c = cutoff
n = sample_size
sigma = np.sqrt(variance)
k = (c*variance)/(n*(m_1-m_0)) + (m_1+m_0)/2.0
z_beta = (k-m_1)/(sigma/np.sqrt(n))
# Pr{z_score < z_beta}
return st.norm(loc=0, scale=1).cdf(z_beta)
e il codice ...
alphas_calculated = []
betas_calculated = []
for cutoff in cutoffs:
alpha_ = alpha_calculation(cutoff, 0.0, 0.5, 1.0, sample_size)
beta_ = beta_calculation(cutoff, 0.0, 0.5, 1.0, sample_size)
alphas_calculated.append(alpha_)
betas_calculated.append(beta_)
e il codice ...
# Reproducing Figure 2.2 from calculation results.
plt.xlabel('$\\alpha$')
plt.ylabel('$\\beta$')
plt.xlim(-0.1, 1.05)
plt.ylim(-0.1, 1.05)
plt.axvline(x=0, color='b', linestyle='--')
plt.axvline(x=1, color='b', linestyle='--')
plt.axhline(y=0, color='b', linestyle='--')
plt.axhline(y=1, color='b', linestyle='--')
figure_2_2 = plt.plot(alphas_calculated, betas_calculated, 'ro', alphas_calculated, betas_calculated, 'k-')
per ottenere una cifra e valori per e molto simile alla mia prima simulazione
E infine per confrontare i risultati tra simulazione e calcolo fianco a fianco ...
df = pd.DataFrame({
'cutoff': np.round(cutoffs, decimals=2),
'simulated alpha': np.round(alphas_simulated, decimals=2),
'simulated beta': np.round(betas_simulated, decimals=2),
'calculated alpha': np.round(alphas_calculated, decimals=2),
'calculate beta': np.round(betas_calculated, decimals=2)
})
df
con il risultato di
Ciò dimostra che i risultati della simulazione sono molto simili (se non uguali) a quelli dell'approccio analitico.
In breve, ho ancora bisogno di aiuto per capire cosa potrebbe essere sbagliato nei miei calcoli. Grazie. :)