A regressão de crista é inútil em altas dimensões ( )? Como o OLS pode não se adequar demais?


50

Considere um bom problema de regressão antigo com preditores de e tamanho da amostra . A sabedoria usual é que o estimador OLS superajuste e geralmente será superado pelo estimador de regressão de crista:É padrão usar a validação cruzada para encontrar um parâmetro de regularização ideal . Aqui eu uso o CV 10 vezes. Atualização de esclarecimentos: quando , por "estimador OLS", entendo "estimador OLS de norma mínima" fornecido porpβ = ( X X + λ I ) - 1 X y . λ n < p β OLS = ( X X ) + X y = X + Y .n

β^=(XX+λI)1Xy.
λn<p
β^OLS=(XX)+Xy=X+y.

Eu tenho um conjunto de dados com e . Todos os preditores são padronizados, e há alguns que (sozinhos) podem fazer um bom trabalho na previsão de . Se eu selecionar aleatoriamente um pequeno-ish, digamos , número de preditores, obtenho uma curva CV razoável: grandes valores de resultam em zero R ao quadrado, pequenos valores de resultam em R-quadrado negativo (porque de sobreajuste) e há um máximo no meio. Para a curva é semelhante. No entanto, para muito maior que isso, por exemplo, , não recebo nenhum máximo: os platôs da curva, o que significa que o OLS comp > 1000 y p = 50 < n λ λ p = 100 > n p p = 1000 λ 0n=80p>1000yp=50<nλλp=100>npp=1000λ0 executa tão bem quanto a regressão de cume com ideal .λ

insira a descrição da imagem aqui

Como é possível e o que diz sobre o meu conjunto de dados? Estou perdendo algo óbvio ou é realmente contra-intuitivo? Como pode haver qualquer diferença qualitativa entre e , dado que ambos são maiores do que ?p = 1000 np=100p=1000n

Sob quais condições a solução OLS de norma mínima para não se ajusta demais?n<p


Atualização: Houve alguma descrença nos comentários, então aqui está um exemplo reproduzível usando glmnet. Eu uso o Python, mas os usuários do R adaptarão facilmente o 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()

insira a descrição da imagem aqui insira a descrição da imagem aqui


2
@DJohnson Sem brincadeira. CV usual de 10 vezes, o que significa que cada conjunto de treinamento tem n = 72 e cada conjunto de teste tem n = 8.
Ameba diz Reinstate Monica

2
Isso está longe de ser um currículo comum . Dado que como alguém poderia esperar algo como um resultado detectável?
Mike Hunter

3
@ Johnson Eu não entendo por que você está dizendo que isso está longe do normal. É assim que o CV é 10 vezes.
Ameba diz Reinstate Monica

2
@ seanv507 eu vejo. Bem, sugiro definir "solução com lambda = 0" como "solução de norma mínima com lambda = 0". Acho que minha pergunta pode ser reformulada da seguinte forma: Sob quais condições a solução OLS de norma mínima com n <p super ajuste vs. não super ajuste?
Ameba diz Reinstate Monica

3
@amoeba: Obrigado por esta pergunta. Até agora, foi extremamente instrutivo e interessante.
usεr11852 diz Reinstate Monic

Respostas:


23

Uma regularização natural ocorre devido à presença de muitos componentes pequenos no PCA teórico de . Esses pequenos componentes são usados ​​implicitamente para ajustar o ruído usando pequenos coeficientes. Ao usar a norma mínima OLS, você adapta o ruído a muitos pequenos componentes independentes e isso tem um efeito de regularização equivalente à regularização de Ridge. Essa regularização geralmente é muito forte e é possível compensá-la usando a "anti-regularização" conhecida como cume negativo . Nesse caso, você verá o mínimo da curva MSE aparecer para valores negativos de .λxλ

Por PCA teórico, quero dizer:

Deixe uma distribuição normal multivariada. Existe uma isometria linear como que é diagonal: os componentes de são independentes. é simplesmente obtido pela diagonalização .f u = f ( x ) N ( 0 , D ) D u D ΣxN(0,Σ)fu=f(x)N(0,D)DuDΣ

Agora o modelo pode ser escrito (uma isometria linear preserva o produto escalar). Se você escrever , o modelo poderá ser escrito . Além disso,portanto, métodos adequados como Ridge ou norma mínima OLS são perfeitamente isomórficos: o estimador de é a imagem de do estimador de .y=β.x+ϵy=f(β).f(x)+ϵγ=f(β)y=γ.u+ϵβ=γy=γ.u+ϵfy=β.x+ϵ

O PCA teórico transforma preditores não independentes em preditores independentes. É apenas vagamente relacionado ao PCA empírico em que você usa a matriz de covariância empírica (que difere muito da teórica com pequeno tamanho de amostra). O PCA teórico não é praticamente computável, mas é usado apenas aqui para interpretar o modelo em um espaço preditivo ortogonal.

