R efficient index matching elements, cluster evaluation - r

Question

This may be a fairly esoteric question.
I'm trying to implement some of the ideas from Albatineh et al (2006) (DOI: 10.1007/s00357-006-0017-z) for a spatial clustering algorithm. The basic idea is one way to assess the stability of a clustering result is to examine how often pairs of observations end up in the same class. In a well defined solution pairs of observations should frequently end up in the same group.
The challenge is that in a large data set there are n^2 possible pairs (and most don't occur). We have structured our output as follows:
A B C C A
B A A A B
A B C C A
Where the column index is the observation ID and each row represents a run from the clustering algorithm. In this example there are 5 observations and the algorithm was run 3 times. The cluster labels A:C are essentially arbitrary between runs. I'd like an efficient way to calculate something like this:
ID1 ID2
1 5
2
3 4
4 3
5 1
1 2
2 3
2 4
...
This accomplishes my goal but is super slow, especially for a large data frame:
testData <- matrix(data=sample(x=c("A", "B", "C"), 15, replace=TRUE), nrow=3)
cluPr <- function(pr.obs){
pairs <- data.frame()
for (row in 1:dim(pr.obs)[1]){
for (ob in 1:dim(pr.obs)[2]){
ob.pairs <- which(pr.obs[row,] %in% pr.obs[row,ob], arr.ind=TRUE)
pairs <- rbind(pairs, cbind(ob, ob.pairs))
}
}
return(pairs)
}
cluPr(testData)

Answer 1

Here's a relatively quick approach using the combn() function. I assumed that the name of your matrix was m.
results <- t(combn(dim(m)[2], 2, function(x) c(x[1], x[2], sum(m[, x[1]] == m[, x[2]]))))
results2 <- results[results[, 3]>0, ]

Answer 2

Try this:
clu.pairs <- function(k, row)
{
w <- which(row==k)
expand.grid(w, w)
}
row.pairs <- function(row)
{
do.call(rbind, lapply(unique(row), function(k) clu.pairs(k, row)))
}
full.pairs <- function(data)
{
do.call(rbind, lapply(seq_len(nrow(data)), function(i) row.pairs(data[i,])))
}
And use full.pairs(testData). The result is not in the same order as yours, but it's equivalent.

Answer 3

My first implementation (not in R; my code is much faster in Java) of the pair counting metrics was with ordered generators, and then doing a merge-sort way of computing the intersection. It was still on the order of O(n^2) run-time, but much lower in memory use.
However, you need to realize that you don't need to know the exact pairs. You only need the quantity in the intersections, and that can be computed straightforward from the intersection matrix, just like most other similarity measures. It's substantially faster if you only need to compute the set intersection sizes; with hash tables, set intersection should be in O(n).
I don't have time to look it up; but we may have touched this in the discussion of
Evaluation of Clusterings – Metrics and Visual Support
Data Engineering (ICDE), 2012 IEEE 28th International Conference on
Elke Achtert, Sascha Goldhofer, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek
where we demonstrated a visual tool to explore the pair-counting based measures, also for more than two clustering solutions (unfortunately, a visual inspection mostly works for toy data sets, not for real data which is usually too messy and high-dimensional).
Roughly said: try computing the values using the formulas on page 303 in the publication you cited, instead of computing and then counting the pairs as explained in the intuition/motivation!