Implementazione della regressione della cresta: selezione di una griglia intelligente per

Sto implementando Ridge Regression in un modulo Python / C, e ho riscontrato questo "piccolo" problema. L'idea è che voglio campionare i gradi di libertà effettivi più o meno equamente distanziati (come la trama a pagina 65 su "Elementi di apprendimento statistico" ), cioè campione:

d f (λ) = \sum_{i = 1}^{p} \frac{d_{i}^{2}}{d_{i}^{2} + λ},

$\mathrm{df}(\lambda)=\sum_{i=1}^{p}\frac{d_i^2}{d_i^2+\lambda},$

d_{i}^{2}

$d_i^2$

X^{T} X

$X^TX$

d f (λ_{max}) \approx 0

$\mathrm{df}(\lambda_{\max})\approx 0$

d f (λ_{min}) = p

$\mathrm{df}(\lambda_{\min})=p$

λ_{max} = \sum_{i}^{p} d_{i}^{2} / c

$\lambda_{\max}=\sum_i^p d_i^2/c$

λ_{max} ≫ d_{i}^{2}

$\lambda_{\max} \gg d_i^2$

c

$c$

c = 0.1

$c=0.1$

λ_{min} = 0

$\lambda_{\min}=0$

Come suggerisce il titolo, quindi, ho bisogno di campionare $\lambda$ da $\lambda_{\min}$ a $\lambda_{\max}$ in una scala tale che $\mathrm{df}(\lambda)$ sia campionato (approssimativamente), diciamo, in $0.1$ intervalli da $c$ a $p$ ... c'è un modo semplice per farlo? Ho pensato di risolvere l'equazione $\mathrm{df}(\lambda)$ per ogni $\lambda$ usando un metodo Newton-Raphson, ma questo aggiungerà troppe iterazioni, specialmente quando $p$ è grande. Eventuali suggerimenti?

ridge-regression

— Néstor
fonte

Questa funzione è una funzione razionale convessa decrescente di

λ \geq 0

$\lambda \geq 0$ . Le radici, in particolare se scelte su una griglia diadica, dovrebbero essere molto veloci da trovare.

— cardinale il

@cardinale, probabilmente hai ragione. Tuttavia, se possibile, vorrei sapere se esiste una griglia "predefinita". Ad esempio, ho provato a ottenere una griglia facendo , dove e ha funzionato abbastanza bene per alcuni gradi di libertà, ma come , è saltato fuori. Questo mi ha fatto pensare che forse c'era un modo preciso per scegliere la griglia per 's, che è quello che sto chiedendo. Se questo non esiste, sarei anche felice di saperlo (poiché potrei lasciare felicemente il metodo Newton-Rapson nel mio codice sapendo che "non esiste un modo migliore").

λ = l o g (s) λ_{m a x} / l o g (s_{m a x})

$\lambda=log(s)\lambda_{max}/log(s_{max})$

s = (1, 2, . . ., s_{m a x})

$s=(1,2,...,s_{max})$

d f (λ) \to p

$df(\lambda)\to p$

λ

$\lambda$

— Néstor,

Per avere una migliore idea delle potenziali difficoltà che si incontrano, quali sono i valori tipici e nel caso peggiore di ? C'è qualcosa che conosci a priori sulla distribuzione degli autovalori?

p

$p$

— cardinale il

@cardinal, i valori tipici di nella mia applicazione vanno da a , ma voglio renderlo il più generale possibile. A proposito della distribuzione degli autovalori, non molto. è una matrice che contiene predittori nelle sue colonne, che non sono sempre ortogonali.

p

$p$

15

$15$

40

$40$

X

$X$

— Néstor,

Newton-Raphson tipicamente trova radici per precisione entro a passaggi per e piccoli valori di ; quasi mai più di passaggi. Per valori più grandi, occasionalmente sono necessari fino a passaggi. Poiché ogni passaggio richiede calcoli , la quantità totale di calcolo è irrilevante. In effetti, il numero di passaggi non sembra dipendere da se viene scelto un buon valore iniziale ( quello che se tutti i uguali alla loro media).

