X-Git-Url: https://git.auder.net/?p=epclust.git;a=blobdiff_plain;f=epclust%2FR%2Fclustering.R;h=640837064273f0947ce82a2c9d2130ee37268221;hp=493f90f31c1c20d0cfb591d4acc043ff32505a8a;hb=4bcfdbee4e2157f232427a5bfdf240f34760110d;hpb=4efef8ccd1522278f53aa5ce265f3a6cfb6fbd9f

diff --git a/epclust/R/clustering.R b/epclust/R/clustering.R
index 493f90f..6408370 100644
--- a/epclust/R/clustering.R
+++ b/epclust/R/clustering.R
@@ -1,10 +1,44 @@
-# Cluster one full task (nb_curves / ntasks series); only step 1
-clusteringTask = function(indices, getCoefs, K1, nb_series_per_chunk, ncores)
+#' @name clustering
+#' @rdname clustering
+#' @aliases clusteringTask computeClusters1 computeClusters2
+#'
+#' @title Two-stages clustering, withing one task (see \code{claws()})
+#'
+#' @description \code{clusteringTask()} runs one full task, which consists in iterated stage 1
+#'   clustering (on nb_curves / ntasks energy contributions, computed through discrete
+#'   wavelets coefficients). \code{computeClusters1()} and \code{computeClusters2()}
+#'   correspond to the atomic clustering procedures respectively for stage 1 and 2.
+#'   The former applies the clustering algorithm (PAM) on a contributions matrix, while
+#'   the latter clusters a chunk of series inside one task (~max nb_series_per_chunk)
+#'
+#' @param indices Range of series indices to cluster in parallel (initial data)
+#' @param getContribs Function to retrieve contributions from initial series indices:
+#'   \code{getContribs(indices)} outpus a contributions matrix
+#' @param contribs matrix of contributions (e.g. output of \code{curvesToContribs()})
+#' @inheritParams computeSynchrones
+#' @inheritParams claws
+#'
+#' @return For \code{clusteringTask()} and \code{computeClusters1()}, the indices of the
+#'   computed (K1) medoids. Indices are irrelevant for stage 2 clustering, thus
+#'   \code{computeClusters2()} outputs a matrix of medoids
+#'   (of size limited by nb_series_per_chunk)
+NULL
+
+#' @rdname clustering
+#' @export
+clusteringTask = function(indices, getContribs, K1, nb_series_per_chunk, ncores_clust)
 {
-	cl = parallel::makeCluster(ncores)
-	parallel::clusterExport(cl, varlist=c("getCoefs","K1"), envir=environment())
+
+#NOTE: comment out parallel sections for debugging
+#propagate verbose arg ?!
+
+#	cl = parallel::makeCluster(ncores_clust)
+#	parallel::clusterExport(cl, varlist=c("getContribs","K1"), envir=environment())
 	repeat
 	{
+
+print(length(indices))
+
 		nb_workers = max( 1, floor( length(indices) / nb_series_per_chunk ) )
 		indices_workers = lapply( seq_len(nb_workers), function(i)
 			indices[(nb_series_per_chunk*(i-1)+1):(nb_series_per_chunk*i)] )
@@ -16,29 +50,45 @@ clusteringTask = function(indices, getCoefs, K1, nb_series_per_chunk, ncores)
 			indices_workers[[index]] = c(indices_workers[[index]], tail(indices,rem))
 			rem = rem - 1
 		}
-		indices = unlist( parallel::parLapply( cl, indices_workers, function(inds) {
-			require("epclust", quietly=TRUE)
-			inds[ computeClusters1(getCoefs(inds), K1) ]
+#		indices = unlist( parallel::parLapply( cl, indices_workers, function(inds) {
+		indices = unlist( lapply( indices_workers, function(inds) {
+#			require("epclust", quietly=TRUE)
+
+print(paste("   ",length(inds))) ## PROBLEME ICI : 21104 ??!
+
+			inds[ computeClusters1(getContribs(inds), K1) ]
 		} ) )
 		if (length(indices) == K1)
 			break
 	}
-	parallel::stopCluster(cl)
+#	parallel::stopCluster(cl)
 	indices #medoids
 }
 
-# Apply the clustering algorithm (PAM) on a coeffs or distances matrix
-computeClusters1 = function(coefs, K1)
-	cluster::pam(coefs, K1, diss=FALSE)$id.med
+#' @rdname clustering
+#' @export
+computeClusters1 = function(contribs, K1)
+	cluster::pam(contribs, K1, diss=FALSE)$id.med
 
-# Cluster a chunk of series inside one task (~max nb_series_per_chunk)
+#' @rdname clustering
+#' @export
 computeClusters2 = function(medoids, K2, getRefSeries, nb_series_per_chunk)
 {
 	synchrones = computeSynchrones(medoids, getRefSeries, nb_series_per_chunk)
 	medoids[ cluster::pam(computeWerDists(synchrones), K2, diss=TRUE)$medoids , ]
 }
 
-# Compute the synchrones curves (sum of clusters elements) from a clustering result
+#' computeSynchrones
+#'
+#' Compute the synchrones curves (sum of clusters elements) from a matrix of medoids,
+#' using L2 distances.
+#'
+#' @param medoids Matrix of medoids (curves of same legnth as initial series)
+#' @param getRefSeries Function to retrieve initial series (e.g. in stage 2 after series
+#'   have been replaced by stage-1 medoids)
+#' @inheritParams claws
+#'
+#' @export
 computeSynchrones = function(medoids, getRefSeries, nb_series_per_chunk)
 {
 	K = nrow(medoids)
@@ -66,16 +116,22 @@ computeSynchrones = function(medoids, getRefSeries, nb_series_per_chunk)
 	synchrones[ sapply(seq_len(K), function(i) all(!is.nan(synchrones[i,]))) , ]
 }
 
-# Compute the WER distance between the synchrones curves (in rows)
-computeWerDists = function(curves)
+#' computeWerDists
+#'
+#' Compute the WER distances between the synchrones curves (in rows), which are
+#' returned (e.g.) by \code{computeSynchrones()}
+#'
+#' @param synchrones A matrix of synchrones, in rows. The series have same length as the
+#' series in the initial dataset
+#'
+#' @export
+computeWerDists = function(synchrones)
 {
-	if (!require("Rwave", quietly=TRUE))
-		stop("Unable to load Rwave library")
-	n <- nrow(curves)
-	delta <- ncol(curves)
+	n <- nrow(synchrones)
+	delta <- ncol(synchrones)
 	#TODO: automatic tune of all these parameters ? (for other users)
 	nvoice   <- 4
-	# noctave = 2^13 = 8192 half hours ~ 180 days ; ~log2(ncol(curves))
+	# noctave = 2^13 = 8192 half hours ~ 180 days ; ~log2(ncol(synchrones))
 	noctave = 13
 	# 4 here represent 2^5 = 32 half-hours ~ 1 day
 	#NOTE: default scalevector == 2^(0:(noctave * nvoice) / nvoice) * s0 (?)
@@ -89,7 +145,7 @@ computeWerDists = function(curves)
 
 	# (normalized) observations node with CWT
 	Xcwt4 <- lapply(seq_len(n), function(i) {
-		ts <- scale(ts(curves[i,]), center=TRUE, scale=scaled)
+		ts <- scale(ts(synchrones[i,]), center=TRUE, scale=scaled)
 		totts.cwt = Rwave::cwt(ts,totnoct,nvoice,w0,plot=0)
 		ts.cwt = totts.cwt[,s0log:(s0log+noctave*nvoice)]
 		#Normalization