X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=epclust%2FR%2Fmain.R;h=bcc650abb8feee40cfc246ef3f95d27b13e478c4;hb=d9bb53c5e1392018bf67f92140edb10137f3423c;hp=a039d1cc029f94f641d6943b7aacc63d27c38002;hpb=37c82bbafbffc19e8b47a521952bac58f189e9ea;p=epclust.git diff --git a/epclust/R/main.R b/epclust/R/main.R index a039d1c..bcc650a 100644 --- a/epclust/R/main.R +++ b/epclust/R/main.R @@ -4,29 +4,35 @@ #' two stage procedure in parallel (see details). #' Input series must be sampled on the same time grid, no missing values. #' -#' @details Summary of the function execution flow: +#' Summary of the function execution flow: +#' \enumerate{ +#' \item Compute and serialize all contributions, obtained through discrete wavelet +#' decomposition (see Antoniadis & al. [2013]) +#' \item Divide series into \code{ntasks} groups to process in parallel. In each task: #' \enumerate{ -#' \item Compute and serialize all contributions, obtained through discrete wavelet -#' decomposition (see Antoniadis & al. [2013]) -#' \item Divide series into \code{ntasks} groups to process in parallel. In each task: -#' \enumerate{ -#' \item iterate the first clustering algorithm on its aggregated outputs, -#' on inputs of size \code{nb_items_clust} -#' \item optionally, if WER=="mix": -#' a) compute the K1 synchrones curves, -#' b) compute WER distances (K1xK1 matrix) between synchrones and -#' c) apply the second clustering algorithm -#' } -#' \item Launch a final task on the aggregated outputs of all previous tasks: -#' in the case WER=="end" this task takes indices in input, otherwise -#' (medoid) curves +#' \item iterate the first clustering algorithm on its aggregated outputs, +#' on inputs of size \code{nb_items_clust1} +#' \item optionally, if WER=="mix": +#' a) compute the K1 synchrones curves, +#' b) compute WER distances (K1xK1 matrix) between synchrones and +#' c) apply the second clustering algorithm #' } -#' The main argument -- \code{getSeries} -- has a quite misleading name, since it can be -#' either a [big.]matrix, a CSV file, a connection or a user function to retrieve -#' series; the name was chosen because all types of arguments are converted to a function. -#' When \code{getSeries} is given as a function, it must take a single argument, -#' 'indices', integer vector equal to the indices of the curves to retrieve; -#' see SQLite example. The nature and role of other arguments should be clear +#' \item Launch a final task on the aggregated outputs of all previous tasks: +#' in the case WER=="end" this task takes indices in input, otherwise +#' (medoid) curves +#' } +#' \cr +#' The main argument -- \code{getSeries} -- has a quite misleading name, since it can be +#' either a [big.]matrix, a CSV file, a connection or a user function to retrieve +#' series; the name was chosen because all types of arguments are converted to a function. +#' When \code{getSeries} is given as a function, it must take a single argument, +#' 'indices', integer vector equal to the indices of the curves to retrieve; +#' see SQLite example. The nature and role of other arguments should be clear +#' \cr +#' Note: Since we don't make assumptions on initial data, there is a possibility that +#' even when serialized, contributions or synchrones do not fit in RAM. For example, +#' 30e6 series of length 100,000 would lead to a +4Go contribution matrix. Therefore, +#' it's safer to place these in (binary) files; that's what we do. #' #' @param getSeries Access to the (time-)series, which can be of one of the three #' following types: @@ -40,12 +46,14 @@ #' @param K1 Number of clusters to be found after stage 1 (K1 << N [number of series]) #' @param K2 Number of clusters to be found after stage 2 (K2 << K1) #' @param nb_series_per_chunk (Maximum) number of series to retrieve in one batch -#' @param algo_clust1 Clustering algorithm for stage 1. A function which takes (data, K) +#' @param algoClust1 Clustering algorithm for stage 1. A function which takes (data, K) #' as argument where data is a matrix in columns and K the desired number of clusters, -#' and outputs K medoids ranks. Default: PAM -#' @param algo_clust2 Clustering algorithm for stage 2. A function which takes (dists, K) +#' and outputs K medoids ranks. Default: PAM. In our method, this function is called +#' on iterated medoids during stage 1 +#' @param algoClust2 Clustering algorithm for stage 2. A function which takes (dists, K) #' as argument where dists is a matrix of distances and K the desired number of clusters, -#' and outputs K clusters representatives (curves). Default: k-means +#' and outputs K medoids ranks. Default: PAM. In our method, this function is called +#' on a matrix of K1 x K1 (WER) distances computed between synchrones #' @param nb_items_clust1 (~Maximum) number of items in input of the clustering algorithm #' for stage 1. At worst, a clustering algorithm might be called with ~2*nb_items_clust1 #' items; but this could only happen at the last few iterations. @@ -134,17 +142,12 @@ #' digest::sha1(medoids_db) #' } #' @export -claws <- function(getSeries, K1, K2, nb_series_per_chunk, - nb_items_clust1=7*K1, - algo_clust1=function(data,K) cluster::pam(data,K,diss=FALSE), - algo_clust2=function(dists,K) stats::kmeans(dists,K,iter.max=50,nstart=3), - wav_filt="d8", contrib_type="absolute", - WER="end", - random=TRUE, - ntasks=1, ncores_tasks=1, ncores_clust=4, - sep=",", - nbytes=4, endian=.Platform$endian, - verbose=FALSE, parll=TRUE) +claws <- function(getSeries, K1, K2, nb_series_per_chunk, nb_items_clust1=7*K1, + algoClust1=function(data,K) cluster::pam(t(data),K,diss=FALSE)$id.med, + algoClust2=function(dists,K) cluster::pam(dists,K,diss=TRUE)$id.med, + wav_filt="d8", contrib_type="absolute", WER="end", random=TRUE, + ntasks=1, ncores_tasks=1, ncores_clust=4, sep=",", nbytes=4, + endian=.Platform$endian, verbose=FALSE, parll=TRUE) { # Check/transform arguments if (!is.matrix(getSeries) && !bigmemory::is.big.matrix(getSeries) @@ -162,11 +165,8 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, stop("'K1' cannot exceed 'nb_series_per_chunk'") nb_items_clust1 <- .toInteger(nb_items_clust1, function(x) x>K1) random <- .toLogical(random) - tryCatch - ( - {ignored <- wavelets::wt.filter(wav_filt)}, - error = function(e) stop("Invalid wavelet filter; see ?wavelets::wt.filter") - ) + tryCatch( {ignored <- wavelets::wt.filter(wav_filt)}, + error = function(e) stop("Invalid wavelet filter; see ?wavelets::wt.filter") ) ctypes = c("relative","absolute","logit") contrib_type = ctypes[ pmatch(contrib_type,ctypes) ] if (is.na(contrib_type)) @@ -183,33 +183,26 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, verbose <- .toLogical(verbose) parll <- .toLogical(parll) - # Since we don't make assumptions on initial data, there is a possibility that even - # when serialized, contributions or synchrones do not fit in RAM. For example, - # 30e6 series of length 100,000 would lead to a +4Go contribution matrix. Therefore, - # it's safer to place these in (binary) files, located in the following folder. - bin_dir <- ".epclust_bin/" - dir.create(bin_dir, showWarnings=FALSE, mode="0755") - # Binarize series if getSeries is not a function; the aim is to always use a function, # to uniformize treatments. An equally good alternative would be to use a file-backed - # bigmemory::big.matrix, but it would break the uniformity. + # bigmemory::big.matrix, but it would break the "all-is-function" pattern. if (!is.function(getSeries)) { if (verbose) cat("...Serialize time-series\n") - series_file = paste(bin_dir,"data",sep="") ; unlink(series_file) + series_file = ".series.bin" ; unlink(series_file) binarize(getSeries, series_file, nb_series_per_chunk, sep, nbytes, endian) getSeries = function(inds) getDataInFile(inds, series_file, nbytes, endian) } # Serialize all computed wavelets contributions into a file - contribs_file = paste(bin_dir,"contribs",sep="") ; unlink(contribs_file) + contribs_file = ".contribs.bin" ; unlink(contribs_file) index = 1 nb_curves = 0 if (verbose) cat("...Compute contributions and serialize them\n") nb_curves = binarizeTransform(getSeries, - function(series) curvesToContribs(series, wf, ctype), + function(series) curvesToContribs(series, wav_filt, contrib_type), contribs_file, nb_series_per_chunk, nbytes, endian) getContribs = function(indices) getDataInFile(indices, contribs_file, nbytes, endian) @@ -220,8 +213,8 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, if (nb_series_per_task < K2) stop("Too many tasks: less series in one task than final number of clusters") - # Generate a random permutation of 1:N (if random==TRUE); otherwise just use arrival - # (storage) order. + # Generate a random permutation of 1:N (if random==TRUE); + # otherwise just use arrival (storage) order. indices_all = if (random) sample(nb_curves) else seq_len(nb_curves) # Split (all) indices into ntasks groups of ~same size indices_tasks = lapply(seq_len(ntasks), function(i) { @@ -234,10 +227,10 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, # Initialize parallel runs: outfile="" allow to output verbose traces in the console # under Linux. All necessary variables are passed to the workers. cl = parallel::makeCluster(ncores_tasks, outfile="") - varlist = c("getSeries","getContribs","K1","K2","algo_clust1","algo_clust2", - "nb_series_per_chunk","nb_items_clust","ncores_clust","sep", - "nbytes","endian","verbose","parll") - if (WER=="mix") + varlist = c("getSeries","getContribs","K1","K2","algoClust1","algoClust2", + "nb_series_per_chunk","nb_items_clust1","ncores_clust", + "sep","nbytes","endian","verbose","parll") + if (WER=="mix" && ntasks>1) varlist = c(varlist, "medoids_file") parallel::clusterExport(cl, varlist, envir = environment()) } @@ -248,19 +241,19 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, # where n = N / ntasks, N being the total number of curves. runTwoStepClustering = function(inds) { - # When running in parallel, the environment is blank: we need to load required + # When running in parallel, the environment is blank: we need to load the required # packages, and pass useful variables. if (parll && ntasks>1) require("epclust", quietly=TRUE) indices_medoids = clusteringTask1( - inds, getContribs, K1, nb_series_per_chunk, ncores_clust, verbose, parll) - if (WER=="mix") + inds, getContribs, K1, algoClust1, nb_series_per_chunk, ncores_clust, verbose, parll) + if (WER=="mix" && ntasks>1) { - if (parll && ntasks>1) + if (parll) require("bigmemory", quietly=TRUE) medoids1 = bigmemory::as.big.matrix( getSeries(indices_medoids) ) - medoids2 = clusteringTask2(medoids1, K2, getSeries, nb_curves, nb_series_per_chunk, - nbytes, endian, ncores_clust, verbose, parll) + medoids2 = clusteringTask2(medoids1, K2, algoClust2, getSeries, nb_curves, + nb_series_per_chunk, nbytes, endian, ncores_clust, verbose, parll) binarize(medoids2, medoids_file, nb_series_per_chunk, sep, nbytes, endian) return (vector("integer",0)) } @@ -270,8 +263,8 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, # Synchrones (medoids) need to be stored only if WER=="mix"; indeed in this case, every # task output is a set of new (medoids) curves. If WER=="end" however, output is just a # set of indices, representing some initial series. - if (WER=="mix") - {medoids_file = paste(bin_dir,"medoids",sep="") ; unlink(medoids_file)} + if (WER=="mix" && ntasks>1) + {medoids_file = ".medoids.bin" ; unlink(medoids_file)} if (verbose) { @@ -282,8 +275,7 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, } # As explained above, indices will be assigned to ntasks*K1 medoids indices [if WER=="end"], - # or nothing (empty vector) if WER=="mix"; in this case, medoids (synchrones) are stored - # in a file. + # or nothing (empty vector) if WER=="mix"; in this case, synchrones are stored in a file. indices <- if (parll && ntasks>1) unlist( parallel::parLapply(cl, indices_tasks, runTwoStepClustering) ) @@ -293,14 +285,14 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, parallel::stopCluster(cl) # Right before the final stage, two situations are possible: - # a. data to be processed now sit in binary format in medoids_file (if WER=="mix") + # a. data to be processed now sit in a binary format in medoids_file (if WER=="mix") # b. data still is the initial set of curves, referenced by the ntasks*K1 indices # So, the function getSeries() will potentially change. However, computeSynchrones() # requires a function retrieving the initial series. Thus, the next line saves future # conditional instructions. getRefSeries = getSeries - if (WER=="mix") + if (WER=="mix" && ntasks>1) { indices = seq_len(ntasks*K2) # Now series (synchrones) must be retrieved from medoids_file @@ -311,24 +303,23 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, if (verbose) cat("...Serialize contributions computed on synchrones\n") ignored = binarizeTransform(getSeries, - function(series) curvesToContribs(series, wf, ctype), + function(series) curvesToContribs(series, wav_filt, contrib_type), contribs_file, nb_series_per_chunk, nbytes, endian) } -#TODO: check THAT - - # Run step2 on resulting indices or series (from file) if (verbose) cat("...Run final // stage 1 + stage 2\n") - indices_medoids = clusteringTask1( - indices, getContribs, K1, nb_series_per_chunk, ncores_tasks*ncores_clust, verbose, parll) + indices_medoids = clusteringTask1(indices, getContribs, K1, algoClust1, + nb_series_per_chunk, ncores_tasks*ncores_clust, verbose, parll) medoids1 = bigmemory::as.big.matrix( getSeries(indices_medoids) ) - medoids2 = clusteringTask2(medoids1, K2, getRefSeries, nb_curves, nb_series_per_chunk, - nbytes, endian, ncores_tasks*ncores_clust, verbose, parll) + medoids2 = clusteringTask2(medoids1, K2, algoClust2, getRefSeries, nb_curves, + nb_series_per_chunk, nbytes, endian, ncores_tasks*ncores_clust, verbose, parll) - # Cleanup: remove temporary binary files and their folder - unlink(bin_dir, recursive=TRUE) + # Cleanup: remove temporary binary files + tryCatch( + {unlink(series_file); unlink(contribs_file); unlink(medoids_file)}, + error = function(e) {}) # Return medoids as a standard matrix, since K2 series have to fit in RAM # (clustering algorithm 1 takes K1 > K2 of them as input) @@ -346,14 +337,17 @@ claws <- function(getSeries, K1, K2, nb_series_per_chunk, #' @return A [big.]matrix of size log(L) x n containing contributions in columns #' #' @export -curvesToContribs = function(series, wav_filt, contrib_type) +curvesToContribs = function(series, wav_filt, contrib_type, coin=FALSE) { + series = as.matrix(series) #1D serie could occur L = nrow(series) D = ceiling( log2(L) ) + # Series are interpolated to all have length 2^D nb_sample_points = 2^D apply(series, 2, function(x) { interpolated_curve = spline(1:L, x, n=nb_sample_points)$y - W = wavelets::dwt(interpolated_curve, filter=wf, D)@W + W = wavelets::dwt(interpolated_curve, filter=wav_filt, D)@W + # Compute the sum of squared discrete wavelet coefficients, for each scale nrj = rev( sapply( W, function(v) ( sqrt( sum(v^2) ) ) ) ) if (contrib_type!="absolute") nrj = nrj / sum(nrj)