The `table`

command is great in its simplicity for cross tabulations. I have run into some settings where it is slow and I wanted to demonstrate one simple example here of why you may want to use other functions or write your own tabler. This example is a specific case where, for some examples and functions, you don't need all the good error-checking or flexibility that a function contains, but you want to do something specific and can greatly speed up computation.

## Setup of example

I have some brain imaging data. I have a gold standard, where an expert hand-traced (on a computer) a brain scan delineating the brain. I'll refer to this as a brain “mask”. (We use the word mask in imaging to denote a segmented image – either done manually or automatically and I generally reserve the word mask for binary 0/1 values, but others use the term more broadly.)

Using automated methods, I can try to re-create this mask automatically. This image is also binary. I want to simply get a \(2\times2\) contingency table of the automated versus manual masks so I can get sensitivity/specificity/accuracy/etc.

## The data

For simplicity and computation, let's consider the images as just a really long vectors. I'll call them `manual`

and `auto`

for the manual and automatic masks, respectively.

These are long logical vectors (9 million elements):

length(manual)

[1] 9175040

length(auto)

[1] 9175040

head(manual)

[1] FALSE FALSE FALSE FALSE FALSE FALSE

head(auto)

[1] FALSE FALSE FALSE FALSE FALSE FALSE

Naturally, you can run `table`

on this data:

stime = system.time({ tab = table(manual, auto) }) print(stime)

user system elapsed 3.294 0.082 3.386

print(tab)

auto manual FALSE TRUE FALSE 7941541 11953 TRUE 15384 1206162

The computation took about 3.4 seconds on my MacBook Pro (2013, 16Gb RAM, 2.8GHz Intel i7), which isn't that bad. Realize, though, that I could have hundreds or thousands of these images. We need to speed this up.

## What is the essense of what we're doing?

Taking 3.4 seconds to get 4 numbers seems a bit long. As the data is binary, we can simply compute these with the `sum`

command and logical operators.

Let's make the `twoXtwo`

command:

twoXtwo = function(x, y, dnames=c("x", "y")){ tt <- sum( x & y) tf <- sum( x & !y) ft <- sum(!x & y) ff <- sum(!x & !y) tab = matrix(c(ff, tf, ft, tt), ncol=2) n = list(c("FALSE", "TRUE"), c("FALSE", "TRUE")) names(n) = dnames dimnames(tab) = n tab = as.table(tab) dim tab }

And let's see how fast this is (and confirm the result is the same):

stime2 = system.time({ twotab = twoXtwo(manual, auto, dnames=c("manual", "auto")) }) print(stime2)

user system elapsed 0.828 0.006 0.835

print(twotab)

auto manual FALSE TRUE FALSE 7941541 11953 TRUE 15384 1206162

identical(tab, twotab)

[1] TRUE

Viola, `twoXtwo`

runs about 4.06 times faster than `table`

, largely because we knew we did not have to check certain characteristics of the data and that it's a specific example of a table.

### More speed captain!

This isn't something astronomical such as a 100-fold increase, but we can increase the speed by not doing all the logical operations on the vectors, but taking differences from the margin sums.

Let's confirm this is faster and accurate by running it on our data:

stime3 = system.time({ twotab2 = twoXtwo2(manual, auto, dnames=c("manual", "auto")) }) print(stime3)

user system elapsed 0.198 0.001 0.200

print(twotab2)

auto manual FALSE TRUE FALSE 7941541 11953 TRUE 15384 1206162

identical(tab, twotab2)

[1] TRUE

Now, if I were going for speed, this code is good enough for me: it runs about 16.93 times faster than `table`

. The one downside is that it is not as readable as `twoXtwo`

. For even greater speed, I could probably move into C++ using the `Rcpp`

package, but that seems overkill for a two by two table.

Other examples of speeding up the calculation can be found here.

## Finishing up

I said I wanted sensitivity/specificity/accuracy/etc. so I will show how to get these. I'm going to use `prop.table`

, which I didn't know about for a while when I first started using R (see `margin.table`

too).

ptab = prop.table(twotab) rowtab = prop.table(twotab, margin=1) coltab = prop.table(twotab, margin=2)

As you can see, like the `apply`

command, the `prop.table`

command can either take no margin or take the dimension to divide over (1 for rows, 2 for columns). This means that in `ptab`

, each cell of `twotab`

was divided by the grand total (or `sum(tab)`

). For `rowtab`

, each cell was divided by the `rowSums(tab)`

to get a proportion, and similarly cells in `coltab`

were divided by `colSums(tab)`

. After the end of the post, I can show you these are the same.

### Getting Performance Measures

#### Accuracy

Getting the accuracy is very easy:

accur = sum(diag(ptab)) print(accur)

[1] 0.997

#### Sensitivity/Specificity

For sensitivity/specificity, the “truth” is the rows of the table, so we want the row percentages:

