Implementando regressão de cume: Selecionando uma grade inteligente para ?

Estou implementando Ridge Regression em um módulo Python / C e me deparei com esse "pequeno" problema. A idéia é que eu queira provar os graus efetivos de liberdade mais ou menos igualmente espaçados (como o gráfico na página 65, nos "Elementos do aprendizado estatístico" ), ou seja, exemplo: que são os autovalores da matriz , de a . Uma maneira fácil de definir o primeiro limite é deixar (assumindo que ), em que

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$ é uma constante pequena e representa aproximadamente o grau mínimo de liberdade que você deseja amostrar (por exemplo,

c = 0.1

$c=0.1$ ). O segundo limite é obviamente

λ_{min} = 0

$\lambda_{\min}=0$ .

Como o título sugere, preciso amostrar $\lambda$ de $\lambda_{\min}$ a $\lambda_{\max}$ em uma escala em que $\mathrm{df}(\lambda)$ seja amostrada (aproximadamente), digamos, em $0.1$ intervalos de $c$ para $p$ ... há uma maneira fácil de fazer isso? Eu pensei em resolver a equação $\mathrm{df}(\lambda)$ para cada $\lambda$ usando o método Newton-Raphson, mas isso adicionará muitas iterações, especialmente quando $p$ for grande. Alguma sugestão?

ridge-regression

— Néstor
fonte

Essa função é uma função racional convexa decrescente de

λ \geq 0

$\lambda \geq 0$ . As raízes, principalmente se escolhidas em uma grade diádica, devem ser muito rápidas de encontrar.

— cardeal

@ cardinal, você provavelmente está certo. No entanto, se possível, eu gostaria de saber se há alguma grade "padrão". Por exemplo, tentei obter uma grade executando , onde e funcionou muito bem para alguns graus de liberdade, mas, como , explodiu. Isso me fez pensar que talvez houvesse uma maneira legal de escolher a grade para os 's, é o que estou perguntando. Se isso não existir, eu também ficaria feliz em saber (como eu poderia deixar o método Newton-Rapson feliz em meu código, sabendo que "não existe melhor maneira").

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

Para ter uma idéia melhor das possíveis dificuldades que você está enfrentando, quais são os valores típicos e os piores casos de ? Existe algo que você sabe a priori sobre a distribuição de autovalores?

p

$p$

— cardeal

@ cardinal, os valores típicos de no meu aplicativo variam de a , mas quero torná-lo o mais geral possível. Sobre a distribuição de autovalores, não muito. é uma matriz que contém preditores em suas colunas, que nem sempre são ortogonais.

p

$p$

15

$15$

40

$40$

X

$X$

— Néstor

Newton-Raphson normalmente encontra raízes com precisão de dentro de a etapas para e pequenos valores de ; quase nunca mais de etapas. Para valores maiores, ocasionalmente são necessários até passos. Como cada etapa requer cálculos de , a quantidade total de computação é inconseqüente. De fato, o número de etapas parece não depender de se um bom valor inicial for escolhido (eu escolho o que você usaria se todos os iguais à média).

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

Respostas:

Esta é uma resposta longa . Então, vamos dar uma versão resumida dela aqui.

Não há uma boa solução algébrica para esse problema de busca de raiz, por isso precisamos de um algoritmo numérico.
A função possui muitas propriedades agradáveis. Podemos utilizá-los para criar uma versão especializada do método de Newton para esse problema, com convergência monotônica garantida para cada raiz. $\mathrm{df}(\lambda)$
Mesmo o Rcódigo de morte encefálica, ausente de qualquer tentativa de otimização, pode calcular uma grade de tamanho 100 com em alguns segundos. Umcódigocuidadosamente escritoreduziria isso em pelo menos 2 a 3 ordens de magnitude. $p = 100\,000$ C

Existem dois esquemas abaixo para garantir a convergência monotônica. Um usa os limites mostrados abaixo, que parecem ajudar a salvar um ou dois passos de Newton ocasionalmente.

Exemplo : e uma grade uniforme para os graus de liberdade de tamanho 100. Os valores próprios são distribuídos por Pareto e, portanto, altamente distorcidos. Abaixo estão as tabelas do número de etapas de Newton para encontrar cada raiz. $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

Não haverá uma solução em forma fechada para esta , em geral, mas não é muito de estrutura presente, que pode ser usado para produzir soluções muito eficazes e seguros, utilizando métodos de determinação de raiz padrão.

Antes de aprofundar as coisas, vamos coletar algumas propriedades e conseqüências da função

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

Propriedade 0 : é uma função racional de . (Isso é aparente na definição.) Consequência 0 : Nenhuma solução algébrica geral existirá para encontrar a raiz . Isso ocorre porque existe um problema equivalente de busca de raiz polinomial de grau e, portanto, se não for extremamente pequeno (ou seja, menor que cinco), nenhuma solução geral existirá. Então, precisaremos de um método numérico. $\df$ $\lambda$
$\df(\lambda) - y = 0$ $p$ $p$