10^{- 12}

$10^{-12}$

3

$3$

4

$4$

p = 40

$p=40$

d f (λ)

$df(\lambda)$

6

$6$

30

$30$

O (p)

$O(p)$

p

$p$

d_{i}

$d_i$

— whuber

Si tratta di una risposta lunga . Quindi, diamo una versione breve di questo qui.

Non esiste una buona soluzione algebrica a questo problema di ricerca delle radici, quindi abbiamo bisogno di un algoritmo numerico.
La funzione ha molte belle proprietà. Possiamo sfruttarli per creare una versione specializzata del metodo di Newton per questo problema con una convergenza monotonica garantita a ciascuna radice. $\mathrm{df}(\lambda)$
Perfino il Rcodice morto in assenza di qualsiasi tentativo di ottimizzazione può calcolare una griglia di dimensioni 100 con in pochi secondi. Un codice scritto con cura ridurrebbe questo di almeno 2-3 ordini di grandezza. $p = 100\,000$ C

Di seguito sono riportati due schemi per garantire la convergenza monotonica. Uno usa i limiti mostrati di seguito, che sembrano aiutare a salvare uno o due passi di Newton a volte.

Esempio : e una griglia uniforme per i gradi di libertà di dimensione 100. Gli autovalori sono distribuiti da Pareto, quindi fortemente inclinati. Di seguito sono riportate le tabelle del numero di passaggi di Newton per trovare ciascuna radice. $p = 100\,000$

# Table of Newton iterations per root.
# Without using lower-bound check.
  1  3  4  5  6 
  1 28 65  5  1 
# Table with lower-bound check.
  1  2  3 
  1 14 85

Non ci sarà una soluzione in forma chiusa per questo , in generale, ma v'è un sacco di struttura attuale che può essere utilizzato per produrre soluzioni molto efficaci e sicure con metodi radice-finding standard.

Prima di scavare troppo a fondo nelle cose, raccogliamo alcune proprietà e conseguenze della funzione

d f (λ) = \sum_{i = 1}^{p} \frac{d_{i}^{2}}{d_{i}^{2} + λ} .

$\newcommand{\df}{\mathrm{df}} \df(\lambda) = \sum_{i=1}^p \frac{d_i^2}{d_i^2 + \lambda} \>.$

La proprietà 0 : è una funzione razionale di . (Ciò è evidente dalla definizione.) Conseguenza 0 : non esiste una soluzione algebrica generale per trovare la radice . Questo perché esiste un equivalente problema di individuazione delle radici polinomiali di grado e quindi se non è estremamente piccolo (cioè meno di cinque), non esisterà una soluzione generale. Quindi, avremo bisogno di un metodo numerico. $\df$ $\lambda$
$\df(\lambda) - y = 0$ $p$ $p$

