Variabilità nei risultati di cv.glmnet

Sto usando cv.glmnetper trovare predittori. L'impostazione che utilizzo è la seguente:

lassoResults<-cv.glmnet(x=countDiffs,y=responseDiffs,alpha=1,nfolds=cvfold)
bestlambda<-lassoResults$lambda.min

results<-predict(lassoResults,s=bestlambda,type="coefficients")

choicePred<-rownames(results)[which(results !=0)]

Per assicurarsi che i risultati sono riproducibili io set.seed(1). I risultati sono molto variabili. Ho eseguito esattamente lo stesso codice 100 per vedere quanto variabili fossero i risultati. Nelle corse 98/100 era sempre stato selezionato un predittore particolare (a volte solo da solo); sono stati selezionati altri predittori (il coefficiente era diverso da zero) di solito 50/100 volte.

Quindi mi dice che ogni volta che la validazione incrociata è in esecuzione, probabilmente selezionerà un diverso lambda migliore, perché la randomizzazione iniziale delle pieghe è importante. Altri hanno riscontrato questo problema ( risultati CV.glmnet ) ma non esiste una soluzione suggerita.

Sto pensando che forse quello che mostra 98/100 è probabilmente abbastanza fortemente correlato a tutti gli altri? I risultati si stabilizzano se eseguo LOOCV ( ), ma sono curioso di sapere perché sono così variabili quando nfold < n .$\text{fold-size} = n$$\text{nfold} < n$

Il punto qui è che nelle cv.glmnetpieghe K ("parti") vengono scelte casualmente.

Nella convalida incrociata di K-fold il set di dati è diviso in $K$ parti parti vengono utilizzate per prevedere la parte K-th (questo viene fatto K volte, usando una parte K diversa ogni volta). Questo viene fatto per tutti i lambda, ed è quello che dà il più piccolo errore di convalida incrociata.$K-1$$K$$K$lambda.min

Questo è il motivo per cui quando lo usi i risultati non cambiano: ogni gruppo ne fa uno, quindi non c'è molta scelta per igruppi$nfolds = n$$K$

Dal cv.glmnet()manuale di riferimento:

Si noti inoltre che i risultati di cv.glmnet sono casuali, poiché le pieghe sono selezionate a caso. Gli utenti possono ridurre questa casualità eseguendo cv.glmnet molte volte e calcolando la media delle curve di errore.

### cycle for doing 100 cross validations
### and take the average of the mean error curves
### initialize vector for final data.frame with Mean Standard Errors
MSEs <- NULL
for (i in 1:100){
                 cv <- cv.glmnet(y, x, alpha=alpha, nfolds=k)  
                 MSEs <- cbind(MSEs, cv$cvm)
             }
  rownames(MSEs) <- cv$lambda
  lambda.min <- as.numeric(names(which.min(rowMeans(MSEs))))

MSE è il frame di dati che contiene tutti gli errori per tutti i lambda (per le 100 esecuzioni), lambda.minè il tuo lambda con un errore medio minimo.

$\lambda$$\alpha$$\alpha$$\lambda$$\alpha$ coppie ).

$\alpha$$\lambda$ e quindi li trattano come una distribuzione di valori (una variabile casuale).

Quindi, per ogni predittore ottengo:

• coefficiente medio
• deviazione standard
• 5 riepilogo numeri (mediana, quartili, min e max)
• la percentuale di volte è diversa da zero (cioè ha un'influenza)

In questo modo ottengo una descrizione abbastanza solida dell'effetto del predittore. Una volta che hai distribuzioni per i coefficienti, puoi eseguire qualsiasi roba statistica che ritieni valga la pena ottenere CI, valori p, ecc ... ma non ho ancora indagato su questo.

Questo metodo può essere utilizzato con più o meno qualsiasi metodo di selezione che mi viene in mente.

Aggiungerò un'altra soluzione, che gestisce il bug in @ Alice's a causa della mancanza di lambda, ma non richiede pacchetti extra come @Max Ghenis. Grazie a tutte le altre risposte - tutti fanno punti utili!

lambdas = NULL
for (i in 1:n)
{
    fit <- cv.glmnet(xs,ys)
    errors = data.frame(fit$lambda,fit$cvm)
    lambdas <- rbind(lambdas,errors)
}
# take mean cvm for each lambda
lambdas <- aggregate(lambdas[, 2], list(lambdas$fit.lambda), mean)

# select the best one
bestindex = which(lambdas[2]==min(lambdas[2]))
bestlambda = lambdas[bestindex,1]

# and now run glmnet once more with it
fit <- glmnet(xy,ys,lambda=bestlambda)

La risposta di Alice funziona bene nella maggior parte dei casi, ma a volte si verificano errori a causa della cv.glmnet$lambdarestituzione a volte di risultati di diversa lunghezza, ad esempio:

Errore nei rownames <- (tmp, value = c (0.135739830284452, 0.12368107787663,: lunghezza di 'dimnames' [1] non uguale all'estensione dell'array.

OptimLambdasotto dovrebbe funzionare nel caso generale, ed è anche più veloce sfruttando l' mclapplyelaborazione parallela ed evitando i loop.

Lambdas <- function(...) {
  cv <- cv.glmnet(...)
  return(data.table(cvm=cv$cvm, lambda=cv$lambda))
}

OptimLambda <- function(k, ...) {
  # Returns optimal lambda for glmnet.
  #
  # Args:
  #   k: # times to loop through cv.glmnet.
  #   ...: Other args passed to cv.glmnet.
  #
  # Returns:
  #   Lambda associated with minimum average CV error over runs.
  #
  # Example:
  #   OptimLambda(k=100, y=y, x=x, alpha=alpha, nfolds=k)
  #
  require(parallel)
  require(data.table)
  MSEs <- data.table(rbind.fill(mclapply(seq(k), function(dummy) Lambdas(...))))
  return(MSEs[, list(mean.cvm=mean(cvm)), lambda][order(mean.cvm)][1]$lambda)
}

È possibile controllare la casualità se si imposta esplicitamente foldid. Ecco un esempio di CV 5 volte

library(caret)
set.seed(284)
flds <- createFolds(responseDiffs, k = cvfold, list = TRUE, returnTrain = FALSE)
foldids = rep(1,length(responseDiffs))
foldids[flds$Fold2] = 2
foldids[flds$Fold3] = 3
foldids[flds$Fold4] = 4
foldids[flds$Fold5] = 5

Ora esegui cv.glmnet con questi foldids.

lassoResults<-cv.glmnet(x=countDiffs,y=responseDiffs,alpha=1,foldid = foldids)

Otterrai gli stessi risultati ogni volta.