epclust/R/main.R

   1 #' @title Cluster power curves with PAM in parallel
   2 #'
   3 #' @description Groups electricity power curves (or any series of similar nature) by applying PAM
   4 #' algorithm in parallel to chunks of size \code{nb_series_per_chunk}
   5 #'
   6 #' @param data Access to the data, which can be of one of the three following types:
   7 #' \itemize{
   8 #'   \item data.frame: each line contains its ID in the first cell, and all values after
   9 #'   \item connection: any R connection object (e.g. a file) providing lines as described above
  10 #'   \item function: a custom way to retrieve the curves; it has two arguments: the start index
  11 #'     (start) and number of curves (n); see example in package vignette.
  12 #' }
  13 #' @param K1 Number of super-consumers to be found after stage 1 (K1 << N)
  14 #' @param K2 Number of clusters to be found after stage 2 (K2 << K1)
  15 #' @param ntasks Number of tasks (parallel iterations to obtain K1 medoids); default: 1.
  16 #'   Note: ntasks << N, so that N is "roughly divisible" by N (number of series)
  17 #' @param nb_series_per_chunk (Maximum) number of series in each group, inside a task
  18 #' @param min_series_per_chunk Minimum number of series in each group
  19 #' @param wf Wavelet transform filter; see ?wt.filter. Default: haar
  20 #' @param WER "end" to apply stage 2 after stage 1 has iterated and finished, or "mix"
  21 #'   to apply it after every stage 1
  22 #' @param ncores_tasks "MPI" number of parallel tasks (1 to disable: sequential tasks)
  23 #' @param ncores_clust "OpenMP" number of parallel clusterings in one task
  24 #' @param random Randomize chunks repartition
  25 #'
  26 #' @return A data.frame of the final medoids curves (identifiers + values)
  27 #'
  28 #' @examples
  29 #' getData = function(start, n) {
  30 #'   con = dbConnect(drv = RSQLite::SQLite(), dbname = "mydata.sqlite")
  31 #'   df = dbGetQuery(con, paste(
  32 #'     "SELECT * FROM times_values GROUP BY id OFFSET ",start,
  33 #'     "LIMIT ", n, " ORDER BY date", sep=""))
  34 #'   return (df)
  35 #' }
  36 #'   #TODO: 3 examples, data.frame / binary file / DB sqLite
  37 #'   + sampleCurves : wavBootstrap de package wmtsa
  38 #' cl = epclust(getData, K1=200, K2=15, ntasks=1000, nb_series_per_chunk=5000, WER="mix")
  39 #' @export
  40 epclust = function(data, K1, K2, ntasks=1, nb_series_per_chunk=50*K1, min_series_per_chunk=5*K1,
  41     wf="haar", WER="end", ncores_tasks=1, ncores_clust=4, random=TRUE)
  42 {
  43     #0) check arguments
  44     if (!is.data.frame(data) && !is.function(data))
  45     {
  46         tryCatch(
  47             {
  48                 if (is.character(data))
  49                     data_con = file(data, open="r")
  50                 else if (!isOpen(data))
  51                 {
  52                     open(data)
  53                     data_con = data
  54                 }
  55             },
  56             error=function(e) "data should be a data.frame, a function or a valid connection"
  57         )
  58     }
  59     K1 = toInteger(K1, function(x) x>=2)
  60     K2 = toInteger(K2, function(x) x>=2)
  61     ntasks = toInteger(ntasks)
  62     nb_series_per_chunk = toInteger(nb_series_per_chunk, function(x) x>=K1)
  63     min_series_per_chunk = toInteger(K1, function(x) x>=K1 && x<=nb_series_per_chunk)
  64     ncores_tasks = toInteger(ncores_tasks, function(x) x>=1)
  65     ncores_clust = toInteger(ncores_clust, function(x) x>=1)
  66     if (WER!="end" && WER!="mix")
  67         stop("WER takes values in {'end','mix'}")
  68
  69     #1) Serialize all wavelets coefficients (+ IDs) onto a file
  70     coeffs_file = ".coeffs"
  71     index = 1
  72     nb_curves = 0
  73     nb_coeffs = NA
  74     repeat
  75     {
  76         coeffs_chunk = computeCoeffs(data, index, nb_series_per_chunk, wf)
  77         if (is.null(coeffs_chunk))
  78             break
  79         serialized_coeffs = serialize(coeffs_chunk)
  80         appendBinary(coeffs_file, serialized_coeffs)
  81         index = index + nb_series_per_chunk
  82         nb_curves = nb_curves + nrow(coeffs_chunk)
  83         if (is.na(nb_coeffs))
  84             nb_coeffs = ncol(coeffs_chunk)-1
  85     }
  86
  87 #   finalizeSerialization(coeffs_file) ........, nb_curves, )
  88 #TODO: is it really useful ?! we will always have these informations (nb_curves, nb_coeffs)
  89
  90     if (nb_curves < min_series_per_chunk)
  91         stop("Not enough data: less rows than min_series_per_chunk!")
  92     nb_series_per_task = round(nb_curves / ntasks)
  93     if (nb_series_per_task < min_series_per_chunk)
  94         stop("Too many tasks: less series in one task than min_series_per_chunk!")
  95
  96     #2) Cluster coefficients in parallel (by nb_series_per_chunk)
  97     # All indices, relative to complete dataset
  98     indices = if (random) sample(nb_curves) else seq_len(nb_curves)
  99     # Indices to be processed in each task
 100     indices_tasks = list()
 101     for (i in seq_len(ntasks))
 102     {
 103         upper_bound = ifelse( i<ntasks, min(nb_series_per_task*i,nb_curves), nb_curves )
 104         indices_task[[i]] = indices[((i-1)*nb_series_per_task+1):upper_bound]
 105     }
 106     library(parallel, quietly=TRUE)
 107     cl_tasks = parallel::makeCluster(ncores_tasks)
 108     parallel::clusterExport(cl_tasks, ..........ncores_clust, indices_tasks, nb_series_per_chunk, processChunk, K1,
 109                                      K2, WER, )
 110     ranks = parallel::parSapply(cl_tasks, seq_along(indices_tasks), oneIteration)
 111     parallel::stopCluster(cl_tasks)
 112
 113     #3) Run step1+2 step on resulting ranks
 114     ranks = oneIteration(.........)
 115     return (list("ranks"=ranks, "medoids"=getSeries(data, ranks)))
 116 }