Sử dụng lm để kiểm tra tỷ lệ 2 mẫu

Tôi đã sử dụng các mô hình tuyến tính để thực hiện các thử nghiệm tỷ lệ 2 mẫu trong một thời gian, nhưng đã nhận ra rằng có thể không hoàn toàn chính xác. Dường như việc sử dụng mô hình tuyến tính tổng quát với liên kết nhận dạng nhị phân + họ cho kết quả kiểm tra tỷ lệ 2 mẫu không chính xác. Tuy nhiên, sử dụng mô hình tuyến tính (hoặc glm với họ gaussian) cho kết quả hơi khác. Tôi hợp lý hóa rằng điều này có thể là do cách R giải quyết glm cho các gia đình nhị thức so với gaussian, nhưng có thể có một nguyên nhân nào khác không?

## prop.test gives pooled 2-sample proportion result
## glm w/ binomial family gives unpooled 2-sample proportion result
## lm and glm w/ gaussian family give unknown result

library(dplyr)
library(broom)
set.seed(12345)

## set up dataframe -------------------------
n_A <- 5000
n_B <- 5000

outcome <- rbinom(
  n = n_A + n_B,
  size = 1,
  prob = 0.5
)
treatment <- c(
  rep("A", n_A),
  rep("B", n_B)
)

df <- tbl_df(data.frame(outcome = outcome, treatment = treatment))


## by hand, 2-sample prop tests ---------------------------------------------
p_A <- sum(df$outcome[df$treatment == "A"])/n_A
p_B <- sum(df$outcome[df$treatment == "B"])/n_B

p_pooled <- sum(df$outcome)/(n_A + n_B)
z_pooled <- (p_B - p_A) / sqrt( p_pooled * (1 - p_pooled) * (1/n_A + 1/n_B) )
pvalue_pooled <- 2*(1-pnorm(abs(z_pooled)))

z_unpooled <- (p_B - p_A) / sqrt( (p_A * (1 - p_A))/n_A + (p_B * (1 - p_B))/n_B )
pvalue_unpooled <- 2*(1-pnorm(abs(z_unpooled)))


## using prop.test --------------------------------------
res_prop_test <- tidy(prop.test(
  x = c(sum(df$outcome[df$treatment == "A"]), 
        sum(df$outcome[df$treatment == "B"])),
  n = c(n_A, n_B),
  correct = FALSE
))
res_prop_test # same as pvalue_pooled
all.equal(res_prop_test$p.value, pvalue_pooled)
# [1] TRUE


# using glm with identity link -----------------------------------
res_glm_binomial <- df %>%
  do(tidy(glm(outcome ~ treatment, family = binomial(link = "identity")))) %>%
  filter(term == "treatmentB")
res_glm_binomial # same as p_unpooled
all.equal(res_glm_binomial$p.value, pvalue_unpooled)
# [1] TRUE


## glm and lm gaussian --------------------------------

res_glm <- df %>%
  do(tidy(glm(outcome ~ treatment))) %>%
  filter(term == "treatmentB")
res_glm 
all.equal(res_glm$p.value, pvalue_unpooled)
all.equal(res_glm$p.value, pvalue_pooled)

res_lm <- df %>%
  do(tidy(lm(outcome ~ treatment))) %>% 
  filter(term == "treatmentB")
res_lm
all.equal(res_lm$p.value, pvalue_unpooled)
all.equal(res_lm$p.value, pvalue_pooled)

all.equal(res_lm$p.value, res_glm$p.value)
# [1] TRUE

Nó không liên quan đến cách họ giải quyết các vấn đề tối ưu hóa tương ứng với việc phù hợp với các mô hình, nó liên quan đến các vấn đề tối ưu hóa thực tế mà các mô hình đặt ra.

Cụ thể, trong các mẫu lớn, bạn có thể xem xét nó một cách hiệu quả khi so sánh hai bài toán bình phương nhỏ nhất có trọng số

Mô hình tuyến tính ( lm) người ta giả định (khi không có trọng số) rằng phương sai của tỷ lệ là không đổi. Glm giả định rằng phương sai của tỷ lệ xuất phát từ giả định nhị thức$\text{Var}(\hat{p})=\text{Var}(X/n) = p(1-p)/n$. Điều này có trọng số các điểm dữ liệu khác nhau và do đó có các ước tính khác nhau * và phương sai khác nhau.

* ít nhất là trong một số tình huống, mặc dù không nhất thiết phải so sánh tỷ lệ

Về mặt tính toán, so sánh sai số chuẩn của hệ số xử lýB cho lm so với nhị thức glm. Bạn có công thức cho sai số chuẩn của hệ số xử lýB trong hệ số nhị phân (mẫu số của z_unpooled). Lỗi tiêu chuẩn của hệ số xử lýB trong lm chuẩn là (SE_lm):

    test = lm(outcome ~ treatment, data = df)
    treat_B =  as.numeric(df$treatment == "B")
    SE_lm = sqrt( sum(test$residuals^2)/(n_A+n_B-2) / 
              sum((treat_B - mean(treat_B))^2))

Xem bài đăng này để lấy đạo hàm, sự khác biệt duy nhất là ở đây tìm thấy lỗi mẫu thay vì$\sigma^2$ (tức là trừ 2 từ $n_A+n_B$cho mức độ tự do bị mất). Ngoài điều đó ra$-2$, các lỗi tiêu chuẩn glm và nhị thức thực sự có vẻ khớp với nhau khi $n_A = n_B$.