Vamos ver o que acontece quando anexamos muitos preditores independentes de pequena variação a um modelo:

Teorema

A regularização de cume com coeficiente é equivalente (quando ) a:λp

  • adicionando preditores independentes falsos (centralizados e distribuídos de forma idêntica), cada um com variaçãopλp
  • ajuste do modelo enriquecido com estimador mínimo de norma OLS
  • mantendo apenas os parâmetros para os preditores verdadeiros

(esboço de) Prova

Vamos provar que as funções de custo são assintoticamente iguais. Vamos dividir o modelo em preditores reais e falsos: . A função de custo de Ridge (para os verdadeiros preditores) pode ser escrita:y=βx+βx+ϵ

costλ=β2+1λyXβ2

Ao usar a norma mínima OLS, a resposta é ajustada perfeitamente: o termo do erro é 0. A função de custo é apenas sobre a norma dos parâmetros. Pode ser dividido em parâmetros verdadeiros e falsos:

costλ,p=β2+inf{β2Xβ=yXβ}

Na expressão correta, a solução de norma mínima é dada por:

β=X+(yXβ)

Agora, usando SVD para :X

X=UΣV

X+=VΣ+U

Vemos que a norma de depende essencialmente dos valores singulares de que são os recíprocos dos valores singulares de . A versão normalizada do é . Examinei a literatura e os valores singulares de grandes matrizes aleatórias são bem conhecidos. Para e suficientemente grandes, os valores singulares mínimos e máximos são aproximados por (consulte o teorema 1.1 ):βX+XXp/λXpnsminsmax

smin(p/λX)p(1n/p)
smax(p/λX)p(1+n/p)

Como para grande , tende para 0, podemos apenas dizer que todos os valores singulares são aproximados por . Portanto:pn/pp

β1λyXβ

Finalmente:

costλ,pβ2+1λyXβ2=costλ

Nota : não importa se você mantém os coeficientes dos preditores falsos no seu modelo. A variação introduzida por é . Assim, você aumenta seu MSE apenas por um fator que tende a 1 de qualquer maneira. De alguma forma, você não precisa tratar os preditores falsos de maneira diferente dos reais.βxλpβ21pyXβ2npMSE(β)1+n/p

Agora, voltando aos dados de @ amoeba. Após aplicar o PCA teórico a (assumido como normal), é transformado por uma isometria linear em uma variável cujos componentes são independentes e classificados em ordem decrescente de variação. O problema é equivalente ao problema transformado .xxuy=βx+ϵy=γu+ϵ

Agora imagine a variação dos componentes:

insira a descrição da imagem aqui

Considere muitos dos últimos componentes, chame a soma de suas variações . Cada um deles tem uma variação aproximadamente igual a são independentes. Eles desempenham o papel de preditores falsos no teorema.pλλ/p

Esse fato é mais claro no modelo de jonny: apenas o primeiro componente do PCA teórico está correlacionado com (é proporcional ) e possui uma enorme variação. Todos os outros componentes (proporcionais a ) apresentam uma variação comparativamente muito pequena (escreva a matriz de covariância e diagonalize-a para ver isso) e desempenhe o papel de preditores falsos. Calculei que a regularização aqui corresponde (aprox.) Ao anterior em enquanto o verdadeiro . Isso definitivamente encolhe demais. Isto é visível pelo fato de que o MSE final é muito maior que o MSE ideal. O efeito de regularização é muito forte.yx¯xix¯N(0,1p2)γ1γ12=1p

Às vezes é possível melhorar essa regularização natural por Ridge. Primeiro, às vezes você precisa de no teorema realmente grande (1000, 10000 ...) para rivalizar seriamente com Ridge, e a finitude de é como uma imprecisão. Mas também mostra que Ridge é uma regularização adicional sobre uma regularização implícita naturalmente existente e, portanto, pode ter apenas um efeito muito pequeno. Às vezes, essa regularização natural já é muito forte e Ridge pode até não ser uma melhoria. Mais do que isso, é melhor usar anti-regularização: cume com coeficiente negativo. Isso mostra o MSE para o modelo de @ jonny ( ), usando :ppp=1000λR

insira a descrição da imagem aqui


2
+1 Muito bom, obrigado por escrever isso. Eu acho que é importante esclarecer que quando você diz "regularização" você quer dizer regularização (isto é, cume). Seria de esperar que o laço ou a rede elástica pudesse se comportar melhor e, de fato, é isso que as pessoas estão usando em situações . Ninguém usa cume puro em tal cenário e o conselho padrão é usar regularizações que imponham escassez; portanto, o comportamento da cordilheira pura pode ter apenas um interesse acadêmico. Ainda assim, é incrível que parecemos estar descobrindo isso aqui. Por que isso não é bem conhecido? L2np
Ameba diz Reinstate Monica