Proprietà 1 : la funzione è convessa e decrescente su . (Prendi i derivati.) Conseguenza 1 (a) : l'algoritmo di ricerca delle radici di Newton si comporterà molto bene in questa situazione. Sia il grado desiderato di libertà e la radice corrispondente, cioè . In particolare, se iniziamo con qualsiasi valore iniziale (quindi, ), allora la sequenza di iterazioni di Newton convergeranno monotonicamente al soluzione unica $\df$ $\lambda \geq 0$
$y$ $\lambda_0$ $y = \df(\lambda_0)$ $\lambda_1 < \lambda_0$ $\df(\lambda_1) > y$ $\lambda_1,\lambda_2,\ldots$ $\lambda_0$ .
Conseguenza 1 (b) : Inoltre, se dovessimo iniziare con , il primo passo produrrebbe e quindi il primo passo di Newton ci porterà da qualche parte a sinistra della radice. NB Poiché non è generalmente convesso per negativo $\lambda_1 > \lambda_0$ $\lambda_2 \leq \lambda_0$ , da cui aumenterà monotonicamente alla soluzione dalla conseguenza precedente (vedi avvertenza di seguito). Intuitivamente, questo ultimo fatto segue perché se iniziamo a destra della radice, la derivata è "troppo" superficiale a causa della convessità di , questo fornisce un motivo forte per preferire iniziare a sinistra della radice desiderata. Altrimenti, dobbiamo ricontrollare che il passaggio di Newton non abbia comportato un valore negativo per la radice stimata, che potrebbe posizionarci da qualche parte in una porzione non convessa di . Conseguenza 1 (c) : una volta trovata la radice per alcuni e quindi stiamo cercando la radice da alcuni $\df$ $\df$ $\lambda$ $\df$
$y_1$ $y_2 < y_1$ , usando tale che come la nostra ipotesi iniziale garantiamo che iniziamo a la sinistra della seconda radice. Quindi, la nostra convergenza è garantita per essere monotona da lì. $\lambda_1$ $\df(\lambda_1) = y_1$

Proprietà 2 : esistono limiti ragionevoli per dare punti di partenza "sicuri". Utilizzando argomenti di convessità e disuguaglianza di Jensen, abbiamo i seguenti limiti Conseguenza 2 : questo ci dice che la radice soddisfacente

\frac{p}{1 + \frac{λ}{p} \sum d_{i}^{- 2}} \leq d f (λ) \leq \frac{p \sum_{i} d_{i}^{2}}{\sum_{i} d_{i}^{2} + p λ} .

$\frac{p}{1+ \frac{\lambda}{p}\sum d_i^{-2}} \leq \df(\lambda) \leq \frac{p \sum_i d_i^2}{\sum_i d_i^2 + p \lambda} \>.$

λ_{0}

$\lambda_0$

d f (λ_{0}) = y

$\df(\lambda_0) = y$ obbedisce Quindi, fino a una costante comune, abbiamo inserito la radice tra i mezzi armonici e aritmetici di .

\begin{matrix} (⋆) & \frac{1}{\frac{1}{p} \sum_{i} d_{i}^{- 2}} (\frac{p - y}{y}) \leq λ_{0} \leq (\frac{1}{p} \sum_{i} d_{i}^{2}) (\frac{p - y}{y}) . \end{matrix}

$\frac{1}{\frac{1}{p}\sum_i d_i^{-2}}\left(\frac{p - y}{y}\right) \leq \lambda_0 \leq \left(\frac{1}{p}\sum_i d_i^2\right) \left(\frac{p - y}{y}\right) \>. \tag{$\star$}$

d_{i}^{2}

$d_i^2$

Ciò presuppone che per tutti . In caso contrario, lo stesso limite vale considerando solo il positivo e sostituendo con il numero di positivo . NB : da allora $d_i > 0$ $i$ $d_i$ $p$ $d_i$ $\df(0) = p$ assumendo tutto , quindi , da cui i limiti sono sempre non banali (ad esempio, il limite inferiore è sempre non negativo). $d_i > 0$ $y \in (0,p]$

Ecco un diagramma di un esempio "tipico" di con $\df(\lambda)$ $p = 400$ . Abbiamo sovrapposto una griglia di dimensioni 10 per i gradi di libertà. Queste sono le linee orizzontali nella trama. Le linee verdi verticali corrispondono al limite inferiore in . $(\star)$

Esempio di trama con griglia e limiti

Un algoritmo e qualche esempio di codice R.

Un algoritmo molto efficiente dato una griglia di gradi di libertà desiderati $y_1, \ldots y_n$ in è quello di ordinarli in ordine decrescente e quindi trovare sequenzialmente la radice di ciascuno, usando la radice precedente come punto di partenza per il seguente 1. Possiamo perfezionarlo ulteriormente controllando se ogni radice è maggiore del limite inferiore per la radice successiva e, in caso contrario, possiamo invece iniziare la successiva iterazione sul limite inferiore. $(0,p]$

