Gratregression implementieren: Intelligentes Gitter für ?

Ich implementiere Ridge Regression in einem Python / C-Modul und bin auf dieses "kleine" Problem gestoßen. Die Idee ist, dass ich die effektiven Freiheitsgrade mehr oder weniger gleichmäßig verteilt abtasten möchte (wie die grafische Darstellung auf Seite 65 unter "Elemente des statistischen Lernens" ), dh Beispiel: wobei die Eigenwerte der Matrix aus bis . Eine einfache Möglichkeit, die erste Grenze festzulegen, besteht darin, (unter der Annahme von ) zu lassen, wobei

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$ ist eine kleine Konstante und repräsentiert ungefähr den Mindestfreiheitsgrad, den Sie abtasten möchten (z. B.

c = 0.1

$c=0.1$ ). Die zweite Grenze ist natürlich

λ_{min} = 0

$\lambda_{\min}=0$ .

Wie aus dem Titel hervorgeht, muss ich $\lambda$ von $\lambda_{\min}$ bis $\lambda_{\max}$ in einer gewissen Skala abtasten, sodass $\mathrm{df}(\lambda)$ (ungefähr) abgetastet wird, z $0.1$ Intervalle von $c$ bis $p$ ... gibt es eine einfache Möglichkeit, dies zu tun? Ich dachte, die Gleichung $\mathrm{df}(\lambda)$ für jedes $\lambda$ mit einer Newton-Raphson-Methode zu lösen , aber dies fügt zu viele Iterationen hinzu, insbesondere wenn $p$ groß ist. Irgendwelche Vorschläge?

ridge-regression

— Néstor
quelle

Diese Funktion ist eine abnehmende konvexe rationale Funktion von

λ \geq 0

$\lambda \geq 0$ . Wurzeln sollten, besonders wenn sie über einem dyadischen Gitter ausgewählt werden, sehr schnell zu finden sein.

— Kardinal

@ Cardinal, Sie haben wahrscheinlich Recht. Wenn möglich, würde ich gerne wissen, ob es ein "Standard" -Raster gibt. Ich habe zum Beispiel versucht, ein Gitter zu erhalten, indem ich

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

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

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

$s=(1,2,...,s_{max})$ und funktionierte für einige Freiheitsgrade ziemlich gut, aber als

d f (λ) \to p

$df(\lambda)\to p$ , blies es aus. Das ließ mich wundern, dass es vielleicht eine gute Möglichkeit gab, das Gitter für die

zu wählen

λ

$\lambda$ , was ich frage . Wenn dies nicht existiert, würde ich es auch gerne wissen (da ich die Newton-Rapson-Methode gerne in meinem Code belassen könnte, wenn ich wüsste, dass es keinen besseren Weg gibt).

— Néstor

Was sind typische und Worst-Case-Werte für um sich ein Bild von den möglichen Schwierigkeiten zu machen, auf die Sie stoßen ? Wissen Sie a priori etwas über die Eigenwertverteilung?

p

$p$

— Kardinal

@ Kardinal, typische Werte von in meiner Anwendung reichen von bis , aber ich möchte es so allgemein wie möglich machen. Über die Eigenwertverteilung eigentlich nicht viel. ist eine Matrix, deren Spalten Prädiktoren enthalten, die nicht immer orthogonal sind.

p

$p$

15

$15$

40

$40$

X

$X$

— Néstor

Newton-Raphson findet in der Regel Wurzeln mit einer Genauigkeit von innerhalb von bis Schritten für und kleine Werte von ; fast nie mehr als Schritte. Bei größeren Werten sind gelegentlich bis zu Schritte erforderlich. Da für jeden Schritt -Berechnungen erforderlich sind , ist der gesamte Rechenaufwand ohne Belang. Tatsächlich scheint die Anzahl der Schritte nicht von abzuhängen, wenn ein guter Startwert gewählt wird (ich wähle denjenigen, den Sie verwenden würden, wenn alle dem Mittelwert entsprechen).

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

Antworten:

Das ist eine lange Antwort . Lassen Sie uns hier eine Kurzgeschichtenversion davon geben.