11
com código proporcional a . Desculpe, não tive tempo para algo adequado. Meu foco principal foi o comportamento da norma mínima OLS, para ver que ela difere do seu exemplo e que "alguma regularização não muito ruim" em 40 primeiros foi violentamente melhor. λσ2
Benoit Sanchez

3
Acho que entendi o mistério: a regularização de Ridge com coeficiente é equivalente à norma mínima OLS, adicionando preditores falsos, cada um com variação (assintoticamente para grande ). Nos seus dados e no modelo de Johny, isso acontece sem fazer nada, graças aos componentes de menor variação do PCA. Agora eu preciso de tempo para encontrar uma maneira de explicar isso claramente ...λpλ/pp
Benoit Sanchez

11
Esclarei um pequeno ponto: os coeficientes dos preditores falsos não aumentam muito o erro (veja a nota no final da prova). É importante porque nos seus dados / Jonny eles são inevitavelmente retidos.
Benoit Sanchez

3
Eu tentei Ridge negativo. Não acredito, mas funciona !!! (e não apenas no modelo de Jonny ...)
Benoit Sanchez

16

Obrigado a todos pela grande discussão em andamento. O cerne da questão parece ser que o OLS de norma mínima está efetivamente realizando encolhimento semelhante à regressão da crista. Isso parece ocorrer sempre que . Ironicamente, adicionar preditores de ruído puro pode até ser usado como uma forma ou regularização muito estranha.pn


Parte I. Demonstração com dados artificiais e CV analítico

@ Jonny (+1) apresentou um exemplo artificial realmente simples que vou adaptar um pouco aqui. de tamanho são gerados de modo que todas as variáveis ​​sejam gaussianas com variação de unidade e a correlação entre cada preditor e a resposta seja . Vou corrigir .Xn×pyρρ=.2

Usarei o CV de exclusão única, porque existe expressão analítica para o erro ao quadrado: é conhecido como PRESS , "soma prevista dos quadrados". onde são resíduos e é o matriz de chapéu em termos de SVD . Isso permite replicar os resultados de @ Jonny sem usar e sem realmente executar a validação cruzada (estou plotando a proporção de PRESS para a soma dos quadrados de ):

PRESS=i(ei1Hii)2,
ei
e=yy^=yHy,
H
H=X(XX+λI)1X=US2S2+λU
X=USVglmnety

insira a descrição da imagem aqui

Essa abordagem analítica permite calcular o limite em . Simplesmente ligar na fórmula imprensa não trabalho: quando e , os resíduos são todos matriz zero e chapéu é a matriz identidade com aqueles na diagonal, o que significa que as fracções na imprensa equação são indefinidas. Mas se calcularmos o limite em , ele corresponderá à solução OLS de norma mínima com .λ0λ=0n<pλ=0λ0λ=0

O truque é fazer a expansão de Taylor da matriz do chapéu quando : Aqui, introduzi a matriz Gram .λ0

H=U11+λ/S2UU(1λ/S2)U=IλUS2U=IλG1.
G=XX=US2U

Estamos quase terminando:O Lambda foi cancelado, então aqui temos o valor limite. Plotei-o com um grande ponto preto na figura acima (nos painéis em que ), e combina perfeitamente.

PRESS=i(λ[G1y]iλGii1)2=i([G1y]iGii1)2.
p>n

Atualização em 21 de fevereiro. A fórmula acima é exata, mas podemos obter algumas idéias fazendo outras aproximações. Parece que tem valores aproximadamente iguais na diagonal, mesmo que tenha valores muito desiguais (provavelmente porque mistura todos os valores próprios muito bem). Portanto, para cada , temos que onde colchetes angulares indicam a média. Usando esta aproximação, podemos reescrever:Essa aproximação é mostrada na figura acima com círculos abertos vermelhos.G1SUiGii1S2

PRESSS2S2Uy2.

Se isso vai ser maior ou menor do que depende do valor singular . Nesta simulação, é correlacionado com o primeiro PC de portanto é grande e todos os outros termos são pequenos. (Nos meus dados reais, também é bem previsto pelos principais PCs.) Agora, no caso , se as colunas de forem suficientemente aleatórias, todos os valores singulares estarão bastante próximos um do outro (linhas aproximadamente ortogonal). O termo "principal"y2=Uy2SyXU1yypnXU1yserá multiplicado por um fator menor que 1. Os termos no final serão multiplicados por fatores maiores que 1, mas não muito maiores. No geral, a norma diminui. Por outro lado, no caso , haverá alguns valores singulares muito pequenos. Após a inversão, eles se tornarão grandes fatores que aumentarão a norma geral.pn

[Este argumento é muito ondulado; Espero que seja mais preciso.]

