Question

我试图通过使用嵌套列表和嵌套循环将值与阈值进行比较。该列表包含一个个人列表，每个人都获得n次试验，其中（在每个试验中）他们从两个分布中获得两个值。然后使用Kullback-Leibler散度（KLD）组合这些值，这意味着每个试验现在都有一个单一值。目的是找出（对于每个人）这些值中有多少等于或超过阈值。

问题是结果不累加。当阈值达到compare_05时（根据我的计算），我应该得到很多1（在我的0.5中）。对我做错了什么建议？我对编码非常很陌生，所以代码可能看起来有些粗糙。

n = 10#trials
x = 5#people

p_sd = 1
s_sd = 0.5
KL_sd = 0.4472136

rand_values = list(1:2)
trials = list(rep(rand_values,n))
all_1 = rep(trials, x) #nested lists

for (i in 1:x){
  for (k in 1:n){
    for (m in 1:2){
      if (all_1[[i]][[k]][[m]]==1){
        all_1[[i]][[k]][[m]]=rnorm(1,0,2) #adding the random values
      } else {
        all_1[[i]][[k]][[m]]=rnorm(1,0,1)
      }
    }
  }
}

compare_05=numeric(x)
for (i in 1:x){
  for (k in 1:n){
    compare_05[i]=length(which(   #the next seven lines make up the KLD equation
      (log(p_sd/KL_sd) + (((KL_sd*KL_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                     (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
           (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*p_sd*p_sd))-0.5 
   +  
      log(KL_sd/p_sd) + (((p_sd*p_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
       (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*KL_sd*KL_sd))-0.5)
      >=0.5))/n 
  }
}

当我使用cohen d而不是KLD组合随机绘制的值时，我完成了这项工作。

all_2 = all_1
for (i in 1:x){
  for (k in 1:n){
    all_2[[i]][k]=sum(all_2[[i]][[k]][[1]]-all_2[[i]][[k]][[2]])
    all_2[[i]][k]=abs(all_2[[i]][[k]][[1]]/0.7905)
  }
}

compare_d_05 = numeric(x)
for (i in 1:x){
  compare_d_05[i]=length(which((as.numeric(all_2[[i]]))>=0.5))/n
}

科恩d（compare_d_05）的结果：

[1] 0.8 0.9 0.8 0.9 0.9

我不希望输出与这些数字相似（除非您将阈值提高到2.5或2.75），但我绝对不应该大量使用0.1（或{{1} }，如果您将0.01增加到100）。

Answer 1

定义compare_05[i]时，每个k都会被重新定义，因此您可以有效地进行以下操作

compare_05=numeric(x)
for (i in 1:x){
  for (k in n){#Only where k is n, not for other values of k
    compare_05[i]=length(which(   #the next seven lines make up the KLD equation
      (log(p_sd/KL_sd) + (((KL_sd*KL_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                     (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
           (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*p_sd*p_sd))-0.5 
   +  
      log(KL_sd/p_sd) + (((p_sd*p_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
       (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*KL_sd*KL_sd))-0.5)
      >=0.5))/n 
  }
}

cohen d不会发生这种情况，因为您仅在其中使用一个循环。如果我的理解正确，那么您想要的是以下内容：

kld<-function(k, i, all_1){
  length(
    which(
      (log(p_sd/KL_sd)+(((KL_sd*KL_sd)+(all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                                                                (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
                                                                (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*p_sd*p_sd))-0.5 
       +  
         log(KL_sd/p_sd) + (((p_sd*p_sd) + (all_1[[i]][[k]][[1]]-((s_sd*s_sd)/
                                                                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[1]] + (p_sd*p_sd)/
                                                                    (s_sd*s_sd+p_sd*p_sd)*all_1[[i]][[k]][[2]]))^2)/(2*KL_sd*KL_sd))-0.5
    )>=0.5))/n
}

compare_05=numeric(x)
for(i in 1:x){
  compare_05[i]<-sum(unlist(lapply(1:10, kld, i, all_1)))
}

一个更短的替代方法，而无需使用循环，将是：

compare_05<-unlist(lapply(1:x, function(a, b, all_1)
  sum(unlist(lapply(1:b, kld, a, all_1))), n, all_1))

将嵌套循环与嵌套列表一起使用

1 个答案: