Реалізація регресії хребта: вибір інтелектуальної сітки для

Я реалізую Ridge Regression в модулі Python / C, і я натрапив на цю "маленьку" проблему. Ідея полягає в тому, що я хочу взяти вибірку ефективних ступенів свободи в більшій чи меншій мірі однаковою мірою (як сюжет на стор. 65 у розділі "Елементи статистичного навчання" ), тобто зразок: де - власні значення матриці , від до . Найпростіший спосіб встановити першу межу - дозволити (якщо вважати ), де

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

Як випливає з назви, тоді мені потрібно відібрати $\lambda$ з $\lambda_{\min}$ до $\lambda_{\max}$ в деякій шкалі, щоб $\mathrm{df}(\lambda)$ була вибірковою (приблизно), скажімо, у $0.1$ інтервали від $c$ до $p$ ... чи є простий спосіб це зробити? Я думав вирішити рівняння $\mathrm{df}(\lambda)$ для кожного $\lambda$ за допомогою методу Ньютона-Рафсона, але це додасть занадто багато ітерацій, особливо коли $p$ велике. Будь-які пропозиції?

ridge-regression

— Нестор
джерело

Ця функція є спадною опуклою раціональною функцією

λ \geq 0

$\lambda \geq 0$ . Коріння, особливо якщо вони вибрані через діадичну сітку, слід знайти дуже швидко.

— кардинал

@cardinal, ти, мабуть, маєш рацію. Однак, якщо можливо, я хотів би знати, чи є якась сітка "за замовчуванням". Наприклад, я спробував отримати сітку, зробивши , де і працював досить добре для деяких ступенів свободи, але як , вона вибухнула. Це змусило мене замислитися, що, можливо, був якийсь акуратний спосіб вибрати сітку для , про що я прошу. Якщо цього не існує, я також був би радий знати (так як я міг щасливо залишити метод Ньютона-Рапсона у своєму коді, знаючи, що "кращого способу не існує").

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

— Нестор

Для кращого уявлення про можливі труднощі, з якими ви стикаєтесь, які типові та найгірші значення ? Чи є щось, що ви знаєте апріорі про розподіл власних значень?

p

$p$

— кардинал

@cardinal, типові значення в моєму додатку становитимуть від до , але я хочу зробити це максимально загальним. Про розподіл власних значень не дуже. - це матриця, яка містить передбачувачі в стовпцях, які не завжди є ортогональними.

p

$p$

15

$15$

40

$40$

X

$X$

— Нестор

Ньютон-Рафсон зазвичай знаходить корені до точності протягом - кроків для та малих значень ; майже ніколи більше кроків. Для більших значень періодично потрібно до кроків. Оскільки кожен крок вимагає обчислень , загальна кількість обчислень є несуттєвою. Дійсно, кількість кроків, схоже, не залежить від якщо обрано хороше початкове значення (я вибираю той, який ви використали, якщо всі рівні їх середнього значення).

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

Відповіді:

Це довга відповідь . Отже, давайте тут наведемо короткочасну версію.

Немає приємного алгебраїчного вирішення цієї кореневої проблеми, тому нам потрібен числовий алгоритм.
Функція має безліч приємних властивостей. Ми можемо використати їх для створення спеціалізованої версії методу Ньютона для цієї проблеми із гарантованою монотонною конвергенцією до кожного кореня. $\mathrm{df}(\lambda)$
Навіть мертвий Rкод, відсутній будь-які спроби оптимізації, може обчислити сітку розміром 100 з за кілька секунд. Ретельно написанийкод зменшив би це щонайменше на 2–3 порядки. $p = 100\,000$ C

Нижче наведені дві схеми, які гарантують монотонну конвергенцію. Один використовує межі, показані нижче, які, здається, допомагають зберегти крок або два Ньютона при нагоді.

Приклад : та рівномірна сітка для ступенів свободи розміру 100. Власні значення розподілені парето, отже, сильно перекошені. Нижче наведено таблиці кількості кроків Ньютона для пошуку кожного кореня. $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

Там не буде замкнута форма вирішення для цього , в загальному випадку , але це багато структури даний час, які можуть бути використані для створення дуже ефективні і безпечних рішень з використанням стандартних кореневими ознайомчими методів.

Перш ніж надто глибоко копатись у речах, давайте збираємо деякі властивості та наслідки функції

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

Властивість 0 : - це раціональна функція . (Це видно з визначення.) Наслідок 0 : Не знайдеться загального алгебраїчного рішення для знаходження кореня . Це тому, що існує еквівалентна поліноміальна проблема кореневого пошуку ступеня і тому, якщо не надзвичайно малий (тобто менше п’яти), загального рішення не буде. Отже, нам знадобиться числовий метод. $\df$ $\lambda$
$\df(\lambda) - y = 0$ $p$ $p$

