Um mergulho profundo no glmnet: type.gaussian

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br


Estou escrevendo uma série de postagens em várias opções de função do glmnet (do pacote com o mesmo nome), na esperança de fornecer mais detalhes e insights além da documentação de R.

Neste post, veremos o type.gaussian opção.

Para referência, aqui está a assinatura completa do glmnet função (v3.0-2):

glmnet (x, y, família = c ("gaussiano", "binomial", "poisson", "multinomial",
  "cox", "mgaussian"), pesos, deslocamento = NULL, alfa = 1,
  nlambda = 100, lambda.min.ratio = ifelse (nobs 

type.gaussian

De acordo com a documentação oficial R,

Dois tipos de algoritmos são suportados (apenas) family="gaussian". O padrão quando nvar is type.gaussian="covariance"e salva todos os produtos internos já computados. Isso pode ser muito mais rápido que type.gaussian="naive", que percorre as pontas sempre que um produto interno é calculado. Este último pode ser muito mais eficiente para nvar >> nobs situações ou quando nvar > 500.

De um modo geral, não é necessário que você, como usuário, altere esta opção.

Como os tempos de montagem se comparam?

Fiz uma simulação de tempo para comparar os tempos de execução da função type.gaussian="naive" vs. type.gaussian="covariance" para uma série de observações (nobs ou n

) e número de recursos (nvar ou p) Os resultados são mostrados abaixo. (Para o código R que gerou esses gráficos, veja aqui.)

Este primeiro painel de boxplots mostra o tempo necessário para type.gaussian="naive" para completar como uma fração (ou múltipla) disso para type.gaussian="covariance" (cada boxplot representa 5 execuções de simulação). Conforme anunciado, o ingênuo corre mais lentamente para pequenos valores de p

mas mais rapidamente para grandes valores de p. A diferença parece ser mais acentuada quando n é maior.

O próximo gráfico mostra os tempos absolutos de ajuste: observe a escala de log nos eixos x e y.

Então, quais algoritmos essas duas opções representam? O que se segue é baseado em Aprendizagem Estatística com Sparsity por Hastie, Tibshirani e Wainwright (PDF gratuito aqui, p.124 do PDF, p113 do livro).

Deixei y_i  in  mathbb {R}

denotar a resposta para observação Eu, e deixar x_ {ij}  in  mathbb {R} denotar o valor do recurso j para observação Eu. Suponha que a resposta e os recursos sejam padronizados com média zero, para que não tenhamos que nos preocupar em ajustar um termo de interceptação. Para cada valor de  lambda em lambda, glmnet está minimizando a seguinte função objetivo:

 begin {alinhado}  underset { beta} { text {minimize}}  quad J ( beta) =  frac {1} {2n}  displaystyle  sum_ {i = 1} ^ n  left (y_i -  sum_ {j = 1} ^ p  beta_j x_ {ij}  right) ^ 2 +  lambda  displaystyle  sum_ {j = 1} ^ p  left ( frac {1 -  alpha} {2}  beta_j ^ 2 +  alpha |  beta_j |  right).  end {alinhado}

Nós minimizamos a expressão acima por descida cíclica de coordenadas. Ou seja, percorremos os recursos j = 1,  pontos, p

. Para cada jtratar J como a função de  beta_j (finja que  beta_k para k  neq j são corrigidos) e atualize  beta_j para o valor que minimiza J. Acontece que esta atualização é muito simples:

 begin {alinhado}  beta_j  leftarrow  dfrac { mathcal {S} _ { alpha  lambda}  left ( frac {1} {n}  sum_ {i = 1} ^ n r_i ^ {(j) } x_ {ij}  right)} { frac {1} {n}  sum_ {i = 1} ^ n x_ {ij} ^ 2 + (1-  alpha)  lambda},  end {align}

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br

Onde  mathcal {S}

é o operador de limiar suave e r_i ^ {(j)} = y_i -  sum_ {k  neq j}  beta_k x_ {ik} é o residual parcial.

Ambos os modos minimizam J

nesse caminho. Eles diferem na maneira como controlam as quantidades necessárias para fazer a atualização acima. A partir daqui, assuma que os dados foram padronizados. (O que se segue também funciona para dados não padronizados, mas apenas possui expressões mais complicadas.)

type.gaussian = "naive"

Como os recursos são padronizados, podemos escrever o argumento no operador de limiar suave como

 begin {alinhado}  frac {1} {n}  sum_ {i = 1} ^ n r_i ^ {(j)} x_ {ij} =  frac {1} {n}  sum_ {i = 1} ^ n r_i x_ {ij} +  beta_j,  qquad (1)  end {alinhado}

Onde r_i

é o resíduo total para observação Eu. Nesse modo, controlamos os resíduos completos r_i, i = 1,  pontos, n.

Em suma, um ciclo completo através de todos p

custos variáveis O (np) operações.

type.gaussian = "covariance"

Ignorando o fator de  frac {1} {n}

, observe que o primeiro termo no RHS de (1) pode ser escrito como

(p deles), o que leva O (np) operações. Para cada k de tal modo que  beta_k  neq 0, armazenamos os valores atuais de  langle x_j, x_k  rangle  beta_k (tem p deles para cada k)

Essa forma de atualização evita o Em)

atualização necessária a cada etapa de cada recurso no modo ingênuo. Enquanto às vezes ocorrem O (np) operações quando uma nova variável entra no modelo, esses eventos não acontecem frequentemente. Além disso, temos q  leq p, então se p é pequeno ou se n  gg p, a O (pq) operações por um ciclo completo pálido em comparação com O (np) operações para atualização ingênua.



Se você chegou até aqui, por que não inscreva-se para atualizações do site? Escolha seu sabor: e-mail, Twitter, RSS ou facebook …



cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br
Leia Também  Visualizando o edifício mais alto de cada estado