Como verificação de sanidade, se eu trocar a ordem dos valores singulares até S = diag(flipud(diag(S)));então, o MSE previsto estará acima de em todos os lugares no segundo e no terceiro painéis.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. Adicionando preditores de ruído puro como uma forma de regularização

Bons argumentos foram apresentados por @ Jonny, @ Benoit, @ Paul, @ Dikran e outros que o aumento do número de preditores reduzirá a solução OLS de norma mínima. De fato, uma vez que , qualquer novo preditor só pode diminuir a norma da solução de norma mínima. Portanto, a adição de preditores empurrará a norma para baixo, um pouco semelhante a como a regressão da crista está penalizando a norma.p>n

Então, isso pode ser usado como uma estratégia de regularização? Começamos com e e depois continuar a acrescentar preditores de ruído puros como uma tentativa de regularização. Vou fazer LOOCV e compará-lo com LOOCV para o cume (calculado como acima). Observe que, depois de obter nos preditores , estou "truncando" em porque estou interessado apenas nos preditores originais.n=80p=40qβ^p+qp

insira a descrição da imagem aqui

FUNCIONA!!!

De fato, não é necessário "truncar" o beta; mesmo se eu usar o beta completo e os preditores completos , posso obter um bom desempenho (linha tracejada na subparcela correta). Acho que isso imita meus dados reais na pergunta: apenas alguns preditores estão realmente prevendo , a maioria deles é puro ruído e serve como uma regularização. Nesse regime, a regularização adicional da cadeia não ajuda em nada.p+qy

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])

@MartijnWeterings Neste experimento, começo com n = 80 ep = 40. À medida que o número total de preditores (p + q) se aproxima de n = 80, o problema se torna mal condicionado e a solução OLS se supera drasticamente. Há um pico enorme no erro em torno de q = 40. Assim que p + q> n, a restrição "norma mínima" entra em ação e o erro começa a diminuir, mas leva algum tempo até voltar ao local onde estava com q = 0. Isso acontece em torno de q = 70, ou seja, p + q = 130. Depois disso, o erro diminui ainda mais e essa parte do gráfico é semelhante ao gráfico de regressão de crista. Isso faz sentido?
ameba diz Restabelecer Monica

@MartijnWeterings No primeiro comentário: estamos na mesma página. No segundo comentário: na minha pergunta, eu não estou truncando a versão beta, isso mesmo. Mas, na verdade, se eu não truncar beta na minha simulação (use em y(fold) - XX(fold,:) * betavez de XX(fold,1:size(X,2)) * beta(1:size(X,2))), os resultados não mudarão muito. Acho que devo adicionar isso à minha resposta. Eu acho que meus dados originais mostram esse tipo de comportamento.
ameba diz Restabelecer Monica

(1/2): Ainda estou trabalhando em todos os comentários e códigos para entender, mas um pensamento me ocorre: existe uma relação entre esse fenômeno que estamos observando e a relação entre regressão de cordilheira e efeitos aleatórios?
Ryan Simmons

(2/2): De acordo com a resposta de Randel aqui ( stats.stackexchange.com/questions/122062/… ), vemos uma estimativa equivalente entre efeitos aleatórios e regressão de crista, em que lambda é igual à razão entre os resíduos e a variação de o efeito aleatório. Aqui, pela resposta de Benoit Sanchez, vemos que a regressão de crista é equivalente a adicionar um número arbitrário de preditores independentes falsos, cada um com variação igual a uma função de lambda e o número de parâmetros. Parece-me que existe uma relação conceitual.
Ryan Simmons

@amoeba foi um erro. adicionar um vetor em escala y à matriz X regulariza um pouco, mas não é o mesmo que regressão de crista ou vetores de ruído. No entanto, me faz pensar no que acontece quando subtraímos um pouco de de cada x, a fim de tornar todas as variáveis ​​ligeiramente correlacionadas negativamente (ou menos positivas) com o vetor y. Isso para realizar alguma regularização 'negativa'. Isso para 'desfazer' a regularização dos 1000 vetores (em algum momento, pode se tornar excessivo, como você vê com o coeficiente de regularização de pico / ótimo agora estando quase fora de alcance). y
Sextus Empiricus

15

Aqui está uma situação artificial em que isso ocorre. Suponha que cada variável preditora seja uma cópia da variável alvo com uma grande quantidade de ruído gaussiano aplicada. O melhor modelo possível é uma média de todas as variáveis ​​preditivas.

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

MSE para vários lambda com 100 preditores

100 variáveis ​​se comportam de maneira "normal": algum valor positivo de lambda minimiza o erro fora da amostra.