Властивість 1 : Функція опукла і зменшується на . (Візьміть похідні.) Наслідок 1 (а) : Алгоритм пошуку коренів Ньютона в цій ситуації буде вести себе дуже добре. Нехай - бажані ступені свободи, а - відповідний корінь, тобто . Зокрема, якщо ми почнемо з будь-якого початкового значення (значить, $\df$ $\lambda \geq 0$
$y$ $\lambda_0$ $y = \df(\lambda_0)$ $\lambda_1 < \lambda_0$ ), то послідовність ітерацій кроків Ньютона монотоннобуде сходитисядо унікального рішення . Наслідок 1 (b): Крім того, якби ми починали з , топершийкрок дав би $\df(\lambda_1) > y$ $\lambda_1,\lambda_2,\ldots$ $\lambda_0$
$\lambda_1 > \lambda_0$ $\lambda_2 \leq \lambda_0$ , звідки він монотонно зросте до рішення попереднім наслідком (див. попередження нижче). Інтуїтивно цей останній факт випливає, тому що якщо ми почнемо праворуч від кореня, похідна буде "занадто" дрібною через опуклості і тому перший крок Ньютона перенесе нас кудись зліва від кореня. Примітка : Так як це НЕ в загальному опуклу для негативного , це дає серйозні підстави вважати за краще починаючи зліва від необхідного кореня. В іншому випадку нам потрібно ще раз перевірити, чи не призвів крок Ньютона до негативного значення для оціненого кореня, яке може розмістити нас десь у невипуклій частині . $\df$ $\df$ $\lambda$ $\df$
Наслідок 1 (с) : Після того, як ми знайшли корінь для деякого а потім шукаємо корінь з деякого , використовуючи такий, що як наша початкова здогадка гарантує, що ми починаємо зліва від другого кореня. Отже, наше зближення гарантовано буде монотонним звідти. $y_1$ $y_2 < y_1$ $\lambda_1$ $\df(\lambda_1) = y_1$

Властивість 2 : Існують розумні межі, щоб дати "безпечні" вихідні точки. Використовуючи аргументи опуклості та нерівності Дженсена, ми маємо такі межі Наслідок 2: Це говорить нам, що корінь задовольняє підкоряється

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

Це передбачає, що для всіх . Якщо це не так, то ця ж межа дотримується, враховуючи лише додатне і замінюючи на кількість позитивних . Примітка : Оскільки якщо вважати всі , то , причому межі завжди нетривіальні (наприклад, нижня межа завжди невід'ємна). $d_i > 0$ $i$ $d_i$ $p$ $d_i$ $\df(0) = p$ $d_i > 0$ $y \in (0,p]$

Ось сюжет "типового" прикладу з . Ми наклали сітку розміром 10 для ступенів свободи. Це горизонтальні лінії в сюжеті. Вертикальні зелені лінії відповідають нижній межі в . $\df(\lambda)$ $p = 400$ $(\star)$

Example dof plot with grid and bounds

Алгоритм і деякий приклад R-коду

Дуже ефективний алгоритм, що дає сітку потрібних ступенів свободи in - сортувати їх у порядку зменшення, а потім послідовно знаходити корінь кожного, використовуючи попередній корінь як вихідну точку для Ми можемо додатково уточнити це, перевіривши, чи кожен корінь перевищує нижню межу для наступного кореня, і, якщо ні, ми можемо почати наступну ітерацію на нижній межі. $y_1, \ldots y_n$ $(0,p]$

Ось декілька прикладів коду R, без спроб його оптимізації. Як видно нижче, він все ще досить швидкий, хоча Rце - ввічливо сказати - жахливо, жахливо, страшенно повільно в петлях.

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

Нижче представлений остаточний повний алгоритм, який бере сітку точок і вектор ( не !). $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
}

Зразок виклику функції

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)

— кардинальний
джерело

Улюблене питання, щоб я міг повернутися до цієї відповіді. Дякую, що опублікував цей детальний аналіз, кардинал.

— Макрос

Дивовижна відповідь :-), дякую великому кардиналу за пропозиції та відповідь.

— Нестор

Крім того, існує пара методів, які дозволять ефективно обчислити повний шлях регуляризації:

Наведені вище всі R-пакети, оскільки ви використовуєте Python, scikit-learn містить реалізацію для хребта, ласо та еластичної мережі.

— sebp
джерело

olsФункцію в R rmsпакеті можна використовувати чисельну оптимізацію , щоб знайти оптимальний штраф з використанням ефективної AIC. Але ви повинні забезпечити максимальний штраф, який не завжди є простим.

— Френк Харрелл

Можливою альтернативою згідно з джерелом, поданим нижче, здається, є:

Рішення закритої форми: $df(\lambda) = tr(X(X^{\top} X + \lambda I_{p})^{-1}X^{\top})$

Should you be using the normal equation as the solver or computing the variance-covariance estimate, you should already have computed $(X^{\top}X + \lambda I_{p})^{-1}$ . This approach works best if you are estimating the coefficients at the various $\lambda$ .

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

— José Bayoán Santiago Calderón
джерело