renaming, refactoring

[epclust.git] / epclust / R / clustering.R

diff --git a/epclust/R/clustering.R b/epclust/R/clustering.R
index e27ea35..077becf 100644 (file)
--- a/epclust/R/clustering.R
+++ b/epclust/R/clustering.R
@@ -1,71 +1,65 @@
-oneIteration = function(..........)
+# Cluster one full task (nb_curves / ntasks series)
+clusteringTask = function(K1, K2, WER, nb_series_per_chunk, indices_tasks, ncores_clust)
 {
-               cl_clust = parallel::makeCluster(ncores_clust)
-               parallel::clusterExport(cl_clust, .............., envir=........)
-               indices_clust = indices_task[[i]]
-               repeat
+       cl_clust = parallel::makeCluster(ncores_clust)
+       #parallel::clusterExport(cl=cl_clust, varlist=c("fonctions_du_package"), envir=environment())
+       indices_clust = indices_task[[i]]
+       repeat
+       {
+               nb_workers = max( 1, round( length(indices_clust) / nb_series_per_chunk ) )
+               indices_workers = list()
+               for (i in 1:nb_workers)
                {
-                       nb_workers = max( 1, round( length(indices_clust) / nb_series_per_chunk ) )
-                       indices_workers = list()
-                       #indices[[i]] == (start_index,number_of_elements)
-                       for (i in 1:nb_workers)
-                       {
-                               upper_bound = ifelse( i<nb_workers,
-                                       min(nb_series_per_chunk*i,length(indices_clust)), length(indices_clust) )
-                               indices_workers[[i]] = indices_clust[(nb_series_per_chunk*(i-1)+1):upper_bound]
-                       }
-                       indices_clust = parallel::parSapply(cl, indices_workers, processChunk, K1, K2*(WER=="mix"))
-                       if ( (WER=="end" && length(indices_clust) == K1) ||
-                               (WER=="mix" && length(indices_clust) == K2) )
-                       {
-                               break
-                       }
+                       upper_bound = ifelse( i<nb_workers,
+                               min(nb_series_per_chunk*i,length(indices_clust)), length(indices_clust) )
+                       indices_workers[[i]] = indices_clust[(nb_series_per_chunk*(i-1)+1):upper_bound]
                }
-               parallel::stopCluster(cl_clust)
-               res_clust
+               indices_clust = parallel::parLapply(cl, indices_workers, clusterChunk, K1, K2*(WER=="mix"))
+               if ((WER=="end" && length(indices_clust)==K1) || (WER=="mix" && length(indices_clust)==K2))
+                       break
+       }
+       parallel::stopCluster(cl_clust)
+       unlist(indices_clust)
 }
 
-processChunk = function(indices, K1, K2)
+# Cluster a chunk of series inside one task (~max nb_series_per_chunk)
+clusterChunk = function(indices, K1, K2)
 {
-       #1) retrieve data (coeffs)
        coeffs = getCoeffs(indices)
-       #2) cluster
-       cl = computeClusters(as.matrix(coeffs[,2:ncol(coeffs)]), K1)
-       #3) WER (optional)
+       cl = computeClusters(as.matrix(coeffs[,2:ncol(coeffs)]), K1, diss=FALSE)
        if (K2 > 0)
        {
                curves = computeSynchrones(cl)
                dists = computeWerDists(curves)
-               cl = computeClusters(dists, K2)
+               cl = computeClusters(dists, K2, diss=TRUE)
        }
-       cl
+       indices[cl]
 }
 
-computeClusters = function(data, K)
+# Apply the clustering algorithm (PAM) on a coeffs or distances matrix
+computeClusters = function(md, K, diss)
 {
-       library(cluster)
-       pam_output = cluster::pam(data, K)
-       return ( list( clusts=pam_output$clustering, medoids=pam_output$medoids,
-               ranks=pam_output$id.med ) )
+       if (!require(cluster, quietly=TRUE))
+               stop("Unable to load cluster library")
+       cluster::pam(md, K, diss=diss)$id.med
 }
 
-#TODO: appendCoeffs() en C --> serialize et append to file
-
-computeSynchrones = function(...)
+# Compute the synchrones curves (sum of clusters elements) from a clustering result
+computeSynchrones = function(indices)
 {
-
+       colSums( getData(indices) )
 }
 
-#Entrée : courbes synchrones, soit après étape 1 itérée, soit après chaqure étape 1
-computeWerDist = function(conso)
+# Compute the WER distance between the synchrones curves
+computeWerDist = function(curves)
 {
        if (!require("Rwave", quietly=TRUE))
                stop("Unable to load Rwave library")
-       n <- nrow(conso)
-       delta <- ncol(conso)
+       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(conso))
+       # 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 (?)
@@ -79,7 +73,7 @@ computeWerDist = function(conso)
 
        # (normalized) observations node with CWT
        Xcwt4 <- lapply(seq_len(n), function(i) {
-               ts <- scale(ts(conso[i,]), center=TRUE, scale=scaled)
+               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