Ecco alcuni esempi di codice R, senza tentativi di ottimizzazione. Come visto di seguito, è ancora abbastanza veloce anche se Rè - per dirla educatamente - terrificante, terribile, terribilmente terribilmente lento agli anelli.

# Newton's step for finding solutions to regularization dof.

dof <- function(lambda, d) { sum(1/(1+lambda / (d[d>0])^2)) }
dof.prime <- function(lambda, d) { -sum(1/(d[d>0]+lambda / d[d>0])^2) }

newton.step <- function(lambda, y, d)
{ lambda - (dof(lambda,d)-y)/dof.prime(lambda,d) }

# Full Newton step; Finds the root of y = dof(lambda, d).
newton <- function(y, d, lambda = NA, tol=1e-10, smart.start=T)
{
    if( is.na(lambda) || smart.start )
        lambda <- max(ifelse(is.na(lambda),0,lambda), (sum(d>0)/y-1)/mean(1/(d[d>0])^2))
    iter <- 0
    yn   <- Inf
    while( abs(y-yn) > tol )
    {
        lambda <- max(0, newton.step(lambda, y, d)) # max = pedantically safe
        yn <- dof(lambda,d)
        iter = iter + 1
    }
    return(list(lambda=lambda, dof=y, iter=iter, err=abs(y-yn)))
}

Di seguito è riportato l'algoritmo completo finale che accetta una griglia di punti e un vettore di ( non $d_i$ $d_i^2$ !).

newton.grid <- function(ygrid, d, lambda=NA, tol=1e-10, smart.start=TRUE)
{
    p <- sum(d>0)
    if( any(d < 0) || all(d==0) || any(ygrid > p) 
        || any(ygrid <= 0) || (!is.na(lambda) && lambda < 0) )
        stop("Don't try to fool me. That's not nice. Give me valid inputs, please.")
    ygrid <- sort(ygrid, decreasing=TRUE)
    out    <- data.frame()
    lambda <- NA
    for(y in ygrid)
    {
        out <- rbind(out, newton(y,d,lambda, smart.start=smart.start))
        lambda <- out$lambda[nrow(out)]
    }
    out
}

Chiamata di funzione di esempio

set.seed(17)
p <- 100000
d <- sqrt(sort(exp(rexp(p, 10)),decr=T))
ygrid <- p*(1:100)/100
# Should take ten seconds or so.
out <- newton.grid(ygrid,d)

— cardinale
fonte

Favorire la domanda in modo da poter fare riferimento a questa risposta. Grazie per aver pubblicato questa analisi dettagliata, cardinale.

— Macro,

Risposta incredibile :-), grazie mille cardinale per i suggerimenti E la risposta.

— Néstor,

Inoltre, esistono un paio di metodi che calcoleranno in modo efficiente l'intero percorso di regolarizzazione:

Quanto sopra sono tutti i pacchetti R, poiché stai usando Python, scikit-learn contiene implementazioni per ridge, lazo e rete elastica.

— SEBP
fonte

La olsfunzione nel rmspacchetto R può usare l'ottimizzazione numerica per trovare la penalità ottimale usando AIC efficace. Ma devi fornire la massima penalità che non è sempre facile.

— Frank Harrell,

Una possibile alternativa secondo la fonte qui sotto sembra essere:

La soluzione in forma chiusa: $df(\lambda) = tr(X(X^{\top} X + \lambda I_{p})^{-1}X^{\top})$

Se dovessi usare l'equazione normale come solutore o calcolare la stima della varianza-covarianza, dovresti già aver calcolato . Questo approccio funziona meglio se si stanno valutando i coefficienti ai vari . $(X^{\top}X + \lambda I_{p})^{-1}$ $\lambda$

Fonte: https://onlinecourses.science.psu.edu/stat857/node/155

— José Bayoán Santiago Calderón
fonte