Considere un buen viejo problema de regresión con predictores $p$ y tamaño de muestra $n$ . La sabiduría usual es que OLS estimador será overfit y generalmente será superado por la arista estimador de

$$\hat\beta = (X^\top X + \lambda I)^{-1}X^\top y.$$ Es estándar utilizar la validación cruzada para encontrar un parámetro de regularización óptimo $\lambda$ . Aquí uso 10 veces el CV. Actualización Aclaración: cuando $n<p$ , por "OLS estimador" entiendo "OLS mínimo en normas estimador" dada por β $$\hat\beta_\text{OLS} = (X^\top X)^+X^\top y = X^+ y.$$

Tengo un conjunto de datos con $n=80$ y $p>1000$ . Todos los predictores están estandarizados, y hay bastantes que (solos) pueden hacer un buen trabajo al predecir $y$ . Si selecciono aleatoriamente una pequeña ish, digamos $p=50<n$ , número de predictores, obtengo una curva CV razonable: los valores grandes de $\lambda$ producen cero R cuadrado, los valores pequeños de $\lambda$ producen R cuadrado negativo (debido al sobreajuste ) y hay algún máximo en el medio. Para $p=100>n$ la curva se ve similar. Sin embargo, para $p$mucho más grande que eso, por ejemplo, $p=1000$ , no obtengo ningún máximo: la meseta de la curva, lo que significa que OLS con $\lambda\to 0$ funciona tan bien como la regresión de cresta con óptimo $\lambda$.

¿Cómo es posible y qué dice sobre mi conjunto de datos? ¿Me estoy perdiendo algo obvio o es realmente contra-intuitivo? ¿Cómo puede haber alguna diferencia cualitativa entre $p=100$ y $p=1000$ dado que ambos son mayores que $n$ ?

¿En qué condiciones la solución OLS de norma mínima para $n<p$ no se sobreajusta?

---

Actualización: Hubo algo de incredulidad en los comentarios, así que aquí hay un ejemplo reproducible usando glmnet. Yo uso Python pero los usuarios de R adaptarán fácilmente el código.

%matplotlib notebook

import numpy as np
import pylab as plt
import seaborn as sns; sns.set()

import glmnet_python    # from https://web.stanford.edu/~hastie/glmnet_python/
from cvglmnet import cvglmnet; from cvglmnetPlot import cvglmnetPlot

# 80x1112 data table; first column is y, rest is X. All variables are standardized
mydata = np.loadtxt('../q328630.txt')   # file is here https://pastebin.com/raw/p1cCCYBR
y = mydata[:,:1]
X = mydata[:,1:]

# select p here (try 1000 and 100)
p = 1000

# randomly selecting p variables out of 1111
np.random.seed(42)
X = X[:, np.random.permutation(X.shape[1])[:p]]

fit = cvglmnet(x = X.copy(), y = y.copy(), alpha = 0, standardize = False, intr = False, 
               lambdau=np.array([.0001, .001, .01, .1, 1, 10, 100, 1000, 10000, 100000]))
cvglmnetPlot(fit)
plt.gcf().set_size_inches(6,3)
plt.tight_layout()

Una regularización natural ocurre debido a la presencia de muchos componentes pequeños en el PCA teórico de . Estos componentes pequeños se usan implícitamente para ajustar el ruido utilizando coeficientes pequeños. Cuando se utiliza la norma mínima OLS, se ajusta el ruido con muchos componentes independientes pequeños y esto tiene un efecto de regularización equivalente a la regularización de Ridge. Esta regularización es a menudo demasiado fuerte, y es posible compensarla usando "anti-regularización" conocida como Ridge negativo . En ese caso, verá que el mínimo de la curva MSE aparece para valores negativos de λ .$x$$\lambda$

Por PCA teórico, quiero decir:

Sea una distribución normal multivariada. Hay una isometría lineal f tal como u = f ( x ) ∼ N ( 0 , D ) donde D es diagonal: los componentes de u son independientes. D se obtiene simplemente diagonalizando Σ .$x\sim N(0,\Sigma)$$f$$u=f(x)\sim N(0,D)$$D$$u$$D$$\Sigma$

Ahora el modelo se puede escribir y = f ( β ) . f ( x ) + ϵ (una isometría lineal conserva el producto de puntos). Si escribe γ = f ( β ) , el modelo puede escribirse y = γ . u + ϵ . Además ‖ β ‖ = ‖ γ $y=\beta.x+\epsilon$$y=f(\beta).f(x)+\epsilon$$\gamma=f(\beta)$$y=\gamma.u+\epsilon$$\|\beta\|=\|\gamma\|$por lo tanto, los métodos de ajuste como Ridge o la norma mínima OLS son perfectamente isomórficos: el estimador de es la imagen por f del estimador de y = β . x + ϵ .$y=\gamma.u+\epsilon$$f$$y=\beta.x+\epsilon$

