536d2eec8526504e0c4f7fcd883e54badea58f49
[agghoo.git] / R / compareTo.R
1 #' standardCV_core
2 #'
3 #' Cross-validation method, added here as an example.
4 #' Parameters are described in ?agghoo and ?AgghooCV
5 standardCV_core <- function(data, target, task, gmodel, params, loss, CV) {
6 n <- nrow(data)
7 shuffle_inds <- NULL
8 if (CV$type == "vfold" && CV$shuffle)
9 shuffle_inds <- sample(n, n)
10 list_testinds <- list()
11 for (v in seq_len(CV$V))
12 list_testinds[[v]] <- get_testIndices(n, CV, v, shuffle_inds)
13 gmodel <- agghoo::Model$new(data, target, task, gmodel, params)
14 best_error <- Inf
15 best_model <- NULL
16 for (p in seq_len(gmodel$nmodels)) {
17 error <- Reduce('+', lapply(seq_len(CV$V), function(v) {
18 testIdx <- list_testinds[[v]]
19 d <- splitTrainTest(data, target, testIdx)
20 model_pred <- gmodel$get(d$dataTrain, d$targetTrain, p)
21 prediction <- model_pred(d$dataTest)
22 loss(prediction, d$targetTest)
23 }) )
24 if (error <= best_error) {
25 newModel <- list(model=gmodel$get(data, target, p),
26 param=gmodel$getParam(p))
27 if (error == best_error)
28 best_model[[length(best_model)+1]] <- newModel
29 else {
30 best_model <- list(newModel)
31 best_error <- error
32 }
33 }
34 }
35 best_model[[ sample(length(best_model), 1) ]]
36 }
37
38 #' standardCV_run
39 #'
40 #' Run and eval the standard cross-validation procedure.
41 #' Parameters are rather explicit except "floss", which corresponds to the
42 #' "final" loss function, applied to compute the error on testing dataset.
43 #'
44 #' @export
45 standardCV_run <- function(
46 dataTrain, dataTest, targetTrain, targetTest, floss, verbose, ...
47 ) {
48 args <- list(...)
49 task <- checkTask(args$task, targetTrain)
50 modPar <- checkModPar(args$gmodel, args$params)
51 loss <- checkLoss(args$loss, task)
52 CV <- checkCV(args$CV)
53 s <- standardCV_core(
54 dataTrain, targetTrain, task, modPar$gmodel, modPar$params, loss, CV)
55 if (verbose)
56 print(paste( "Parameter:", s$param ))
57 p <- s$model(dataTest)
58 err <- floss(p, targetTest)
59 if (verbose)
60 print(paste("error CV:", err))
61 invisible(err)
62 }
63
64 #' agghoo_run
65 #'
66 #' Run and eval the agghoo procedure.
67 #' Parameters are rather explicit except "floss", which corresponds to the
68 #' "final" loss function, applied to compute the error on testing dataset.
69 #'
70 #' @export
71 agghoo_run <- function(
72 dataTrain, dataTest, targetTrain, targetTest, floss, verbose, ...
73 ) {
74 args <- list(...)
75 CV <- checkCV(args$CV)
76 # Must remove CV arg, or agghoo will complain "error: unused arg"
77 args$CV <- NULL
78 a <- do.call(agghoo, c(list(data=dataTrain, target=targetTrain), args))
79 a$fit(CV)
80 if (verbose) {
81 print("Parameters:")
82 print(unlist(a$getParams()))
83 }
84 pa <- a$predict(dataTest)
85 err <- floss(pa, targetTest)
86 if (verbose)
87 print(paste("error agghoo:", err))
88 invisible(err)
89 }
90
91 #' compareTo
92 #'
93 #' Compare a list of learning methods (or run only one), on data/target.
94 #'
95 #' @param data Data matrix or data.frame
96 #' @param target Target vector (generally)
97 #' @param method_s Either a single function, or a list
98 #' (examples: agghoo_run, standardCV_run)
99 #' @param rseed Seed of the random generator (-1 means "random seed")
100 #' @param floss Loss function to compute the error on testing dataset.
101 #' @param verbose TRUE to request methods to be verbose.
102 #' @param ... arguments passed to method_s function(s)
103 #'
104 #' @export
105 compareTo <- function(
106 data, target, method_s, rseed=-1, floss=NULL, verbose=TRUE, ...
107 ) {
108 if (rseed >= 0)
109 set.seed(rseed)
110 n <- nrow(data)
111 test_indices <- sample( n, round(n / ifelse(n >= 500, 10, 5)) )
112 d <- splitTrainTest(data, target, test_indices)
113
114 # Set error function to be used on model outputs (not in core method)
115 task <- checkTask(list(...)$task, target)
116 if (is.null(floss)) {
117 floss <- function(y1, y2) {
118 ifelse(task == "classification", mean(y1 != y2), mean(abs(y1 - y2)))
119 }
120 }
121
122 # Run (and compare) all methods:
123 runOne <- function(o) {
124 o(d$dataTrain, d$dataTest, d$targetTrain, d$targetTest, floss, verbose, ...)
125 }
126 errors <- c()
127 if (is.list(method_s))
128 errors <- sapply(method_s, runOne)
129 else if (is.function(method_s))
130 errors <- runOne(method_s)
131 invisible(errors)
132 }
133
134 #' compareMulti
135 #'
136 #' Run compareTo N times in parallel.
137 #'
138 #' @inheritParams compareTo
139 #' @param N Number of calls to method(s)
140 #' @param nc Number of cores. Set to parallel::detectCores() if undefined.
141 #' Set it to any value <=1 to say "no parallelism".
142 #' @param verbose TRUE to print task numbers and "Errors:" in the end.
143 #'
144 #' @export
145 compareMulti <- function(
146 data, target, method_s, N=100, nc=NA, floss=NULL, verbose=TRUE, ...
147 ) {
148 require(parallel)
149 if (is.na(nc))
150 nc <- parallel::detectCores()
151
152 # "One" comparison for each method in method_s (list)
153 compareOne <- function(n) {
154 if (verbose)
155 print(n)
156 compareTo(data, target, method_s, n, floss, verbose=FALSE, ...)
157 }
158
159 errors <- if (nc >= 2) {
160 parallel::mclapply(1:N, compareOne, mc.cores = nc)
161 } else {
162 lapply(1:N, compareOne)
163 }
164 if (verbose)
165 print("Errors:")
166 Reduce('+', errors) / N
167 }
168
169 #' compareRange
170 #'
171 #' Run compareMulti on several values of the parameter V.
172 #'
173 #' @inheritParams compareMulti
174 #' @param V_range Values of V to be tested.
175 #'
176 #' @export
177 compareRange <- function(
178 data, target, method_s, N=100, nc=NA, floss=NULL, V_range=c(10,15,20,), ...
179 ) {
180 args <- list(...)
181 # Avoid warnings if V is left unspecified:
182 CV <- suppressWarnings( checkCV(args$CV) )
183 errors <- lapply(V_range, function(V) {
184 args$CV$V <- V
185 do.call(compareMulti, c(list(data=data, target=target, method_s=method_s,
186 N=N, nc=nc, floss=floss, verbose=F), args))
187 })
188 print(paste(V_range, errors))
189 }