several modifs - pkg looks better (but untested)

[valse.git] / pkg / R / main.R

diff --git a/pkg/R/main.R b/pkg/R/main.R
index 8ce5117..ab25daf 100644 (file)
--- a/pkg/R/main.R
+++ b/pkg/R/main.R
@@ -28,7 +28,6 @@ valse = function(X, Y, procedure='LassoMLE', selecMod='DDSE', gamma=1, mini=10,
   m = dim(Y)[2]
   n = dim(X)[1]
 
-  tableauRecap = list()
   if (verbose)
                print("main loop: over all k and all lambda")
 
@@ -40,21 +39,20 @@ valse = function(X, Y, procedure='LassoMLE', selecMod='DDSE', gamma=1, mini=10,
                        "ncores_outer","ncores_inner","verbose","p","m","k","tableauRecap") )
        }
 
-       # Compute model with k components
-       computeModel <- function(k)
+       # Compute models with k components
+       computeModels <- function(k)
        {
                if (ncores_outer > 1)
                        require("valse") #nodes start with an empty environment
 
                if (verbose)
                        print(paste("Parameters initialization for k =",k))
-    #smallEM initializes parameters by k-means and regression model in each component,
+               #smallEM initializes parameters by k-means and regression model in each component,
     #doing this 20 times, and keeping the values maximizing the likelihood after 10
     #iterations of the EM algorithm.
     P = initSmallEM(k, X, Y)
     grid_lambda <- computeGridLambda(P$phiInit, P$rhoInit, P$piInit, P$gamInit, X, Y,
                        gamma, mini, maxi, eps)
-
                # TODO: 100 = magic number
     if (length(grid_lambda)>100)
       grid_lambda = grid_lambda[seq(1, length(grid_lambda), length.out = 100)]
@@ -62,10 +60,9 @@ valse = function(X, Y, procedure='LassoMLE', selecMod='DDSE', gamma=1, mini=10,
                if (verbose)
                        print("Compute relevant parameters")
     #select variables according to each regularization parameter
-    #from the grid: A1 corresponding to selected variables, and
-    #A2 corresponding to unselected variables.
-    S = selectVariables(P$phiInit,P$rhoInit,P$piInit,P$gamInit,mini,maxi,gamma,
-                       grid_lambda,X,Y,1e-8,eps,ncores_inner)
+    #from the grid: S$selected corresponding to selected variables
+    S = selectVariables(P$phiInit, P$rhoInit, P$piInit, P$gamInit, mini, maxi, gamma,
+                       grid_lambda, X, Y, 1e-8, eps, ncores_inner) #TODO: 1e-8 as arg?! eps?
 
     if (procedure == 'LassoMLE')
                {
@@ -73,7 +70,7 @@ valse = function(X, Y, procedure='LassoMLE', selecMod='DDSE', gamma=1, mini=10,
                                print('run the procedure Lasso-MLE')
       #compute parameter estimations, with the Maximum Likelihood
       #Estimator, restricted on selected variables.
-      model = constructionModelesLassoMLE(phiInit, rhoInit, piInit, gamInit, mini,
+      models <- constructionModelesLassoMLE(phiInit, rhoInit, piInit, gamInit, mini,
                                maxi, gamma, X, Y, thresh, eps, S$selected, ncores_inner, verbose)
     }
                else
@@ -82,52 +79,41 @@ valse = function(X, Y, procedure='LassoMLE', selecMod='DDSE', gamma=1, mini=10,
                                print('run the procedure Lasso-Rank')
       #compute parameter estimations, with the Low Rank
       #Estimator, restricted on selected variables.
-      model = constructionModelesLassoRank(S$Pi, S$Rho, mini, maxi, X, Y, eps, A1,
+      models <- constructionModelesLassoRank(S$Pi, S$Rho, mini, maxi, X, Y, eps, A1,
                                rank.min, rank.max, ncores_inner, verbose)
-
-      ################################################
-      ### Regarder la SUITE  
-#      phi = runProcedure2()$phi
-#      Phi2 = Phi
-#      if (dim(Phi2)[1] == 0)
-#        Phi[, , 1:k,] <- phi
-#      else
-#      {
-#        Phi <- array(0, dim = c(p, m, kmax, dim(Phi2)[4] + dim(phi)[4]))
-#        Phi[, , 1:(dim(Phi2)[3]), 1:(dim(Phi2)[4])] <<- Phi2
-#        Phi[, , 1:k,-(1:(dim(Phi2)[4]))] <<- phi
-#      }
     }
-    model
+    models
   }
 
-       model_list <-
+       # List (index k) of lists (index lambda) of models
+       models_list <-
                if (ncores_k > 1)
-                       parLapply(cl, kmin:kmax, computeModel)
+                       parLapply(cl, kmin:kmax, computeModels)
                else
-                       lapply(kmin:kmax, computeModel)
+                       lapply(kmin:kmax, computeModels)
        if (ncores_k > 1)
                parallel::stopCluster(cl)
 
-       # Get summary "tableauRecap" from models
-       tableauRecap = t( sapply( seq_along(model_list), function(model) {
-               llh = matrix(ncol = 2)
-    for (l in seq_along(model))
-      llh = rbind(llh, model[[l]]$llh)
+       if (! requireNamespace("capushe", quietly=TRUE))
+       {
+               warning("'capushe' not available: returning all models")
+               return (models_list)
+       }
+
+       # Get summary "tableauRecap" from models ; TODO: jusqu'à ligne 114 à mon avis là c'est faux :/
+       tableauRecap = t( sapply( models_list, function(models) {
+               llh = do.call(rbind, lapply(models, function(model) model$llh)
     LLH = llh[-1,1]
     D = llh[-1,2]
                c(LLH, D, rep(k, length(model)), 1:length(model))
-       } ) )
-
+       ) } ) )
        if (verbose)
                print('Model selection')
-       tableauRecap = do.call( rbind, tableauRecap ) #stack list cells into a matrix
   tableauRecap = tableauRecap[rowSums(tableauRecap[, 2:4])!=0,]
-  tableauRecap = tableauRecap[(tableauRecap[,1])!=Inf,]
+  tableauRecap = tableauRecap[!is.infinite(tableauRecap[,1]),]
   data = cbind(1:dim(tableauRecap)[1], tableauRecap[,2], tableauRecap[,2], tableauRecap[,1])
 
-       require(capushe)
-  modSel = capushe(data, n)
+  modSel = capushe::capushe(data, n)
   indModSel <-
                if (selecMod == 'DDSE')
                        as.numeric(modSel@DDSE@model)