La PCA teórica transforma los predictores no independientes en predictores independientes. Solo se relaciona vagamente con la PCA empírica donde se usa la matriz de covarianza empírica (que difiere mucho de la teórica con un tamaño de muestra pequeño). La PCA teórica no es prácticamente computable, pero solo se usa aquí para interpretar el modelo en un espacio predictor ortogonal.

Veamos qué sucede cuando agregamos muchos predictores independientes de varianza pequeña a un modelo:

Teorema

La regularización de crestas con coeficiente es equivalente (cuando p → ∞ ) a:$\lambda$$p\rightarrow\infty$

• agregando predictores independientes falsos (centrados e idénticamente distribuidos) cada uno con varianza $p$$\frac{\lambda}{p}$
• ajustando el modelo enriquecido con estimador OLS de norma mínima
• manteniendo solo los parámetros para los predictores verdaderos

(bosquejo de) Prueba

Vamos a demostrar que las funciones de costo son asintóticamente iguales. Dividamos el modelo en predictores reales y falsos: . La función de costo de Ridge (para los predictores verdaderos) se puede escribir:$y=\beta x+\beta'x'+\epsilon$

$$\mathrm{cost}_\lambda=\|\beta\|^2+\frac{1}{\lambda}\|y-X\beta\|^2$$

Cuando se utiliza la norma mínima OLS, la respuesta se ajusta perfectamente: el término de error es 0. La función de costo se refiere solo a la norma de los parámetros. Se puede dividir en los parámetros verdaderos y los falsos:

