Mise en œuvre de la régression des crêtes: sélectionner une grille intelligente pour

J'implémente Ridge Regression dans un module Python / C, et je suis tombé sur ce "petit" problème. L'idée est que je souhaite échantillonner les degrés de liberté effectifs plus ou moins également espacés (comme le graphique de la page 65 sur les "Éléments de l'apprentissage statistique" ), c'est-à-dire, échantillon: où sont les valeurs propres de la matrice , à partir de à . Un moyen simple de définir la première limite est de laisser (en supposant ), où

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$ est une petite constante et représente approximativement le degré de liberté minimum que vous souhaitez échantillonner (par exemple

c = 0.1

$c=0.1$ ). La deuxième limite est bien sûr

λ_{min} = 0

$\lambda_{\min}=0$ .

Comme le titre l'indique, j'ai besoin d'échantillonner $\lambda$ de $\lambda_{\min}$ à $\lambda_{\max}$ à une certaine échelle de telle sorte que $\mathrm{df}(\lambda)$ soit échantillonné (environ), par exemple, dans $0.1$ intervalle de $c$ à $p$ ... existe-t-il un moyen facile de le faire? J'ai pensé résoudre l'équation $\mathrm{df}(\lambda)$ pour chaque $\lambda$ utilisant une méthode de Newton-Raphson, mais cela ajoutera trop d'itérations, spécialement lorsque $p$ est grand. Aucune suggestion?

ridge-regression Néstor
la source

Cette fonction est une fonction rationnelle convexe décroissante de

λ \geq 0

$\lambda \geq 0$ . Les racines, en particulier si elles sont choisies sur une grille dyadique, devraient être très rapides à trouver.

cardinal

@cardinal, vous avez probablement raison. Cependant, si possible, j'aimerais savoir s'il existe une grille "par défaut". Par exemple, j'ai essayé d'obtenir une grille en faisant , où , et fonctionnait assez bien pour certains degrés de liberté, mais comme , il a explosé. Cela m'a fait me demander s'il y avait peut-être une bonne façon de choisir la grille pour les , c'est ce que je demande. Si cela n'existe pas, je serais également heureux de le savoir (car je pourrais laisser la méthode Newton-Rapson joyeusement dans mon code sachant "qu'il n'existe pas de meilleure façon").

λ = 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

Pour avoir une meilleure idée des difficultés potentielles que vous rencontrez, quelles sont les valeurs typiques et les pires cas de ? Y a-t-il quelque chose que vous savez a priori sur la distribution des valeurs propres?

p

$p$

cardinal

@cardinal, les valeurs typiques de dans mon application seraient comprises entre et , mais je veux que ce soit aussi général que possible. À propos de la distribution des valeurs propres, pas vraiment. est une matrice qui contient des prédicteurs dans ses colonnes, qui ne sont pas toujours orthogonales.

p

$p$

15

$15$

40

$40$

X

$X$

Néstor

Newton-Raphson trouve généralement des racines avec une précision de en à étapes pour et de petites valeurs de ; presque jamais plus de étapes. Pour des valeurs plus importantes, jusqu'à étapes sont parfois nécessaires. Étant donné que chaque étape nécessite des calculs , le montant total du calcul est sans conséquence. En effet, le nombre d'étapes ne semble pas dépendre de si une bonne valeur de départ est choisie (je choisis celle que vous utiliseriez si tous les égaux à leur moyenne).

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

Réponses:

Ceci est une longue réponse . Alors, donnons-en une version courte ici.

Il n'y a pas de bonne solution algébrique à ce problème de recherche de racine, nous avons donc besoin d'un algorithme numérique.
La fonction a beaucoup de belles propriétés. Nous pouvons les exploiter pour créer une version spécialisée de la méthode de Newton pour ce problème avec une convergence monotone garantie à chaque racine. $\mathrm{df}(\lambda)$
Même un Rcode mort cérébral en l' absence de toute tentative d'optimisation peut calculer une grille de taille 100 avec en quelques secondes. Un code soigneusement rédigé réduirait cela d'au moins 2 à 3 ordres de grandeur. $p = 100\,000$ C

Deux schémas sont donnés ci-dessous pour garantir la convergence monotone. On utilise les limites indiquées ci-dessous, qui semblent aider à enregistrer une étape de Newton ou deux à l'occasion.

Exemple : et une grille uniforme pour les degrés de liberté de taille 100. Les valeurs propres sont Pareto-distribuées, donc fortement asymétriques. Voici les tableaux du nombre d'étapes de Newton pour trouver chaque racine. $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

Il n'y aura pas de solution de forme fermée pour cela , en général, mais il y a beaucoup de structure présente qui peut être utilisée pour produire des solutions très efficaces et sûres en utilisant des méthodes de recherche de racines standard.

Avant de creuser trop profondément dans les choses, collectons quelques propriétés et conséquences de la fonction

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

