小编JJL*_*JJL的帖子

我有一些代码可以计算一个矩阵中每个笛卡尔坐标与另一个矩阵中其他坐标之间的距离。对于每个坐标，将返回最小距离以及产生最小坐标的索引位置。

function MED3D(m1, m2)
    n1::Int = size(m1,1)
    Dist = SharedArray{Float64}((n1,3))
    @sync @distributed for k in 1:n1
        Dist[k,:] = MD3D(m1[k,:], m2, k)
    end
    return Dist
end

@everywhere function MD3D(v1, m2, k)
    dsum::Float64 = Inf
    dtemp::Float64 = Inf
    i = 0
    for j in 1:size(m2,1)
        @inbounds dtemp = sqrt((v1[1] - m2[j,1]) * (v1[1] - m2[j,1]) + (v1[2] - m2[j,2]) * (v1[2] - m2[j,2]) + (v1[3] - m2[j,3]) * (v1[3] - m2[j,3]))
        if dtemp < dsum
            dsum = dtemp
            i = j
        end …

我遇到的问题是我必须计算形状之间的欧几里德距离矩阵,其范围从20,000到60,000点,产生10-20GB的数据量.我必须运行这些计算中的每一个数千次,所以20GB x 7,000(每个计算是一个不同的点云).形状可以是2D或3D.

已编辑(更新的问题)

1. 是否有更有效的方法来计算前向和后向距离而不使用两个单独的嵌套循环？

   我知道我可以保存数据矩阵并计算每个方向的最小距离,但是大点云存在巨大的内存问题.

2. 有没有办法加快计算速度和/或清理代码以缩短时间？

具有讽刺意味的是,我只需要矩阵来计算一个非常简单的度量,但它需要整个矩阵才能找到该度量(Average Hausdorff distance).

数据示例,其中每列表示形状的尺寸,每行是形状中的一个点:

first_configuration <- matrix(1:6,2,3)
second_configuration <- matrix(6:11,2,3)
colnames(first_configuration) <- c("x","y","z")
colnames(second_configuration) <- c("x","y","z")

此代码计算坐标之间的欧几里德距离:

m <- nrow(first_configuration)
n <- nrow(second_configuration)

D <- sqrt(pmax(matrix(rep(apply(first_configuration * first_configuration, 1, sum), n), m, n, byrow = F) + matrix(rep(apply(second_configuration * second_configuration, 1, sum), m), m, n, byrow = T) - 2 * first_configuration %*% t(second_configuration), 0))
D

输出:

     [,1]      [,2]
[1,] 8.660254 10.392305
[2,] 6.928203  8.660254

编辑:包括hausdorff平均代码

d1 <- mean(apply(D, 1, min))
d2 <- …

我正在使用两个data.frames列表,目前运行类似于此的东西(我正在做的简化版本):

df1 <- data.frame("a","a1","L","R","b","c",1,2,3,4)
df2 <- data.frame("a","a1","L","R","b","c",4,4,4,4,4,44)
df3 <- data.frame(7,7,7,7)    
df4 <- data.frame(5,5,5,5,9,9)    

L1 <- list(df1,df2)
L2 <- list(df3,df4)

myfun <- function(x,y) {
    difa = rowSums(abs(x[c(T,F)] - x[c(F,T)]))
    difb=sum(abs(as.numeric(y[-c(1:6)])[c(T,F)] - as.numeric(y[-c(1:6)])[c(F,T)])) 
    diff <- difa + difb
    return(diff)
}
output1 <- mapply(myfun, x = L2, y = L1)

每个列表中的数据帧数相同,一个列表中的每个数据帧对应另一个列表中的数据帧.一个列表中的数据帧包含单个行,而第二个列表中的其他数据帧包含动态行数; 因此使用sum和rowSums.数字列的数量也是动态的,但在相应的数据帧之间始终相同.

我希望在处理每个列表1-10万个数据帧时使用并行处理来加速计算.我尝试了以下方法:

library(parallel)
if(detectCores() > 1) {no_cores <- detectCores() - 1}
if(.Platform$OS.type == "unix") {ptype <- "FORK"}
cl <- makeCluster(no_cores, type = ptype)
clusterMap(cl, myfun, x = L2, y = L1)
stopCluster(cl) …