$$\mathrm{cost}_{\lambda,p}=\|\beta\|^2+\inf\{\|\beta'\|^2 \mid X'\beta'=y-X\beta\}$$

En la expresión correcta, la solución de la norma mínima viene dada por:

$$\beta'=X'^+(y-X\beta )$$

Ahora usando SVD para :$X'$

$$X'=U\Sigma V$$

$$X'^{+}=V^\top\Sigma^{+} U^\top$$

Vemos que la norma de depende esencialmente de los valores singulares de X ′ + que son los recíprocos de los valores singulares de X ′ . La versión normalizada de X ′ es $\beta'$$X'^+$$X'$$X'$. He visto literatura y se conocen bien los valores singulares de grandes matrices aleatorias. Parapynsuficientemente grande, mínimosminmáximo y smaxvalores singulares se aproximan mediante (verteorema 1.1):$\sqrt{p/\lambda} X'$$p$$n$$s_\min$$s_\max$

smax(

$$s_\min(\sqrt{p/\lambda}X')\approx \sqrt p\left(1-\sqrt{n/p}\right)$$ $$s_\max(\sqrt{p/\lambda}X')\approx \sqrt p \left(1+\sqrt{n/p}\right)$$

Como, para grande , $p$ tiende hacia 0, solo podemos decir que todos los valores singulares se aproximan por$\sqrt{n/p}$ . Así:$\sqrt p$

$$\|\beta'\|\approx\frac{1}{\sqrt\lambda}\|y-X\beta\|$$

Finalmente:

$$\mathrm{cost}_{\lambda,p}\approx\|\beta\|^2+\frac{1}{\lambda}\|y-X\beta\|^2=\mathrm{cost}_\lambda$$

Nota : no importa si mantiene los coeficientes de los predictores falsos en su modelo. La varianza introducida por es $\beta'x'$. Por lo tanto, aumenta su MSE en un factor1+n/pque tiende a 1 de todos modos. De alguna manera, no necesita tratar a los predictores falsos de manera diferente a los reales.$\frac{\lambda}{p}\|\beta'\|^2\approx\frac{1}{p}\|y-X\beta\|^2\approx\frac{n}{p}MSE(\beta)$$1+n/p$

Ahora, de vuelta a los datos de @ ameeba. Después de aplicar PCA teórico a (se supone que es normal), x se transforma mediante una isometría lineal en una variable u cuyos componentes son independientes y se ordenan en orden de variación decreciente. El problema y = β x + ϵ es equivalente al problema transformado y = γ u + ϵ .$x$$x$$u$$y=\beta x+\epsilon$$y=\gamma u+\epsilon$

Ahora imagine que la varianza de los componentes se ve así:

Considere muchos de los últimos componentes, llame a la suma de su varianza λ . Cada uno tiene una varianza aproximadamente igual a λ /$p$$\lambda$$\lambda/p$ y son independientes. Desempeñan el papel de predictores falsos en el teorema.

Este hecho es más claro en el modelo de Jonny @: sólo el primer componente del PCA teórica se correlaciona con (que es proporcional ¯ x ) y tiene gran varianza. Todos los demás componentes (proporcionales a x i - ¯ x ) tienen una varianza comparativamente muy pequeña (escriba la matriz de covarianza y diagonalícela para ver esto) y desempeñan el papel de predictores falsos. Calculé que la regularización aquí corresponde (aprox.) A N anterior ( 0 , $y$$\overline{x}$$x_i-\overline{x}$enγ1mientras que el verdaderoγ 2 1 =$N(0,\frac{1}{p^2})$$\gamma_1$ . Esto definitivamente se encoge demasiado. Esto es visible por el hecho de que el MSE final es mucho más grande que el MSE ideal. El efecto de regularización es demasiado fuerte.$\gamma_1^2=\frac{1}{p}$

A veces es posible mejorar esta regularización natural por Ridge. Primero, a veces se necesita en el teorema realmente grande (1000, 10000 ...) para rivalizar seriamente con Ridge y la finitud de p es como una imprecisión. Pero también muestra que Ridge es una regularización adicional sobre una regularización implícita naturalmente existente y, por lo tanto, solo puede tener un efecto muy pequeño. A veces, esta regularización natural ya es demasiado fuerte y Ridge incluso puede no ser una mejora. Más que esto, es mejor usar anti-regularización: cresta con coeficiente negativo. Esto muestra MSE para el modelo de @ jonny ( p = 1000 ), usando λ ∈ R :$p$$p$$p=1000$$\lambda\in\mathbb{R}$

Gracias a todos por la gran discusión en curso. El quid de la cuestión parece ser que la OLS de norma mínima está realizando efectivamente una contracción similar a la regresión de cresta. Esto parece ocurrir siempre que . Irónicamente, agregar predictores de ruido puro puede incluso usarse como una forma muy extraña o regularización.$p\gg n$

---

Parte I. Demostración con datos artificiales y CV analítico.

A @Jonny (+1) se le ocurrió un ejemplo artificial muy simple que adaptaré ligeramente aquí. de n × p tamaño e y se generan de manera que todas las variables son gaussianas con varianza unitaria, y la correlación entre cada predictor y la respuesta es ρ . Arreglaré ρ = .2 .$X$$n\times p$$y$$\rho$$\rho=.2$

Usaré CV de dejar uno afuera porque hay una expresión analítica para el error al cuadrado: se conoce como PRENSA , "suma de cuadrados pronosticada". dondeeison residuose=Y-Y=Y-Hy,yHes la matriz hatH=X(X⊤X+λI)-1X⊤=US

$$\text{PRESS} = \sum_i \left( \frac{e_i}{1-H_{ii}}\right)^2,$$ $e_i$ $$e = y - \hat y = y - Hy,$$ $H$en términos de SVDX=USV⊤. Esto permite replicar los resultados de @ Jonny sin usary sin realizar una validación cruzada (estoy trazando la relación de PRENSA a la suma de cuadrados dey): $$H = X (X^\top X + \lambda I)^{-1} X^\top=U\frac{S^2}{S^2+\lambda} U^\top$$ $X=USV^\top$glmnet$y$

Este enfoque analítico permite calcular el límite en . Simplemente conectar λ = 0 en la fórmula de PRENSA no funciona: cuando n < p y λ = 0 , los residuos son todos cero y la matriz de sombrero es la matriz de identidad con unos en la diagonal, lo que significa que las fracciones en la ecuación de PRENSA son indefinido Pero si calculamos el límite en λ → 0 , entonces corresponderá a la solución OLS de norma mínima con λ = 0 .$\lambda\to 0$$\lambda=0$$n<p$$\lambda=0$$\lambda \to 0$$\lambda=0$

El truco es hacer la expansión de Taylor de la matriz del sombrero cuando : H = U $\lambda\to 0$Aquípresenté lamatriz de GramG=XX⊤=US2U⊤.

$$H=U\frac{1}{1+\lambda/S^2} U^\top\approx U(1-\lambda/S^2) U^\top = I - \lambda US^{-2}U^\top = I-\lambda G^{-1}.$$ $G=XX^\top = US^2U^\top$

Ya casi hemos terminado: Lambda se canceló, así que aquí tenemos el valor límite. Lo tracé con un gran punto negro en la figura de arriba (en los paneles dondep>n), y coincide perfectamente.

$$\text{PRESS} = \sum_i\Big( \frac{\lambda [G^{-1}y]_i}{\lambda G^{-1}_{ii}}\Big)^2 = \sum_i\Big( \frac{ [G^{-1}y]_i}{G^{-1}_{ii}}\Big)^2.$$ $p>n$

Actualización 21 de febrero. La fórmula anterior es exacta, pero podemos obtener una idea haciendo más aproximaciones. Parece que tiene valores aproximadamente iguales en la diagonal incluso si S tiene valores muy desiguales (probablemente porque U mezcla todos los valores propios bastante bien). Así que para cada i tenemos que G - 1 i i ≈ ⟨ S - 2 ⟩ donde corchetes angulares denotan promediado. Usando esta aproximación, podemos reescribir: PRESIONE ≈ ‖ S - $G^{-1}$$S$$U$$i$$G^{-1}_{ii}\approx \langle S^{-2} \rangle$Esta aproximación se muestra en la figura anterior con círculos rojos abiertos.

$$\text{PRESS}\approx \Big\lVert \frac{S^{-2}}{\langle S^{-2} \rangle}U^\top y\Big\rVert^2.$$

Si esto será mayor o menor que depende de los valores singulares S . En esta simulación, y se correlaciona con la primera PC de X, por lo que U ⊤ 1 y es grande y todos los demás términos son pequeños. (En mis datos reales, y también está bien predicho por las PC principales.) Ahora, en el caso p ≫ n , si las columnas de X son lo suficientemente aleatorias, entonces todos los valores singulares estarán bastante cerca unos de otros (filas aproximadamente ortogonales ) El término "principal"$\lVert y \rVert^2 = \lVert U^\top y \rVert^2$$S$$y$$X$$U_1^\top y$$y$$p\gg n$$X$ se multiplicará por un factor menor que 1. Los términos hacia el final se multiplicarán por factores mayores que 1 pero no mucho mayores. En general, la norma disminuye. En contraste, en el caso de p ≳ n , habrá algunos valores singulares muy pequeños. Después de la inversión, se convertirán en grandes factores que aumentarán la norma general.$U_1^\top y$$p\gtrsim n$

[Este argumento es muy ondulado a mano; Espero que pueda hacerse más preciso.]

Como verificación de cordura, si cambio el orden de los valores singulares para S = diag(flipud(diag(S)));entonces, el MSE predicho está por encima de todas partes en el segundo y tercer paneles.$1$

figure('Position', [100 100 1000 300])
ps = [10, 100, 1000];

for pnum = 1:length(ps)
    rng(42)
    n = 80;
    p = ps(pnum);
    rho = .2;
    y = randn(n,1);
    X = repmat(y, [1 p])*rho + randn(n,p)*sqrt(1-rho^2);

    lambdas = exp(-10:.1:20);
    press = zeros(size(lambdas));
    [U,S,V] = svd(X, 'econ');
    % S = diag(flipud(diag(S)));   % sanity check

    for i = 1:length(lambdas)
        H = U * diag(diag(S).^2./(diag(S).^2 + lambdas(i))) * U';
        e = y - H*y;
        press(i) = sum((e ./ (1-diag(H))).^2);
    end

    subplot(1, length(ps), pnum)
    plot(log(lambdas), press/sum(y.^2))
    hold on
    title(['p = ' num2str(p)])
    plot(xlim, [1 1], 'k--')

    if p > n
        Ginv = U * diag(diag(S).^-2) * U';
        press0 = sum((Ginv*y ./ diag(Ginv)).^2);
        plot(log(lambdas(1)), press0/sum(y.^2), 'ko', 'MarkerFaceColor', [0,0,0]);

        press0approx = sum((diag(diag(S).^-2/mean(diag(S).^-2)) * U' * y).^2);
        plot(log(lambdas(1)), press0approx/sum(y.^2), 'ro');
    end
end

---

Parte II. Agregar predictores de ruido puro como una forma de regularización

$p>n$

$n=80$$p=40$$q$$\hat\beta$$p+q$$p$

¡¡¡FUNCIONA!!!

$p+q$$y$

rng(42)
n = 80;
p = 40;
rho = .2;
y = randn(n,1);
X = repmat(y, [1 p])*rho + randn(n,p)*sqrt(1-rho^2);

lambdas = exp(-10:.1:20);
press = zeros(size(lambdas));
[U,S,V] = svd(X, 'econ');

for i = 1:length(lambdas)
    H = U * diag(diag(S).^2./(diag(S).^2 + lambdas(i))) * U';
    e = y - H*y;
    press(i) = sum((e ./ (1-diag(H))).^2);
end

figure('Position', [100 100 1000 300])
subplot(121)
plot(log(lambdas), press/sum(y.^2))
hold on
xlabel('Ridge penalty (log)')
plot(xlim, [1 1], 'k--')
title('Ridge regression (n=80, p=40)')
ylim([0 2])

ps = [0 20 40 60 80 100 200 300 400 500 1000];
error = zeros(n, length(ps));
error_trunc = zeros(n, length(ps));
for fold = 1:n
    indtrain = setdiff(1:n, fold);
    for pi = 1:length(ps)
        XX = [X randn(n,ps(pi))];
        if size(XX,2) < size(XX,1)
            beta = XX(indtrain,:) \ y(indtrain,:);
        else
            beta = pinv(XX(indtrain,:)) * y(indtrain,:);
        end
        error(fold, pi) = y(fold) - XX(fold,:) * beta;
        error_trunc(fold, pi) = y(fold) - XX(fold,1:size(X,2)) * beta(1:size(X,2));
    end
end

subplot(122)
hold on
plot(ps, sum(error.^2)/sum(y.^2), 'k.--')
plot(ps, sum(error_trunc.^2)/sum(y.^2), '.-')
legend({'Entire beta', 'Truncated beta'}, 'AutoUpdate','off')
legend boxoff
xlabel('Number of extra predictors')
title('Extra pure noise predictors')
plot(xlim, [1 1], 'k--')
ylim([0 2])

Aquí hay una situación artificial donde esto ocurre. Supongamos que cada variable predictora es una copia de la variable objetivo con una gran cantidad de ruido gaussiano aplicado. El mejor modelo posible es un promedio de todas las variables predictoras.

library(glmnet)
set.seed(1846)
noise <- 10
N <- 80
num.vars <- 100
target <- runif(N,-1,1)
training.data <- matrix(nrow = N, ncol = num.vars)
for(i in 1:num.vars){
  training.data[,i] <- target + rnorm(N,0,noise)
}
plot(cv.glmnet(training.data, target, alpha = 0,
               lambda = exp(seq(-10, 10, by = 0.1))))

100 variables se comportan de manera "normal": algún valor positivo de lambda minimiza el error de muestra.

Pero aumente num.vars en el código anterior a 1000, y aquí está la nueva ruta MSE. (Extendí a log (Lambda) = -100 para convencerme a mí mismo.

Lo que creo que está pasando

Cuando se ajustan muchos parámetros con baja regularización, los coeficientes se distribuyen aleatoriamente alrededor de su valor verdadero con alta varianza.

A medida que el número de predictores se vuelve muy grande, el "error promedio" tiende hacia cero, y es mejor dejar que los coeficientes caigan donde puedan y resumir todo que sesgarlos hacia 0.

Estoy seguro de que esta situación en la que la predicción verdadera es un promedio de todos los predictores no es la única vez que esto ocurre, pero no sé cómo comenzar a determinar la mayor condición necesaria aquí.

EDITAR:

El comportamiento "plano" para lambda muy bajo siempre ocurrirá, ya que la solución está convergiendo a la solución OLS de norma mínima. De manera similar, la curva será plana para lambda muy alta ya que la solución converge a 0. No habrá un mínimo si una de esas dos soluciones es óptima.

¿Por qué la solución OLS de norma mínima es tan (comparable) buena en este caso? Creo que está relacionado con el siguiente comportamiento que encontré muy contrario a la intuición, pero reflexionar tiene mucho sentido.

max.beta.random <- function(num.vars){
  num.vars <- round(num.vars)
  set.seed(1846)
  noise <- 10
  N <- 80
  target <- runif(N,-1,1)
  training.data <- matrix(nrow = N, ncol = num.vars)

  for(i in 1:num.vars){
    training.data[,i] <- rnorm(N,0,noise)
  }
  udv <- svd(training.data)

  U <- udv$u
  S <- diag(udv$d)
  V <- udv$v

  beta.hat <- V %*% solve(S) %*% t(U) %*% target

  max(abs(beta.hat))
}


curve(Vectorize(max.beta.random)(x), from = 10, to = 1000, n = 50,
      xlab = "Number of Predictors", y = "Max Magnitude of Coefficients")

abline(v = 80)

Con predictores generados aleatoriamente no relacionados con la respuesta, a medida que p aumenta, los coeficientes se hacen más grandes, pero una vez que p es mucho más grande que N, se reducen a cero. Esto también sucede en mi ejemplo. De manera muy flexible, ¡las soluciones no regularizadas para esos problemas no necesitan contracción porque ya son muy pequeñas!

Esto sucede por una razón trivial. se puede expresar exactamente como una combinación lineal de las columnas de X .$y$$X$$\hat{\beta}$$\hat{\beta}$$0$

Así que decidí ejecutar una validación cruzada anidada usando el mlrpaquete especializado en R para ver lo que realmente viene del enfoque de modelado.

Código (se tarda unos minutos en ejecutarse en una computadora portátil común)

library(mlr)
daf = read.csv("https://pastebin.com/raw/p1cCCYBR", sep = " ", header = FALSE)

tsk = list(
  tsk1110 = makeRegrTask(id = "tsk1110", data = daf, target = colnames(daf)[1]),
  tsk500 = makeRegrTask(id = "tsk500", data = daf[, c(1,sample(ncol(daf)-1, 500)+1)], target = colnames(daf)[1]),
  tsk100 = makeRegrTask(id = "tsk100", data = daf[, c(1,sample(ncol(daf)-1, 100)+1)], target = colnames(daf)[1]),
  tsk50 = makeRegrTask(id = "tsk50", data = daf[, c(1,sample(ncol(daf)-1, 50)+1)], target = colnames(daf)[1]),
  tsk10 = makeRegrTask(id = "tsk10", data = daf[, c(1,sample(ncol(daf)-1, 10)+1)], target = colnames(daf)[1])
)

rdesc = makeResampleDesc("CV", iters = 10)
msrs = list(mse, rsq)
configureMlr(on.par.without.desc = "quiet")
bm3 = benchmark(learners = list(
    makeLearner("regr.cvglmnet", alpha = 0, lambda = c(0, exp(seq(-10, 10, length.out = 150))),
    makeLearner("regr.glmnet", alpha = 0, lambda = c(0, exp(seq(-10, 10, length.out = 150))), s = 151)
    ), tasks = tsk, resamplings = rdesc, measures = msrs)

Resultados

getBMRAggrPerformances(bm3, as.df = TRUE)
#   task.id    learner.id mse.test.mean rsq.test.mean
#1    tsk10 regr.cvglmnet     1.0308055  -0.224534550
#2    tsk10   regr.glmnet     1.3685799  -0.669473387
#3   tsk100 regr.cvglmnet     0.7996823   0.031731316
#4   tsk100   regr.glmnet     1.3092522  -0.656879104
#5  tsk1110 regr.cvglmnet     0.8236786   0.009315037
#6  tsk1110   regr.glmnet     0.6866745   0.117540454
#7    tsk50 regr.cvglmnet     1.0348319  -0.188568886
#8    tsk50   regr.glmnet     2.5468091  -2.423461744
#9   tsk500 regr.cvglmnet     0.7210185   0.173851634
#10  tsk500   regr.glmnet     0.6171841   0.296530437

Básicamente hacen lo mismo en todas las tareas.

Entonces, ¿qué pasa con las lambdas óptimas?

sapply(lapply(getBMRModels(bm3, task.ids = "tsk1110")[[1]][[1]], "[[", 2), "[[", "lambda.min")
# [1] 4.539993e-05 4.539993e-05 2.442908e-01 1.398738e+00 4.539993e-05
# [6] 0.000000e+00 4.539993e-05 3.195187e-01 2.793841e-01 4.539993e-05

$\lambda = 0$

Jugué un poco más glmnety descubrí que allí no se elige el lambda mínimo. Cheque:

EDITAR:

Después de los comentarios de ameba, quedó claro que la ruta de regularización es un paso importante en la glmnetestimación, por lo que el código ahora lo refleja. De esta manera, la mayoría de las discrepancias desaparecieron.

cvfit = cv.glmnet(x = x, y = y, alpha = 0, lambda = exp(seq(-10, 10, length.out = 150)))
plot(cvfit)

Conclusión

$\lambda>0$

¿Cómo es posible y qué dice sobre mi conjunto de datos? ¿Me estoy perdiendo algo obvio o es realmente contra-intuitivo?

$\lambda$

Editar: Tenga en cuenta, sin embargo, que la ruta de regularización de crestas utiliza estimaciones de parámetros anteriores cuando llamamos glmnet, pero esto está más allá de mi experiencia. Si establecemos un lambdaaislamiento realmente bajo , probablemente degradará el rendimiento.

$\lambda\neq0$$p$ .

¿Cómo puede haber alguna diferencia cualitativa entre p = 100 y p = 1000 dado que ambos son mayores que n?

$p=1000$$p=100$

---

Comentarios

Parece que está obteniendo un mínimo mínimo para algunos lambda que no son cero (estoy mirando su figura), pero la curva todavía es realmente muy plana a la izquierda. Entonces mi pregunta principal sigue siendo por qué λ → 0 no se sobreajusta notablemente. Todavía no veo una respuesta aquí. ¿Esperas que esto sea un fenómeno general? Es decir, para cualquier dato con n≪p, lambda = 0 funcionará [casi] tan bien como el lambda óptimo. ¿O es algo especial acerca de estos datos? Si miras arriba en los comentarios, verás que muchas personas ni siquiera me creyeron que es posible.

Creo que está combinando el rendimiento de validación con el rendimiento de la prueba, y tal comparación no está garantizada.

Editar: sin embargo, tenga en cuenta que cuando establecemos lambda0 después de ejecutar toda la ruta de regularización, el rendimiento no se degrada como tal, por lo tanto, la ruta de regularización es clave para comprender lo que está sucediendo.

Además, no entiendo tu última línea. Mire la salida de cv.glmnet para p = 100. Tendrá una forma muy diferente. Entonces, ¿qué afecta a esta forma (asíntota a la izquierda versus no asíntota) cuando p = 100 o p = 1000?

Comparemos las rutas de regularización para ambos:

fit1000 = glmnet(x, y, alpha = 0, lambda = exp(seq(-10,10, length.out = 1001)))
fit100 = glmnet(x[, sample(1000, 100)], y, alpha = 0, lambda = exp(seq(-10,10, length.out = 1001)))
plot(fit1000, "lambda")

x11()
plot(fit100, "lambda")

$p=1000$$\lambda$$p=100$

$p=1000$

¿Cómo puede la OLS (norma mínima) no ajustarse demasiado?

En breve:

Los parámetros experimentales que se correlacionan con los parámetros (desconocidos) en el modelo verdadero serán más propensos a estimarse con valores altos en un procedimiento de ajuste OLS de norma mínima. Esto se debe a que se ajustarán al 'modelo + ruido', mientras que los otros parámetros solo se ajustarán al 'ruido' (por lo tanto, se ajustarán a una parte más grande del modelo con un valor más bajo del coeficiente y es más probable que tengan un valor alto en la norma mínima OLS).

Este efecto reducirá la cantidad de sobreajuste en un procedimiento de ajuste OLS de norma mínima. El efecto es más pronunciado si hay más parámetros disponibles, ya que entonces es más probable que se incorpore una porción más grande del "modelo verdadero" en la estimación.

Parte más larga:
(no estoy seguro de qué colocar aquí ya que el problema no está del todo claro para mí, o no sé con qué precisión necesita una respuesta para abordar la pregunta)

A continuación se muestra un ejemplo que se puede construir fácilmente y demuestra el problema. El efecto no es tan extraño y los ejemplos son fáciles de hacer.

• $p=200$
• $n=50$
  • $tm=10$
  • los coeficientes del modelo se determinan aleatoriamente

En este caso de ejemplo, observamos que existe un ajuste excesivo, pero los coeficientes de los parámetros que pertenecen al modelo verdadero tienen un valor más alto. Por lo tanto, R ^ 2 puede tener algún valor positivo.

La imagen a continuación (y el código para generarla) demuestran que el sobreajuste es limitado. Los puntos que se relacionan con el modelo de estimación de 200 parámetros. Los puntos rojos se relacionan con aquellos parámetros que también están presentes en el 'modelo verdadero' y vemos que tienen un valor más alto. Por lo tanto, hay un cierto grado de acercamiento al modelo real y obtener el R ^ 2 por encima de 0.

• Tenga en cuenta que utilicé un modelo con variables ortogonales (las funciones sinusoidales). Si los parámetros están correlacionados, pueden ocurrir en el modelo con un coeficiente relativamente alto y llegar a ser más penalizados en la norma mínima OLS.
• $sin(ax) \cdot sin(bx)$$x$$x$$n$$p$

library(MASS)

par(mar=c(5.1, 4.1, 9.1, 4.1), xpd=TRUE)

p <- 200       
l <- 24000
n <- 50
tm <- 10

# generate i sinus vectors as possible parameters
t <- c(1:l)
xm <- sapply(c(0:(p-1)), FUN = function(x) sin(x*t/l*2*pi))

# generate random model by selecting only tm parameters
sel <- sample(1:p, tm)
coef <- rnorm(tm, 2, 0.5)

# generate random data xv and yv with n samples
xv <- sample(t, n)
yv <- xm[xv, sel] %*% coef + rnorm(n, 0, 0.1)

# generate model
M <- ginv(t(xm[xv,]) %*% xm[xv,])

Bsol <- M %*% t(xm[xv,]) %*% yv
ysol <- xm[xv,] %*% Bsol

# plotting comparision of model with true model
plot(1:p, Bsol, ylim=c(min(Bsol,coef),max(Bsol,coef)))
points(sel, Bsol[sel], col=1, bg=2, pch=21)
points(sel,coef,pch=3,col=2)

title("comparing overfitted model (circles) with true model (crosses)",line=5)
legend(0,max(coef,Bsol)+0.55,c("all 100 estimated coefficients","the 10 estimated coefficients corresponding to true model","true coefficient values"),pch=c(21,21,3),pt.bg=c(0,2,0),col=c(1,1,2))

Técnica beta truncada en relación con la regresión de cresta

$l_2$$\beta$

• Parece que el modelo de ruido truncado hace casi lo mismo (solo computa un poco más lento, y tal vez un poco más a menudo menos bueno).
• Sin embargo, sin el truncamiento, el efecto es mucho menos fuerte.

• Esta correspondencia entre la adición de parámetros y la penalización de cresta no es necesariamente el mecanismo más fuerte detrás de la ausencia de un ajuste excesivo. Esto se puede ver especialmente en la curva de 1000p (en la imagen de la pregunta) que va a casi 0.3 mientras que las otras curvas, con diferente p, no alcanzan este nivel, sin importar cuál sea el parámetro de regresión de cresta. Los parámetros adicionales, en ese caso práctico, no son lo mismo que un cambio del parámetro de cresta (y supongo que esto se debe a que los parámetros adicionales crearán un modelo mejor y más completo).

• Los parámetros de ruido reducen la norma por un lado (al igual que la regresión de cresta) pero también introducen ruido adicional. Benoit Sanchez muestra que en el límite, al agregar muchos parámetros de ruido con una desviación menor, eventualmente será lo mismo que la regresión de cresta (el creciente número de parámetros de ruido se cancela entre sí). Pero al mismo tiempo, requiere muchos más cálculos (si aumentamos la desviación del ruido, para permitir usar menos parámetros y acelerar el cálculo, la diferencia se hace más grande).

Rho = 0.2

Rho = 0.4

Rho = 0.2 aumentando la varianza de los parámetros de ruido a 2

ejemplo de código

# prepare the data
set.seed(42)
n = 80
p = 40
rho = .2
y = rnorm(n,0,1)
X = matrix(rep(y,p), ncol = p)*rho + rnorm(n*p,0,1)*(1-rho^2)

# range of variables to add
ps = c(0, 5, 10, 15, 20, 40, 45, 50, 55, 60, 70, 80, 100, 125, 150, 175, 200, 300, 400, 500, 1000)
#ps = c(0, 5, 10, 15, 20, 40, 60, 80, 100, 150, 200, 300) #,500,1000)

# variables to store output (the sse)
error   = matrix(0,nrow=n, ncol=length(ps))
error_t = matrix(0,nrow=n, ncol=length(ps))
error_s = matrix(0,nrow=n, ncol=length(ps))

# adding a progression bar
pb <- txtProgressBar(min = 0, max = n, style = 3)

# training set by leaving out measurement 1, repeat n times 
for (fold in 1:n) {
    indtrain = c(1:n)[-fold]

    # ridge regression
    beta_s <- glmnet(X[indtrain,],y[indtrain],alpha=0,lambda = 10^c(seq(-4,2,by=0.01)))$beta
    # calculate l2-norm to compare with adding variables
    l2_bs <- colSums(beta_s^2)

    for (pi in 1:length(ps)) {
        XX = cbind(X, matrix(rnorm(n*ps[pi],0,1), nrow=80))
        XXt = XX[indtrain,]

        if (p+ps[pi] < n) {
            beta = solve(t(XXt) %*% (XXt)) %*% t(XXt) %*% y[indtrain]
        }
        else {
            beta = ginv(t(XXt) %*% (XXt)) %*% t(XXt) %*% y[indtrain]
        }

        # pickout comparable ridge regression with the same l2 norm      
        l2_b <- sum(beta[1:p]^2)
        beta_shrink <- beta_s[,which.min((l2_b-l2_bs)^2)] 

        # compute errors
        error[fold, pi] = y[fold] - XX[fold,1:p] %*% beta[1:p]
        error_t[fold, pi] = y[fold] - XX[fold,] %*% beta[]
        error_s[fold, pi] = y[fold] - XX[fold,1:p] %*% beta_shrink[]
    }
    setTxtProgressBar(pb, fold) # update progression bar
}

# plotting
plot(ps,colSums(error^2)/sum(y^2) , 
     ylim = c(0,2),
     xlab ="Number of extra predictors",
     ylab ="relative sum of squared error")
lines(ps,colSums(error^2)/sum(y^2))
points(ps,colSums(error_t^2)/sum(y^2),col=2)
lines(ps,colSums(error_t^2)/sum(y^2),col=2)
points(ps,colSums(error_s^2)/sum(y^2),col=4)
lines(ps,colSums(error_s^2)/sum(y^2),col=4)

title('Extra pure noise predictors')

legend(200,2,c("complete model with p + extra predictors",
               "truncated model with p + extra predictors",
               "ridge regression with similar l2-norm",
               "idealized model uniform beta with 1/p/rho"),
       pch=c(1,1,1,NA), col=c(2,1,4,1),lt=c(1,1,1,2))

# idealized model (if we put all beta to 1/rho/p we should theoretically have a reasonable good model)
error_op <- rep(0,n)
for (fold in 1:n) {
  beta = rep(1/rho/p,p)
    error_op[fold] = y[fold] - X[fold,] %*% beta
}
id <- sum(error_op^2)/sum(y^2)
lines(range(ps),rep(id,2),lty=2)

$n\ll p$

$$Ax=g_\delta,$$ $A$$g_\delta$

Obviamente, este es un problema inverso mal planteado. Por lo tanto, puede resolverlo con SVD o inverso de Moore-Penrose, lo que representaría la solución menos normal. Por lo tanto, debería no ser sorprendente que su solución de mínimos norma no está fallando por completo.

Sin embargo, si sigue el documento, puede ver que la regresión de cresta sería una mejora con respecto a lo anterior. La mejora es realmente un mejor comportamiento del estimador, ya que la solución de Moore-Penrose no está necesariamente limitada.

ACTUALIZAR

Me di cuenta de que no estaba dejando en claro que los problemas mal planteados conducen al sobreajuste. Aquí está la cita del artículo Gábor A, Banga JR. Estimación de parámetros robusta y eficiente en modelos dinámicos de sistemas biológicos . BMC Systems Biology. 2015; 9: 74. doi: 10.1186 / s12918-015-0219-2:

El mal condicionamiento de estos problemas generalmente surge de (i) modelos con gran número de parámetros (sobre-parametrización), (ii) escasez de datos experimentales y (iii) errores de medición significativos [19, 40]. Como consecuencia, a menudo obtenemos un sobreajuste de tales modelos cinéticos, es decir, modelos calibrados con ajustes razonables a los datos disponibles pero poca capacidad de generalización (bajo valor predictivo)

Entonces, mi argumento puede expresarse de la siguiente manera:

• problemas mal planteados conducen al sobreajuste
• (n <p) caso es un problema inverso extremadamente mal planteado
• $X^+$
• por lo tanto, se encarga de sobreajustar al menos en cierta medida, y no debería sorprender que no falle por completo, a diferencia de lo que debería hacer un OLS normal

Una vez más, la regularización es una solución más sólida todavía.