X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=epclust%2FR%2Fclustering.R;h=1774b19e686c657ea4a81768920d0ffc238bc8a7;hb=3fb6e823601002c44ffbf913e83c8d24cfa1e819;hp=578b2f399035023eb68b0b004be10f18d87cac84;hpb=48108c3999d28d973443fa5e78f73a0a9f2bfc07;p=epclust.git diff --git a/epclust/R/clustering.R b/epclust/R/clustering.R index 578b2f3..1774b19 100644 --- a/epclust/R/clustering.R +++ b/epclust/R/clustering.R @@ -1,103 +1,85 @@ -# Cluster one full task (nb_curves / ntasks series) -clusteringTask = function(indices_clust) +#' Two-stage clustering, within one task (see \code{claws()}) +#' +#' \code{clusteringTask1()} runs one full stage-1 task, which consists in iterated +#' clustering on nb_curves / ntasks energy contributions, computed through +#' discrete wavelets coefficients. +#' \code{clusteringTask2()} runs a full stage-2 task, which consists in WER distances +#' computations between medoids (indices) output from stage 1, before applying +#' the second clustering algorithm on the distances matrix. +#' +#' @param getContribs Function to retrieve contributions from initial series indices: +#' \code{getContribs(indices)} outputs a contributions matrix, in columns +#' @inheritParams claws +#' @inheritParams computeSynchrones +#' @inheritParams computeWerDists +#' +#' @return The indices of the computed (resp. K1 and K2) medoids. +#' +#' @name clustering +#' @rdname clustering +#' @aliases clusteringTask1 clusteringTask2 +NULL + +#' @rdname clustering +#' @export +clusteringTask1 <- function(indices, getContribs, K1, algoClust1, nb_items_clust, + ncores_clust=3, verbose=FALSE, parll=TRUE) { - cl_clust = parallel::makeCluster(ncores_clust) - parallel::clusterExport(cl_clust, - varlist=c("K1","K2","WER"), - envir=environment()) - repeat + if (parll) { - nb_workers = max( 1, round( length(indices_clust) / nb_series_per_chunk ) ) - indices_workers = lapply(seq_len(nb_workers), function(i) { - upper_bound = ifelse( i 0) + # Iterate clustering algorithm 1 until K1 medoids are found + while (length(indices) > K1) { - curves = computeSynchrones(cl) - dists = computeWerDists(curves) - cl = computeClusters(dists, K2, diss=TRUE) + # Balance tasks by splitting the indices set - as evenly as possible + indices_workers <- .splitIndices(indices, nb_items_clust, min_size=K1+1) + if (verbose) + cat(paste("*** [iterated] Clustering task 1 on ",length(indices)," series\n", sep="")) + indices <- + if (parll) + { + unlist( parallel::parLapply(cl, indices_workers, function(inds) { + require("epclust", quietly=TRUE) + inds[ algoClust1(getContribs(inds), K1) ] + }) ) + } + else + { + unlist( lapply(indices_workers, function(inds) + inds[ algoClust1(getContribs(inds), K1) ] + ) ) + } } - indices_chunk[cl] -} + if (parll) + parallel::stopCluster(cl) -# Apply the clustering algorithm (PAM) on a coeffs or distances matrix -computeClusters = function(md, K, diss) -{ - if (!require(cluster, quietly=TRUE)) - stop("Unable to load cluster library") - cluster::pam(md, K, diss=diss)$id.med + indices #medoids } -# Compute the synchrones curves (sum of clusters elements) from a clustering result -computeSynchrones = function(indices) +#' @rdname clustering +#' @export +clusteringTask2 <- function(indices, getSeries, K2, algoClust2, nb_series_per_chunk, + smooth_lvl, nvoice, nbytes, endian, ncores_clust=3, verbose=FALSE, parll=TRUE) { - colSums( getData(indices) ) -} + if (verbose) + cat(paste("*** Clustering task 2 on ",length(indices)," medoids\n", sep="")) -# Compute the WER distance between the synchrones curves -computeWerDist = function(curves) -{ - if (!require("Rwave", quietly=TRUE)) - stop("Unable to load Rwave library") - n <- nrow(curves) - delta <- ncol(curves) - #TODO: automatic tune of all these parameters ? (for other users) - nvoice <- 4 - # noctave = 2^13 = 8192 half hours ~ 180 days ; ~log2(ncol(curves)) - noctave = 13 - # 4 here represent 2^5 = 32 half-hours ~ 1 day - #NOTE: default scalevector == 2^(0:(noctave * nvoice) / nvoice) * s0 (?) - scalevector <- 2^(4:(noctave * nvoice) / nvoice) * 2 - #condition: ( log2(s0*w0/(2*pi)) - 1 ) * nvoice + 1.5 >= 1 - s0=2 - w0=2*pi - scaled=FALSE - s0log = as.integer( (log2( s0*w0/(2*pi) ) - 1) * nvoice + 1.5 ) - totnoct = noctave + as.integer(s0log/nvoice) + 1 + if (length(indices) <= K2) + return (indices) - # (normalized) observations node with CWT - Xcwt4 <- lapply(seq_len(n), function(i) { - ts <- scale(ts(curves[i,]), center=TRUE, scale=scaled) - totts.cwt = Rwave::cwt(ts,totnoct,nvoice,w0,plot=0) - ts.cwt = totts.cwt[,s0log:(s0log+noctave*nvoice)] - #Normalization - sqs <- sqrt(2^(0:(noctave*nvoice)/nvoice)*s0) - sqres <- sweep(ts.cwt,MARGIN=2,sqs,'*') - sqres / max(Mod(sqres)) - }) + # A) Compute the WER distances (Wavelets Extended coefficient of deteRmination) + distances <- computeWerDists(indices, getSeries, nb_series_per_chunk, + smooth_lvl, nvoice, nbytes, endian, ncores_clust, verbose, parll) - Xwer_dist <- matrix(0., n, n) - fcoefs = rep(1/3, 3) #moving average on 3 values (TODO: very slow! correct?!) - for (i in 1:(n-1)) - { - for (j in (i+1):n) - { - #TODO: later, compute CWT here (because not enough storage space for 32M series) - # 'circular=TRUE' is wrong, should just take values on the sides; to rewrite in C - num <- filter(Mod(Xcwt4[[i]] * Conj(Xcwt4[[j]])), fcoefs, circular=TRUE) - WX <- filter(Mod(Xcwt4[[i]] * Conj(Xcwt4[[i]])), fcoefs, circular=TRUE) - WY <- filter(Mod(Xcwt4[[j]] * Conj(Xcwt4[[j]])), fcoefs, circular=TRUE) - wer2 <- sum(colSums(num)^2) / sum( sum(colSums(WX) * colSums(WY)) ) - Xwer_dist[i,j] <- sqrt(delta * ncol(Xcwt4[[1]]) * (1 - wer2)) - Xwer_dist[j,i] <- Xwer_dist[i,j] - } - } - diag(Xwer_dist) <- numeric(n) - Xwer_dist + # B) Apply clustering algorithm 2 on the WER distances matrix + if (verbose) + cat(paste("*** algoClust2() on ",nrow(distances)," items\n", sep="")) + indices[ algoClust2(distances,K2) ] }