Mas aumente num.vars no código acima para 1000, e aqui está o novo caminho MSE. (Estendi para registrar (Lambda) = -100 para me convencer.

MSE para vários lambda com 1000 preditores

O que eu acho que está acontecendo

Ao ajustar muitos parâmetros com baixa regularização, os coeficientes são distribuídos aleatoriamente em torno de seu valor verdadeiro com alta variação.

À medida que o número de preditores se torna muito grande, o "erro médio" tende a zero e torna-se melhor deixar os coeficientes caírem onde podem e resumir tudo do que enviá-los para 0.

Tenho certeza de que essa situação da previsão verdadeira sendo uma média de todos os preditores não é a única vez que isso ocorre, mas não sei como começar a identificar a maior condição necessária aqui.

EDITAR:

O comportamento "plano" para lambda muito baixo sempre ocorrerá, pois a solução está convergindo para a solução OLS de norma mínima. Da mesma forma, a curva será plana para lambda muito alto, pois a solução converge para 0. Não haverá um mínimo se uma dessas duas soluções for ótima.

Por que a solução OLS de norma mínima é tão (comparativamente) boa nesse caso? Eu acho que está relacionado ao seguinte comportamento que eu achei muito contra-intuitivo, mas refletir faz muito 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)

Gráfico da magnitude máxima dos coeficientes à medida que o número de preditores aumenta

Com preditores gerados aleatoriamente não relacionados à resposta, à medida que p aumenta, os coeficientes se tornam maiores, mas, quando p é muito maior que N, eles encolhem em direção a zero. Isso também acontece no meu exemplo. De maneira muito vaga, as soluções não regulamentadas para esses problemas não precisam de retração, porque já são muito pequenas!

Isso acontece por uma razão trivial. pode ser expresso exactamente como uma combinação linear das colunas de . é o vetor de norma mínima dos coeficientes. À medida que mais colunas são adicionadas, a norma deve diminuir ou permanecer constante, porque uma possível combinação linear é manter os coeficientes anteriores iguais e definir os novos coeficientes como .yXβ^β^0


11
(+1). O fenômeno parece ocorrer quando os preditores são correlacionados. Não significa formalmente que a curva de erro não tenha um mínimo para positivo , nem que o limite em 0 não seja grande. Significa apenas que a curva tende a ficar plana e que o limite de quão pequeno deve ser para que a regularização pare de funcionar tende a 0 para grande . Aqui esse limite vai além do limite computacional, mas a resposta do Firebug sugere que ele pode sempre existir. λλp
Benoit Sanchez

11
Por que você precisa glmnetna sua atualização? Se você precisa apenas de uma solução OLS de norma mínima, existe uma fórmula direta (consulte a 2ª fórmula na minha pergunta) e se alguém calcular SVD de , essa fórmula se tornará simplesmente . Há também é provavelmente uma função em R que calcula esta solução, mas eu realmente não sei R :)X=USVβ^=VS1Uy
ameba diz Reintegrar Monica

2
Pensando um pouco mais, não é de todo surpreendente. pode ser expresso exactamente como uma combinação linear de vectores em . é o vetor de coeficientes com a menor norma. Quando você adiciona um vetor, a norma deve diminuir ou manter o mesmo tamanho, porque você pode manter os coeficientes antigos iguais e definir os novos como zero. yXβ^β^
Jonny Lomond

3
O exemplo de Jonny é bom porque já foi analisado: veja estimador de James-Stein . Ao estimar a média de um vetor fixo com dimensão 3 ou superior, sempre podemos melhorar a média simples enviesando para zero, que é mais ou menos o que a regressão de crista faz. Gostaria de saber se talvez a melhora seja muito pequena para ser observada nesse caso. θ
Paul

3
É bem sabido que a regressão de cume é equivalente a adicionar amostras "falsas" extras ao conjunto de dados, com cada amostra tendo valor em um recurso e zeros em qualquer outro lugar, e todas as respostas correspondentes sendo zero. (É trivial reescrever a função de custo RR neste formulário.) Agora, estou me perguntando se existe uma maneira de adicionar recursos extras (por exemplo, ruído puro?) Que teriam efeito semelhante. É claro que adicionar recursos extras significa que aumentará sua dimensionalidade, mas só é possível ver seus valores nos preditores "originais". @Paulpλβ^
ameba diz Reinstate Monica

6

Decidi executar a validação cruzada aninhada usando o mlrpacote especializado em R para ver o que realmente está vindo da abordagem de modelagem.

Código (leva alguns minutos para ser executado em um notebook comum)

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

Eles fazem basicamente o mesmo nas tarefas.

Então, e as lambdas ideais?

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

Observe que as lambdas já estão transformadas. Algumas vezes até escolheram o mínimo lambda .λ=0

Eu brinquei um pouco mais glmnete descobri nem lá o lambda mínimo é escolhido. Verifica:

EDITAR:

Após comentários da ameba, ficou claro que o caminho da regularização é um passo importante na glmnetestimativa, portanto o código agora o reflete. Dessa forma, a maioria das discrepâncias desapareceu.

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