Propriété 0 : est une fonction rationnelle de . (Cela ressort de la définition.) Conséquence 0 : aucune solution algébrique générale n'existera pour trouver la racine . En effet, il existe un problème de recherche de racines polynomial équivalent de degré et donc si n'est pas extrêmement petit (c'est-à-dire moins de cinq), aucune solution générale n'existera. Nous aurons donc besoin d'une méthode numérique. $\df$ $\lambda$
$\df(\lambda) - y = 0$ $p$ $p$

Propriété 1 : La fonction est convexe et décroissante sur . (Prenez les dérivés.) Conséquence 1 (a) : l'algorithme de recherche de racines de Newton se comportera très bien dans cette situation. Soit les degrés de liberté souhaités et la racine correspondante, c'est-à-dire . En particulier, si nous commençons avec une valeur initiale (donc, ), alors la séquence d'itérations de Newton convergera de façon monotone vers le solution unique $\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$ .
Conséquence 1 (b) : En outre, si nous , la première étape donnerait , d'où elle augmentera de façon monotone jusqu'à la solution par la conséquence précédente (voir la mise en garde au dessous de). Intuitivement, ce dernier fait suit parce que si nous commençons à droite de la racine, la dérivée est "trop" superficielle en raison de la convexité de et donc la première étape de Newton nous mènera quelque part à gauche de la racine. NB Puisque n'est pas en général convexe pour négatif $\lambda_1 > \lambda_0$ $\lambda_2 \leq \lambda_0$ $\df$ $\df$ $\lambda$ , cela fournit une bonne raison de préférer commencer à gauche de la racine souhaitée. Sinon, nous devons vérifier que l'étape de Newton n'a pas donné lieu à une valeur négative pour la racine estimée, ce qui peut nous placer quelque part dans une partie non convexe de . Conséquence 1 (c) : Une fois que nous avons trouvé la racine pour certains et que nous recherchons ensuite la racine à partir de certains , en utilisant telle sorte que comme garantie initiale, nous commençons à la gauche de la deuxième racine. Ainsi, notre convergence est garantie d'être monotone à partir de là. $\df$
$y_1$ $y_2 < y_1$ $\lambda_1$ $\df(\lambda_1) = y_1$

Propriété 2 : Des limites raisonnables existent pour donner des points de départ "sûrs". En utilisant des arguments de convexité et l'inégalité de Jensen, nous avons les limites suivantes Conséquence 2 : cela nous indique que la racine satisfaisant obéit Donc, jusqu'à une constante commune, nous avons pris en sandwich la racine entre les moyennes harmonique et arithmétique du .

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

Cela suppose que pour tout . Si ce n'est pas le cas, alors la même borne tient en considérant uniquement le positif et en remplaçant par le nombre de positifs . NB : Puisque supposant que tous les , alors , d'où les bornes sont toujours non triviales (par exemple, la borne inférieure est toujours non négative). $d_i > 0$ $i$ $d_i$ $p$ $d_i$ $\df(0) = p$ $d_i > 0$ $y \in (0,p]$

Voici un tracé d'un exemple "typique" de avec . Nous avons superposé une grille de taille 10 pour les degrés de liberté. Ce sont les lignes horizontales de l'intrigue. Les lignes vertes verticales correspondent à la borne inférieure de . $\df(\lambda)$ $p = 400$ $(\star)$

Exemple de tracé DOF avec grille et bornes

Un algorithme et un exemple de code R

Un algorithme très efficace étant donné une grille de degrés de liberté in consiste à les trier par ordre décroissant puis à trouver séquentiellement la racine de chacun, en utilisant la racine précédente comme point de départ pour les éléments suivants 1. Nous pouvons affiner cela en vérifiant si chaque racine est supérieure à la borne inférieure de la racine suivante, et sinon, nous pouvons commencer l'itération suivante à la borne inférieure à la place. $y_1, \ldots y_n$ $(0,p]$

Voici un exemple de code R, sans aucune tentative d'optimisation. Comme on le voit ci-dessous, il est encore assez rapide même s'il Rest - pour le dire poliment - horriblement, terriblement, terriblement lent aux boucles.

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

Ci-dessous se trouve l'algorithme complet final qui prend une grille de points, et un vecteur du ( pas !). $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
}

Exemple d'appel de fonction

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)

cardinal
la source

Favorisant la question pour que je puisse me référer à cette réponse. Merci d'avoir publié cette analyse détaillée, cardinal.

Macro

Réponse étonnante :-), merci beaucoup cardinal pour les suggestions ET la réponse.

Néstor

De plus, il existe deux méthodes qui permettront de calculer efficacement le chemin de régularisation complet:

Ce qui précède sont tous des packages R, car vous utilisez Python, scikit-learn contient des implémentations pour ridge, lasso et élastique net.

sebp
la source

La olsfonction du rmspackage R peut utiliser l'optimisation numérique pour trouver la pénalité optimale à l'aide d'un AIC efficace. Mais il faut prévoir la peine maximale qui n'est pas toujours facile.

Frank Harrell

Une alternative possible selon la source ci-dessous semble être:

$df(\lambda) = tr(X(X^{\top} X + \lambda I_{p})^{-1}X^{\top})$

$(X^{\top}X + \lambda I_{p})^{-1}$ $\lambda$

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

José Bayoán Santiago Calderón
la source