子集非NA

时间:2016-04-06 23:18:16

标签: r matrix subset na

我有一个矩阵,其中每行至少有一个NA单元格,每列也至少有一个NA单元格。我需要的是找到不包含NA的矩阵的最大子集。

例如,对于此矩阵A

A <- 
  structure(c(NA, NA, NA, NA, 2L, NA,
              1L, 1L, 1L, 0L, NA, NA,
              1L, 8L, NA, 1L, 1L, NA, 
              NA, 1L, 1L, 6L, 1L, 3L, 
              NA, 1L, 5L, 1L, 1L, NA),
            .Dim = c(6L, 5L),
            .Dimnames = 
              list(paste0("R", 1:6),
                   paste0("C", 1:5)))

A
    C1  C2  C3  C4  C5
R1  NA  1   1   NA  NA
R2  NA  1   8   1   1
R3  NA  1   NA  1   5
R4  NA  0   1   6   1
R5  2   NA  1   1   1
R6  NA  NA  NA  3   NA

有两个解决方案(8个单元格):A[c(2, 4), 2:5]A[2:5, 4:5],但只找到一个有效的解决方案就足够了。我的实际矩阵的尺寸是77x132。

作为一个菜鸟,我认为没有明显的方法可以做到这一点。任何人都可以帮我一些想法吗?

2 个答案:

答案 0 :(得分:7)

1)优化在这种方法中,我们将问题放宽到我们用optim解决的持续优化问题。

目标函数是f,其输入是0-1向量,其第一个nrow(A)条目对应于行,其余条目对应于列。 f使用矩阵Ainf,该矩阵A派生自Ainf,用较大的负数代替NA,而用1代替非NAs。x负数为-x[seq(6)] %*% Ainf %*$ x[-seq(6)]x对应的行和列矩形中的元素数量为x,我们将其作为A的函数最小化,其中k的每个成分都位于0和0之间1.

虽然这是对原始问题的一种放宽,但仍然可以根据需要获得整数解决方案。

实际上下面的大多数代码只是为了得到起始值。为此,我们首先应用系列化。这会置换行和列,从而产生更多块状结构,然后在置换矩阵中找到最大的正方形子矩阵。

在问题中特定largestSquare的情况下,最大的矩形子矩阵恰好是正方形,并且起始值已经足够好以至于它们产生最优但我们将执行优化,因此它一般工作。如果您愿意,可以使用不同的起始值。例如,在largestSquare中将k从1更改为更高的数字,在这种情况下,k将返回k列,其中包含可用于optim的起始值library(seriation) # only used for starting values A.na <- is.na(A) + 0 Ainf <- ifelse(A.na, -prod(dim(A)), 1) # used by f nr <- nrow(A) # used by f f <- function(x) - c(x[seq(nr)] %*% Ainf %*% x[-seq(nr)]) # starting values # Input is a square matrix of zeros and ones. # Output is a matrix with k columns such that first column defines the # largest square submatrix of ones, second defines next largest and so on. # Based on algorithm given here: # http://www.geeksforgeeks.org/maximum-size-sub-matrix-with-all-1s-in-a-binary-matrix/ largestSquare <- function(M, k = 1) { nr <- nrow(M); nc <- ncol(M) S <- 0*M; S[1, ] <- M[1, ]; S[, 1] <- M[, 1] for(i in 2:nr) for(j in 2:nc) if (M[i, j] == 1) S[i, j] = min(S[i, j-1], S[i-1, j], S[i-1, j-1]) + 1 o <- head(order(-S), k) d <- data.frame(row = row(M)[o], col = col(M)[o], mx = S[o]) apply(d, 1, function(x) { dn <- dimnames(M[x[1] - 1:x[3] + 1, x[2] - 1:x[3] + 1]) out <- c(rownames(M) %in% dn[[1]], colnames(M) %in% dn[[2]]) + 0 setNames(out, unlist(dimnames(M))) }) } s <- seriate(A.na) p <- permute(A.na, s) # calcualte largest square submatrix in p of zeros rearranging to be in A's order st <- largestSquare(1-p)[unlist(dimnames(A)), 1] res <- optim(st, f, lower = 0*st, upper = st^0, method = "L-BFGS-B") > res $par R1 R2 R3 R4 R5 R6 C1 C2 C3 C4 C5 0 1 1 1 0 0 0 1 0 1 1 $value [1] -9 $counts function gradient 1 1 $convergence [1] 0 $message [1] "CONVERGENCE: NORM OF PROJECTED GRADIENT <= PGTOL" 的{​​{1}}运行效果最佳。