insira a descrição da imagem aqui

Conclusão

Então, basicamente, realmente melhora o ajuste ( edite: mas não muito! ).λ>0

Como é possível e o que diz sobre o meu conjunto de dados? Estou perdendo algo óbvio ou é realmente contra-intuitivo?

Provavelmente, estamos mais próximos da verdadeira distribuição da configuração de dados para um valor pequeno maior que zero. Não há nada contra-intuitivo nisso.λ

Editar: lembre-se, porém, que o caminho de regularização de cume faz uso de estimativas de parâmetros anteriores quando chamamos glmnet, mas isso está além dos meus conhecimentos. Se definirmos um nível realmente baixo lambdade isolamento, isso provavelmente prejudicará o desempenho.

EDIT: A seleção lambda diz algo mais sobre seus dados. Como lambdas maiores diminuem o desempenho, isso significa que existem coeficientes preferenciais, ou seja , maiores em seu modelo, pois as lambdas grandes reduzem todos os coeficientes para zero. Embora signifique que os graus efetivos de liberdade em seu modelo são menores que os graus aparentes de liberdade, .λ0p

Como pode haver alguma diferença qualitativa entre p = 100 ep = 1000, dado que ambos são maiores que n?

p=1000 invariavelmente contém pelo menos a mesma informação ou até mais que .p=100


Comentários

Parece que você está obtendo um mínimo mínimo de lambda diferente de zero (estou olhando para a sua figura), mas a curva ainda é realmente muito plana à esquerda dela. Portanto, minha principal questão permanece a respeito de por que λ → 0 não se nota excessivamente. Ainda não vejo uma resposta aqui. Você espera que isso seja um fenômeno geral? Ou seja, para qualquer dado com n≪p, lambda = 0 terá desempenho [quase] tão bom quanto o ideal para lambda? Ou é algo especial sobre esses dados? Se você olhar acima nos comentários, verá que muitas pessoas nem acreditam em mim que isso é possível.

Acho que você está confundindo o desempenho da validação com o desempenho do teste, e essa comparação não se justifica.

Edit: note que quando definimos lambdacomo 0 depois de executar o caminho inteiro da regularização, o desempenho não se deteriora como tal, portanto, o caminho da regularização é essencial para entender o que está acontecendo!

Além disso, não entendo bem sua última linha. Veja a saída cv.glmnet para p = 100. Ele terá uma forma muito diferente. Então, o que afeta essa forma (assíntota à esquerda versus sem assíntota) quando p = 100 ou p = 1000?

Vamos comparar os caminhos de regularização 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")

insira a descrição da imagem aqui

x11()
plot(fit100, "lambda")

insira a descrição da imagem aqui

Torna-se claro que fornece coeficientes maiores ao aumentar , embora tenha coeficientes menores para a crista OLS assintoticamente, à esquerda das duas parcelas. Então, basicamente, superajustes à esquerda do gráfico, e isso provavelmente explica a diferença de comportamento entre eles.p=1000λp=100

É mais difícil para se ajustar demais, porque, embora Ridge diminua os coeficientes para zero, eles nunca atingem zero. Isso significa que o poder preditivo do modelo é compartilhado entre muitos outros componentes, facilitando a previsão em torno da média, em vez de ser levado pelo ruído.p=1000


+1 Obrigado por fazer essas experiências! Parece que você está obtendo um mínimo mínimo de lambda diferente de zero (estou olhando para a sua figura), mas a curva ainda é realmente muito plana à esquerda dela. Portanto, minha principal pergunta permanece sobre o porquê não se nota excessivamente. Ainda não vejo uma resposta aqui. Você espera que isso seja um fenômeno geral? Ou seja, para quaisquer dados com , lambda = 0 executará [quase] tão bom quanto o lambda ideal? Ou é algo especial sobre esses dados? Se você olhar acima nos comentários, verá que muitas pessoas nem acreditam em mim que isso é possível. λ0np
Ameba diz Reinstate Monica

Além disso, não entendo bem sua última linha. Veja a cv.glmnetsaída para p = 100. Ele terá uma forma muito diferente. Então, o que afeta essa forma (assíntota à esquerda vs. sem assíntota) quando p = 100 ou p = 1000?
Ameba diz Reinstate Monica

Você sabe se mlrseleciona lambda.minou lambda.1se(na cv.glmnetterminologia)?
Ameba diz Reinstate Monica

@amoeba lambda.min. Há também um regr.cvglmnetaluno, que provavelmente permite selecionar outras regras.
Firebug 15/02

