Реализация регрессии гребня: Выбор интеллектуальной сетки для ?

Я реализую 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$ $\df(\lambda_1) > y$ $\lambda_1,\lambda_2,\ldots$ $\lambda_0$ .
Следствие 1 (b) : Более того, если мы начнем с , то первый шаг приведет к , откуда он будет монотонно увеличиваться до решения по предыдущему следствию (см. Предостережение). ниже). Интуитивно, этот последний факт следует из того, что, если мы начнем справа от корня, производная слишком мала из-за выпуклости и поэтому первый шаг Ньютона приведет нас куда-то слева от корня. NB, поскольку не является вообще выпуклым для отрицательных $\lambda_1 > \lambda_0$ $\lambda_2 \leq \lambda_0$ $\df$ $\df$ $\lambda$ это дает веские основания предпочитать начинать слева от нужного корня. В противном случае нам нужно дважды проверить, что шаг Ньютона не привел к отрицательному значению для предполагаемого корня, что может поместить нас где-то в невыпуклую часть . Следствие 1 (c) : Как только мы нашли корень для некоторого и затем ищем корень для некоторого , используя такой, что качестве нашего начального предположения гарантирует, что мы начинаем слева от второго корня. Таким образом, наша конвергенция гарантированно будет монотонной оттуда. $\df$
$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$

Это предполагает, что для всех . Если это не так, то та же самая оценка имеет место, рассматривая только положительное и заменяя числом положительных . NB : Поскольку при условии, что все , то , поэтому границы всегда нетривиальны (например, нижняя граница всегда неотрицательна). $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

Очень эффективный алгоритм, заданный сеткой желаемых степеней свободы в состоит в том, чтобы отсортировать их по убыванию, а затем последовательно найти корень каждого из них, используя предыдущий корень в качестве отправной точки для следующего 1. Мы можем уточнить это далее, проверив, больше ли каждый корень, чем нижняя граница для следующего корня, и, если нет, мы можем вместо этого начать следующую итерацию с нижней границы. $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})$

Если вы используете нормальное уравнение в качестве решателя или вычисляете дисперсию-ковариацию, вы уже должны были вычислить . Этот подход работает лучше всего, если вы оцениваете коэффициенты при различных значениях . $(X^{\top}X + \lambda I_{p})^{-1}$ $\lambda$

Источник: https://onlinecourses.science.psu.edu/stat857/node/155

— Хосе Баян Сантьяго Кальдерон
источник