如果起始值足够好,那么这应该产生最佳值。

optim

,并提供:

GenSA

2)GenSA 另一种可能性是重复(1)但不使用par使用GenSA包中的f。它不需要起始值(虽然您可以使用nr参数提供起始值,这可能会在某些情况下改进解决方案)因此代码要短得多,但由于它使用模拟退火,因此可以预期运行时间长得多。使用{1}中的Ainf(以及f使用的library(GenSA) resSA <- GenSA(lower = rep(0, sum(dim(A))), upper = rep(1, sum(dim(A))), fn = f) > setNames(resSA$par, unlist(dimnames(A))) R1 R2 R3 R4 R5 R6 C1 C2 C3 C4 C5 0 1 1 1 0 0 0 1 0 1 1 > resSA$value [1] -9 来自(1)。下面我们尝试没有起始值。

validates :email, uniqueness: true

,并提供:

$breakpoints: (
  small: 0,
  medium: 640px,
  large: 1024px,
  xlarge: 1200px,
  xxlarge: 1440px,
);
$breakpoint-classes: (small medium large);

答案 1 :(得分:5)

我有一个解决方案,但它不能很好地扩展:

findBiggestSubmatrixNonContiguous <- function(A) {
    A <- !is.na(A); ## don't care about non-NAs
    howmany <- expand.grid(nr=seq_len(nrow(A)),nc=seq_len(ncol(A)));
    howmany <- howmany[order(apply(howmany,1L,prod),decreasing=T),];
    for (ri in seq_len(nrow(howmany))) {
        nr <- howmany$nr[ri];
        nc <- howmany$nc[ri];
        rcom <- combn(nrow(A),nr);
        ccom <- combn(ncol(A),nc);
        comcom <- expand.grid(ri=seq_len(ncol(rcom)),ci=seq_len(ncol(ccom)));
        for (comi in seq_len(nrow(comcom)))
            if (all(A[rcom[,comcom$ri[comi]],ccom[,comcom$ci[comi]]]))
                return(list(ri=rcom[,comcom$ri[comi]],ci=ccom[,comcom$ci[comi]]));
    }; ## end for
    NULL;
}; ## end findBiggestSubmatrixNonContiguous()

它的基础是,如果矩阵具有足够小的NA密度,那么通过首先搜索最大的子矩阵,您很可能会很快找到解决方案。

该算法的工作原理是计算行的所有计数的笛卡尔积和计数列,这些列可以从原始矩阵中索引以生成子矩阵。然后,这组计数对按子矩阵的大小递减排序,子矩阵将由每对计数产生;换句话说,按两个计数的乘积排序。然后迭代这些对。对于每对,它计算可以对该对计数采用的行索引和列索引的所有组合,并依次尝试每个组合,直到找到包含零个NA的子矩阵。找到这样的子矩阵后,它会将该组行和列索引作为列表返回。

结果保证是正确的,因为它以递减顺序尝试子矩阵大小,因此它找到的第一个必须是满足条件的最大(或最大)可能的子矩阵。

## OP's example matrix
A <- data.frame(C1=c(NA,NA,NA,NA,2L,NA),C2=c(1L,1L,1L,0L,NA,NA),C3=c(1L,8L,NA,1L,1L,NA),C4=c(NA,1L,1L,6L,1L,3L),C5=c(NA,1L,5L,1L,1L,NA),row.names=c('R1','R2','R3','R4','R5','R6'));
A;
##    C1 C2 C3 C4 C5
## R1 NA  1  1 NA NA
## R2 NA  1  8  1  1
## R3 NA  1 NA  1  5
## R4 NA  0  1  6  1
## R5  2 NA  1  1  1
## R6 NA NA NA  3 NA
system.time({ res <- findBiggestSubmatrixNonContiguous(A); });
##    user  system elapsed
##   0.094   0.000   0.100
res;
## $ri
## [1] 2 3 4
##
## $ci
## [1] 2 4 5
##
A[res$ri,res$ci];
##    C2 C4 C5
## R2  1  1  1
## R3  1  1  5
## R4  0  6  1

我们看到该函数在OP的示例矩阵中运行得非常快,并返回正确的结果。

randTest <- function(NR,NC,probNA,seed=1L) {
    set.seed(seed);
    A <- replicate(NC,sample(c(NA,0:9),NR,prob=c(probNA,rep((1-probNA)/10,10L)),replace=T));
    print(A);
    print(system.time({ res <- findBiggestSubmatrixNonContiguous(A); }));
    print(res);
    print(A[res$ri,res$ci,drop=F]);
    invisible(res);
}; ## end randTest()

我编写了上面的函数来简化测试。我们可以调用它来测试NR的大小为NC的随机输入矩阵,并且可以在probNA的任何给定单元格中选择NA。

以下是一些简单的测试:

randTest(8L,1L,1/3);
##      [,1]
## [1,]   NA
## [2,]    1
## [3,]    4
## [4,]    9
## [5,]   NA
## [6,]    9
## [7,]    0
## [8,]    5
##    user  system elapsed
##   0.016   0.000   0.003
## $ri
## [1] 2 3 4 6 7 8
##
## $ci
## [1] 1
##
##      [,1]
## [1,]    1
## [2,]    4
## [3,]    9
## [4,]    9
## [5,]    0
## [6,]    5
randTest(11L,3L,4/5);
##       [,1] [,2] [,3]
##  [1,]   NA   NA   NA
##  [2,]   NA   NA   NA
##  [3,]   NA   NA   NA
##  [4,]    2   NA   NA
##  [5,]   NA   NA   NA
##  [6,]    5   NA   NA
##  [7,]    8    0    4
##  [8,]   NA   NA   NA
##  [9,]   NA   NA   NA
## [10,]   NA    7   NA
## [11,]   NA   NA   NA
##    user  system elapsed
##   0.297   0.000   0.300
## $ri
## [1] 4 6 7
##
## $ci
## [1] 1
##
##      [,1]
## [1,]    2
## [2,]    5
## [3,]    8
randTest(10L,10L,1/3);
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]   NA   NA    0    3    8    3    9    1    6    NA
##  [2,]    1   NA   NA    4    5    8   NA    8    2    NA
##  [3,]    4    2    5    3    7    6    6    1    1     5
##  [4,]    9    1   NA   NA    4   NA   NA    1   NA     9
##  [5,]   NA    7   NA    8    3   NA    5    3    7     7
##  [6,]    9    3    1    2    7   NA   NA    9   NA     7
##  [7,]    0    2   NA    7   NA   NA    3    8    2     6
##  [8,]    5    0    1   NA    3    3    7    1   NA     6
##  [9,]    5    1    9    2    2    5   NA    7   NA     8
## [10,]   NA    7    1    6    2    6    9    0   NA     5
##    user  system elapsed
##   8.985   0.000   8.979
## $ri
## [1]  3  4  5  6  8  9 10
##
## $ci
## [1]  2  5  8 10
##
##      [,1] [,2] [,3] [,4]
## [1,]    2    7    1    5
## [2,]    1    4    1    9
## [3,]    7    3    3    7
## [4,]    3    7    9    7
## [5,]    0    3    1    6
## [6,]    1    2    7    8
## [7,]    7    2    0    5

我不知道一种简单的方法来验证上述结果是否正确,但对我来说这看起来不错。但是生成这个结果花了将近9秒钟。在中等大的矩阵上运行函数,特别是77x132矩阵,可能是一个失败的原因。

等待有人能想出一个出色的高效解决方案......