Es gibt keine gute algebraische Lösung für dieses Problem, also brauchen wir einen numerischen Algorithmus.
Die Funktion hat viele schöne Eigenschaften. Wir können diese nutzen, um eine spezialisierte Version von Newtons Methode für dieses Problem mit garantierter monotoner Konvergenz für jede Wurzel zu erstellen . $\mathrm{df}(\lambda)$
Sogar gehirntoter RCode ohne Optimierungsversuche kann in wenigen Sekunden ein Raster der Größe 100 mit 100.000 berechnen . Sorgfältig geschriebener Code würde dies um mindestens 2–3 Größenordnungen reduzieren. $p = 100\,000$ C

Im Folgenden werden zwei Schemata angegeben, um eine monotone Konvergenz zu gewährleisten. Man verwendet die unten gezeigten Grenzen, die gelegentlich helfen, ein oder zwei Newton-Schritte zu sparen.

Beispiel : und ein einheitliches Gitter für die Freiheitsgrade der Größe 100. Die Eigenwerte sind paretoverteilt und daher stark verzerrt. Unten finden Sie Tabellen mit der Anzahl der Newton-Schritte, um die einzelnen Wurzeln zu finden. $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

Es wird im Allgemeinen keine geschlossene Lösung dafür geben , aber es ist eine Menge Struktur vorhanden, die verwendet werden kann, um sehr effektive und sichere Lösungen unter Verwendung von Standardmethoden zum Auffinden von Wurzeln zu erzeugen.

Bevor wir uns zu sehr mit Dingen , wollen wir einige Eigenschaften und Konsequenzen der Funktion

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} \>.$

Eigenschaft 0 : ist eine rationale Funktion von . (Dies geht aus der Definition hervor.) Konsequenz 0 : Es gibt keine allgemeine algebraische Lösung zum Finden der Wurzel . Dies liegt daran, dass es ein äquivalentes Polynomwurzelfindungsproblem des Grades Wenn also nicht extrem klein ist (dh weniger als fünf), gibt es keine allgemeine Lösung. Wir brauchen also eine numerische Methode. $\df$ $\lambda$
$\df(\lambda) - y = 0$ $p$ $p$

Eigenschaft 1 : Die Funktion ist konvex und nimmt bei . (Nehmen Sie Derivate.) Konsequenz 1 (a) : Newtons Algorithmus zum Auffinden von Wurzeln wird sich in dieser Situation sehr gut verhalten . Sei die gewünschten Freiheitsgrade und die entsprechende Wurzel, dh . Insbesondere wenn wir mit einem Anfangswert (also ) beginnen, konvergiert die Folge von Newton-Schritt-Iterationen monoton gegen einzigartige Lösung $\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$ .
Konsequenz 1 (b) : Wenn wir mit , würde der erste Schritt , von wo aus er sich durch die vorherige Konsequenz monoton zur Lösung erhöht (siehe Warnung) unten). Intuitiv folgt diese letzte Tatsache, denn wenn wir rechts von der Wurzel beginnen, ist die Ableitung aufgrund der Konvexität von "zu" flach, und so führt uns der erste Newton-Schritt irgendwo links von der Wurzel. NB Da ist nicht im allgemeinen konvexen für negative $\lambda_1 > \lambda_0$ $\lambda_2 \leq \lambda_0$ $\df$ $\df$ $\lambda$ Dies ist ein wichtiger Grund, lieber links von der gewünschten Wurzel zu beginnen. Andernfalls müssen wir noch einmal überprüfen, ob der Newton-Schritt zu keinem negativen Wert für die geschätzte Wurzel geführt hat, was dazu führen kann, dass wir uns irgendwo in einem nicht konvexen Teil von . Konsequenz 1 (c) : Sobald wir die Wurzel für ein und dann von einem nach der Wurzel suchen , verwenden wir so dass unsere anfängliche Vermutung ist das links von der zweiten Wurzel. Somit ist unsere Konvergenz von dort aus garantiert monoton. $\df$
$y_1$ $y_2 < y_1$ $\lambda_1$ $\df(\lambda_1) = y_1$