Obrigado. Para ser sincero, não entendo o resultado do seu benchmark 1e-100. Por exemplo, para p = 1100, fornece MSE = 1,45. Mas aqui não há ajuste de hiperparâmetro no loop interno, portanto, basicamente, não é necessário um loop CV interno. Significando que o resultado deve ser o mesmo que com CV não aninhado em lambda = 1e-100. Mas vemos na primeira figura que o MSE existe em torno de 0,7. Isso não faz sentido para mim.
Ameba diz Reinstate Monica

5

Como o OLS (norma mínima) pode falhar em superajuste?

Em resumo:

Parâmetros experimentais que se correlacionam com os parâmetros (desconhecidos) no modelo verdadeiro terão maior probabilidade de serem estimados com valores altos em um procedimento de ajuste mínimo da norma OLS. Isso ocorre porque eles se encaixam no 'modelo + ruído', enquanto os outros parâmetros se encaixam apenas no 'ruído' (assim, eles se encaixam em uma parte maior do modelo com um valor mais baixo do coeficiente e são mais propensos a ter um valor alto na norma mínima OLS).

Esse efeito reduzirá a quantidade de sobreajuste em um procedimento mínimo de ajuste da norma OLS. O efeito é mais pronunciado se houver mais parâmetros disponíveis desde então, é mais provável que uma porção maior do 'modelo verdadeiro' esteja sendo incorporada na estimativa.

Parte mais longa:
(não tenho certeza do que colocar aqui, pois o problema não está totalmente claro para mim ou não sei com que precisão uma resposta precisa para resolver a questão)

Abaixo está um exemplo que pode ser facilmente construído e demonstra o problema. O efeito não é tão estranho e exemplos são fáceis de fazer.

  • Tomei funções sin (porque são perpendiculares) como variáveisp=200
  • criaram um modelo aleatório com medidas. n=50
    • O modelo é construído com apenas das variáveis, de modo que 190 das 200 variáveis ​​estão criando a possibilidade de gerar excesso de ajuste.tm=10
    • coeficientes do modelo são determinados aleatoriamente

Neste caso de exemplo, observamos que há algum ajuste excessivo, mas os coeficientes dos parâmetros que pertencem ao modelo verdadeiro têm um valor mais alto. Assim, o R ^ 2 pode ter algum valor positivo.

A imagem abaixo (e o código para gerá-lo) demonstra que o excesso de ajuste é limitado. Os pontos que se relacionam com o modelo de estimativa de 200 parâmetros. Os pontos vermelhos se referem aos parâmetros que também estão presentes no 'modelo verdadeiro' e vemos que eles têm um valor mais alto. Assim, existe algum grau de aproximação do modelo real e obtenção de R ^ 2 acima de 0.

  • Note que eu usei um modelo com variáveis ​​ortogonais (as funções senoidais). Se os parâmetros estão correlacionados, eles podem ocorrer no modelo com um coeficiente relativamente alto e tornar-se mais penalizados na norma mínima OLS.
  • Observe que as 'variáveis ​​ortogonais' não são ortogonais quando consideramos os dados. O produto interno de é apenas zero quando integramos todo o espaço de e não quando temos apenas algumas amostras . A conseqüência é que, mesmo com ruído zero, o ajuste excessivo ocorrerá (e o valor R ^ 2 parece depender de muitos fatores, além do ruído. É claro que existe a relação e , mas também importante é quantas variáveis ​​são no modelo verdadeiro e quantos deles estão no modelo de ajuste).sin(ax)sin(bx)xxnp

exemplo de excesso de ajuste sendo reduzido

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 em relação à regressão de crista

Transformei o código python da Amoeba em R e combinei os dois gráficos. Para cada estimativa mínima de OLS de norma com variáveis ​​de ruído adicionadas, eu uma estimativa de regressão de crista com a mesma (aproximadamente) norma para o vetor .l2β

  • Parece que o modelo de ruído truncado faz o mesmo (apenas calcula um pouco mais devagar, e talvez um pouco mais frequentemente com menos frequência).
  • No entanto, sem o truncamento, o efeito é muito menos forte.
  • Essa correspondência entre adicionar parâmetros e penalizar a crista não é necessariamente o mecanismo mais forte por trás da ausência de ajuste excessivo. Isso pode ser visto especialmente na curva 1000p (na imagem da pergunta) indo para quase 0,3 enquanto as outras curvas, com p diferente, não atingem esse nível, independentemente do parâmetro de regressão da crista. Os parâmetros adicionais, nesse caso prático, não são os mesmos que uma mudança no parâmetro cume (e acho que isso ocorre porque os parâmetros extras criarão um modelo melhor e mais completo).

  • Os parâmetros de ruído reduzem a norma, por um lado (assim como a regressão da crista), mas também introduzem ruído adicional. Benoit Sanchez mostra que, no limite, adicionando muitos parâmetros de ruído com menor desvio, ele se tornará o mesmo que a regressão de crista (o número crescente de parâmetros de ruído se cancela). Mas, ao mesmo tempo, exige muito mais cálculos (se aumentarmos o desvio do ruído, para permitir usar menos parâmetros e acelerar o cálculo, a diferença se torna maior).