sens = rowtab["TRUE", "TRUE"] spec = rowtab["FALSE", "FALSE"] print(sens)

[1] 0.9874

print(spec)

[1] 0.9985

#### Positive/Negative Predictive Value

We can also get the positive predictive value (PPV) and negative predictive value (NPV) from the column percentages:

ppv = coltab["TRUE", "TRUE"] npv = coltab["FALSE", "FALSE"] print(ppv)

[1] 0.9902

print(npv)

[1] 0.9981

## Conclusions

After using R for years, I find things to still be very intuitive. Sometimes, though, for large data sets or specific examples, you may want to write your own function for speed, checking against the base functions for a few iterations as a double-check. I have heard this to be a nuisance for those who dislike R, as well as hampering reproducibility in some cases. Overall, I find that someone has made a vetted package that does what you want, but there are still simple cases (such as above) where “rolling your own” is OK and easier than adding a dependency to your code.

## Aside: How prop.table works

### Over all margins

For just doing `prop.table`

without a margin, you can think of the table being divided by its sum.

print(round(ptab, 3))

auto manual FALSE TRUE FALSE 0.866 0.001 TRUE 0.002 0.131

print(round(twotab / sum(twotab), 3))

auto manual FALSE TRUE FALSE 0.866 0.001 TRUE 0.002 0.131

### Over row margins

For the `margin=1`

, or row percentages, you can think of dividing the table by the row sums.

print(round(rowtab, 3))

auto manual FALSE TRUE FALSE 0.998 0.002 TRUE 0.013 0.987

print(round(twotab / rowSums(twotab), 3))

auto manual FALSE TRUE FALSE 0.998 0.002 TRUE 0.013 0.987

### Over column margins

Now for column percentages, you can think of R dividing each cell by its column's sum. This is what `prop.table`

does.

Let's look at the result we should get:

print(round(coltab, 3))

auto manual FALSE TRUE FALSE 0.998 0.010 TRUE 0.002 0.990

But in R, when you take a matrix and then add/divide/subtract/multiply it by a vector, R does the operation column-wise. So when you take column sums on the table, you get a vector with the same number of columns as the table:

print(colSums(twotab))

FALSE TRUE 7956925 1218115

If you try to divide the table by this value, it will not give you the desired result:

print(round( twotab / colSums(twotab), 3))

auto manual FALSE TRUE FALSE 0.998 0.002 TRUE 0.013 0.990

#### R operations with matrices and vectors

This is because R thinks of a vector as a column vector (or a matrix of 1 column). R then takes the first column of the table and divides the first element from the first column sum (which is correct), but take the second element of the first column and divides it by the second column sum (which is not correct).

A detailed discussion on SO is located here of how to do row-wise operations on matrices.

### Back to column percentages

We can use the `t( t() )`

operation to get the correct answer:

print(round( t( t(twotab) / colSums(twotab)), 3))

auto manual FALSE TRUE FALSE 0.998 0.010 TRUE 0.002 0.990

You can think of R implicitly making the matrix of the correct size with the correct values and then dividing:

cs = colSums(twotab) cs = matrix(cs, nrow=nrow(tab), ncol=ncol(tab), byrow=TRUE) print(cs)

[,1] [,2] [1,] 7956925 1218115 [2,] 7956925 1218115

print(round( twotab/cs, 3))

auto manual FALSE TRUE FALSE 0.998 0.010 TRUE 0.002 0.990

Happy tabling!

Perhaps this simple table would work even faster:

basictab = function(x, y) {

diff = x – y

tf = sum(diff > 0)

ft = sum(diff < 0)

tt = crossprod(x, y)

ff = length(diff) – tt – tf – ft

return(c(tf, ft, tt, ff))

}

I couldn’t edit the comment, but it would be a good idea to change the name from diff to something else instead, avoiding overriding the diff function.

et Voilà !

How about using tabulate:

twoXtwo3 <- function(x, y, dnames=c("x", "y")){

tab = matrix(tabulate(1L+x+2L*y,4L), ncol=2)

n = list(c("FALSE", "TRUE"), c("FALSE", "TRUE"))

names(n) = dnames

dimnames(tab) = n

tab = as.table(tab)

tab

}

tm <- system.time({ tab2 <- twoXtwo3(manual,auto,dnames=c("manual", "auto"))})

print(tm)

Thanks for the responses – I’ll check the sys.times and try out on my data.

Pingback: Sometimes I feel (some) need for speed | Quantum Forest

I wrote some more detailed comments here

got a nice solution:

my.tab = function(x, y) {

tt = sum(x * y)

t1=sum(x)

t2=sum(y)

return(matrix(c(length(x)-t1-t2+tt, t1-tt, t2-tt, tt), 2, 2))

}

put it also in a blog post. http://wiekvoet.blogspot.nl/2014/07/odfweave-setup-and-counting-logicals.html