Propriedade 1 : a função é convexa e diminui em . (Pegue derivadas.) Consequência 1 (a) : O algoritmo de busca de raiz de Newton se comportará muito bem nessa situação. Seja os graus de liberdade desejados e a raiz correspondente, ou seja, . Em particular, se começarmos com qualquer valor inicial (então, ), a sequência de iterações da etapa Newton convergirá monotonicamente para o solução única $\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$ .
Consequência 1 (b) : Além disso, se com , o primeiro passo renderia , de onde aumentará monotonicamente para a solução pela consequência anterior (consulte a advertência abaixo). Intuitivamente, esse último fato se segue porque, se começarmos à direita da raiz, a derivada é "rasa" demais devido à convexidade de e, portanto, o primeiro passo de Newton nos levará a algum lugar à esquerda da raiz. NB Como não é $\lambda_1 > \lambda_0$ $\lambda_2 \leq \lambda_0$ $\df$ $\df$ geralmente convexo para negativo $\lambda$ , isso fornece um forte motivo para preferir começar à esquerda da raiz desejada. Caso contrário, precisamos verificar novamente se o passo de Newton não resultou em um valor negativo para a raiz estimada, o que pode nos colocar em algum lugar em uma porção não-convexa de . Consequência 1 (c) : depois de encontrarmos a raiz para alguns e, em seguida, procurarmos a raiz de alguns , usando $\df$
$y_1$ $y_2 < y_1$ $\lambda_1$ modo que como nosso palpite inicial garante que começamos à esquerda da segunda raiz. Portanto, nossa convergência é garantida para ser monotônica a partir daí. $\df(\lambda_1) = y_1$

Propriedade 2 : Existem limites razoáveis para fornecer pontos de partida "seguros". Usando argumentos de convexidade e desigualdade de Jensen, temos os seguintes limites Consequência 2 : Isso nos diz que a raiz satisfazendo obedece

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

Assim, até uma constante comum, imprensamos a raiz entre os meios harmônicos e aritméticos do

\begin{matrix} (⋆) & \frac{1}{\frac{1}{p} \sum_{Eu} d_{Eu}^{- 2}} (\frac{p - y}{y}) \leq λ_{0 0} \leq (\frac{1}{p} \sum_{Eu} d_{Eu}^{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$

Isso pressupõe que para todos . Se este não for o caso, então o mesmo limite detém por considerar unicamente o positivo e substituindo pelo número de positiva . NB : Como assumindo todos os $d_i > 0$ $i$ $d_i$ $p$ $d_i$ $\df(0) = p$ , então , de onde os limites são sempre não triviais (por exemplo, o limite inferior é sempre não negativo). $d_i > 0$ $y \in (0,p]$

Aqui está um gráfico de um exemplo "típico" de com . Sobrepusemos uma grade de tamanho 10 aos graus de liberdade. Estas são as linhas horizontais no gráfico. As linhas verdes verticais correspondem ao limite inferior em . $\df(\lambda)$ $p = 400$ $(\star)$

Exemplo de gráfico de DOF com grade e limites

Um algoritmo e algum exemplo de código R

Um algoritmo muito eficiente, dada uma grade dos graus de liberdade desejados em é classificá-los em ordem decrescente e, em seguida,encontrarsequencialmentea raiz de cada um, usando a raiz anterior como ponto de partida para o Podemos refinar isso ainda mais, verificando se cada raiz é maior que o limite inferior para a próxima raiz e, se não, podemos iniciar a próxima iteração no limite inferior. $y_1, \ldots y_n$ $(0,p]$

Aqui está um exemplo de código R, sem nenhuma tentativa de otimizá-lo. Como visto abaixo, ainda é bastante rápido, embora Rseja - para ser educado - horrivelmente, terrivelmente, terrivelmente lento nos loops.

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

Abaixo está o algoritmo completo final, que recebe uma grade de pontos e um vetor de ( não !). $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
}

Exemplo de chamada de função

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)

— cardeal
fonte

Favorecendo a pergunta para que eu possa voltar a esta resposta. Obrigado por postar esta análise detalhada, cardeal.

— Macro

Resposta incrível :-), muito obrigado cardeal pelas sugestões e pela resposta.

— Néstor

Além disso, existem alguns métodos que calcularão o caminho completo da regularização com eficiência:

Os pacotes acima são todos R, como você está usando Python, o scikit-learn contém implementações para cume, laço e rede elástica.

— sebp
fonte

A olsfunção no rmspacote R pode usar otimização numérica para encontrar a penalidade ideal usando AIC eficaz. Mas você deve aplicar a penalidade máxima que nem sempre é fácil.

— 31812 Frank Harrell

Uma alternativa possível, de acordo com a fonte abaixo, parece ser:

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

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

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

— José Bayoán Santiago Calderón
fonte