Rho = 0,2 comparando ruído truncado com regressão de crista

Rho = 0,4 comparando ruído truncado com regressão de crista

Rho = 0,2 aumentando a variação dos parâmetros de ruído para 2 comparando ruído truncado com regressão de crista

exemplo 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)

11
(+1) Obrigado. Eu acho que o argumento intuitivo no início de sua resposta faz sentido.
Ameba diz Reinstate Monica

1

Se você conhece os operadores lineares, pode gostar da minha resposta como o caminho mais direto para entender o fenômeno: por que a regressão mínima não falha totalmente? A razão é que o seu problema ( ) é o problema inverso mal colocado e o pseudo-inverso é uma das maneiras de resolvê-lo. A regularização é uma melhoria.np

Este artigo é provavelmente a explicação mais compacta e relevante: Lorenzo Rosasco et al., Aprendizagem, Regularização e Problemas Inversos Positivos . Eles configuram seu problema de regressão como aprendizado, veja Eq.3., Onde o número de parâmetros excede o número de observações: onde é um operador linear no espaço Hilbert e - dados ruidosos.

Ax=gδ,
Agδ

Obviamente, este é um problema inverso mal colocado. Portanto, você pode resolvê-lo com SVD ou Moore-Penrose inverso, o que tornaria a solução com menos normas de fato. Portanto, não deve surpreender que sua solução de menor norma não esteja falhando completamente.

No entanto, se você seguir o documento, poderá ver que a regressão da crista seria uma melhoria em relação ao acima. A melhoria é realmente um comportamento melhor do estimador, uma vez que a solução de Moore-Penrose não é necessariamente limitada.

ATUALIZAR

Percebi que não estava deixando claro que problemas incorretos levavam ao excesso de ajustes. Aqui está a citação do artigo Gábor A, Banga JR. Estimativa de parâmetros robusta e eficiente em modelos dinâmicos de sistemas biológicos . BMC Systems Biology. 2015; 9: 74. doi: 10.1186 / s12918-015-0219-2:

The ill-conditioning of these problems typically arise from (i) models with large number of parameters (over-parametrization), (ii) experimental data scarcity and (iii) significant measurement errors [19, 40]. As a consequence, we often obtain overfitting of such kinetic models, i.e. calibrated models with reasonable fits to the available data but poor capability for generalization (low predictive value)

So, my argument can be stated as follows:

  • ill posed problems lead to overfitting
  • (n < p) case is an extremely ill-posed inverse problem
  • Moore-Penrose psudo-inverse (or other tools like SVD), which you refer to in the question as X+, solves an ill-posed problem
  • therefore, it takes care of overfitting at least to some extent, and it shouldn't be surprising that it doesn't completely fail, unlike a regular OLS should

Again, regularization is a more robust solution still.


1
(+1) Thanks, but I don't quite see how this paper is relevant. I will look at it tomorrow in more detail. Where exactly do they say that minimum norm OLS solution will not overfit or that minimum norm requirement can be seen as regularization?
amoeba says Reinstate Monica

1
Let’s discuss when you read the paper. They don’t say psudo inverse is regularization. What they say is that it is the solution to the ill posed problem. What I’m saying is that overfitting is due to ill posed ness of the problem, so by addressing the latter you take care of the former albeit not as well as with regularization.
Aksakal

1
I think the puzzling thing is not that the minimum norm solution does not ameliorate over-fitting to some extent, but that adding more regularisation doesn't improve things further. Also why the minimum norm solution is more effective as the number of features grows larger. My intuition is that problems with more parameters need more regularisation (all things being otherwise equal) rather than less. This is a really interesting problem, and may help explan why e.g. even unregularised neural networks do not over-fit as much as you might expect.
Dikran Marsupial

1
@Dikran Actually other forms or regularization can still improve the performance: e.g. I can improve the performance (compared to the minimum-norm OLS) with principal component regression or with elastic net. It's just that ridge regularization becomes useless. The analogy to neural networks is a fascinating thought that hasn't crossed my mind. What I did think about recently though, is that no wonder nobody understands why tricky deep learning things like batch normalization really work, given that even linear ridge regression from Statistics 101 can be so puzzling :-)
amoeba says Reinstate Monica

2
This is not the main question at hand but I think that this otherwise excellent series of questions, answers, and comments got sidetracked from bringing in cross-validation. For this discussion it would be far simpler to compute the population linear predictor from the βs that were used to simulate the data, and to compute MSE of any estimator of the linear predictor. And I have seen a case where for n<<p I could not find an optimum corrected AIC for ridge regression (Rrms package ols function). But I need to re-run that using the true linear predictor as the gold standard.
Frank Harrell
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.