Eigenschaft 2 : Es gibt vernünftige Grenzen, um "sichere" Startpunkte zu geben. Unter Verwendung von Konvexitätsargumenten und Jensens Ungleichung ergeben sich folgende Grenzen: Consequence 2 : Dies sagt uns , dass die Wurzel erfüllt gehorcht Wir haben also bis auf eine gemeinsame Konstante die Wurzel zwischen dem harmonischen und dem arithmetischen Mittel von eingeklemmt .

\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$

\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$

Dies setzt voraus, dass für alle . Ist dies nicht der Fall, so gilt dieselbe Schranke, indem nur das positive und durch die Anzahl des positiven . Anmerkung : Da Annahme von , ist , von wo aus die Grenzen immer nichttrivial sind (z. B. ist die untere Grenze immer nichtnegativ). $d_i > 0$ $i$ $d_i$ $p$ $d_i$ $\df(0) = p$ $d_i > 0$ $y \in (0,p]$

Hier ist eine Darstellung eines "typischen" Beispiels für mit . Für die Freiheitsgrade haben wir ein Raster der Größe 10 eingeblendet. Dies sind die horizontalen Linien im Plot. Die vertikalen grünen Linien entsprechen der unteren Grenze in . $\df(\lambda)$ $p = 400$ $(\star)$

Beispiel dof Grundstück mit Raster und Grenzen

Ein Algorithmus und ein Beispiel für einen R-Code

Ein sehr effizienter Algorithmus, der ein Gitter gewünschter Freiheitsgrade in besteht darin, sie in absteigender Reihenfolge zu sortieren und dann nacheinander die Wurzel von jedem zu finden, wobei die vorherige Wurzel als Ausgangspunkt für die folgenden verwendet wird Wir können dies weiter verfeinern, indem wir prüfen, ob jede Wurzel größer als die Untergrenze für die nächste Wurzel ist, und wenn nicht, können wir die nächste Iteration stattdessen an der Untergrenze beginnen. $y_1, \ldots y_n$ $(0,p]$

Hier ist ein Beispielcode, in dem Rkeine Optimierungsversuche unternommen wurden. Wie unten zu sehen, ist es immer noch ziemlich schnell, obwohl Res - höflich ausgedrückt - entsetzlich, schrecklich, schrecklich langsam in Schleifen ist.

# 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)))
}

Unten ist der endgültige vollständige Algorithmus, der ein Gitter von Punkten und einen Vektor von ( nicht !) . $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
}

Beispiel Funktionsaufruf

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)

— Kardinal
quelle

Ich bevorzuge die Frage, damit ich auf diese Antwort zurückgreifen kann. Vielen Dank für die Veröffentlichung dieser detaillierten Analyse, Kardinal.

— Makro

Erstaunliche Antwort :-), vielen Dank Kardinal für die Vorschläge und die Antwort.

— Néstor

Darüber hinaus gibt es eine Reihe von Methoden, mit denen der vollständige Regularisierungspfad effizient berechnet werden kann:

Die obigen sind alle R-Pakete, da Sie Python verwenden, enthält scikit-learn Implementierungen für Ridge, Lasso und Elastic Net.

— sebp
quelle

Die olsFunktion in dem R- rmsPaket kann die numerische Optimierung verwenden, um die optimale Strafe unter Verwendung eines effektiven AIC zu finden. Aber Sie müssen die maximale Strafe bereitstellen, die nicht immer einfach ist.

— Frank Harrell

Eine mögliche Alternative nach der folgenden Quelle scheint zu sein:

Die Lösung in geschlossener Form: $df(\lambda) = tr(X(X^{\top} X + \lambda I_{p})^{-1}X^{\top})$

Wenn Sie die normale Gleichung als Löser verwenden oder die Varianz-Kovarianz-Schätzung berechnen, sollten Sie bereits berechnet haben . Dieser Ansatz funktioniert am besten, wenn Sie die Koeffizienten bei den verschiedenen schätzen . $(X^{\top}X + \lambda I_{p})^{-1}$ $\lambda$

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

— José Bayoán Santiago Calderón
quelle