Why do we make a big fuss about using Fisher scoring when we fit a GLM?

Question

I'm curious about why we treat fitting GLMS as though they were some special optimization problem. Are they? It seems to me that they're just maximum likelihood, and that we write down the likelihood and then ... we maximize it! So why do we use Fisher scoring instead of any of the myriad of optimization schemes that has been developed in the applied math literature?

Answer 1

Fisher's scoring is just a version of Newton's method that happens to be identified with GLMs, there's nothing particularly special about it, other than the fact that the Fisher's information matrix happens to be rather easy to find for random variables in the exponential family. It also ties in to a lot of other math-stat material that tends to come up about the same time, and gives a nice geometric intuition about what exactly Fisher information means.

There's absolutely no reason I can think of not to use some other optimizer if you prefer, other than that you might have to code it by hand rather than use a pre-existing package. I suspect that any strong emphasis on Fisher scoring is a combination of (in order of decreasing weight) pedagogy, ease-of-derivation, historical bias, and "not-invented-here" syndrome.

Answer 2

It's historical, and pragmatic; Nelder and Wedderburn reverse-engineered GLMs, as the set of models where you can find the MLE using Fisher scoring (i.e. Iteratively ReWeighted Least Squares). The algorithm came before the models, at least in the general case.

It's also worth remembering that IWLS was what they had available back in the early 70s, so GLMs were an important class of models to know about. The fact you can maximize GLM likelihoods reliably using Newton-type algorithms (they typically have unique MLEs) also meant that programs like GLIM could be used by those without skills in numerical optimization.

Answer 3

A good discussion of GLM fitting algorithms, including a comparison with Newton-Raphson (which uses the observed Hessian as opposed to the expected Hessian in the IRLS / Fisher scoring algorithm) and hybrid algorithms (which start with IRLS, as these are easier to initialize, but then finish with further optimization using Newton-Raphson) can be found in the book "Generalized Linear Models and Extensions" by James W. Hardin & Joseph M. Hilbe.

In pure mathematical terms & somewhat schematically, (from this Hardin & Hilbe book), the IRLS / Fisher scoring and Newton-Raphson algorithms are structured as follows:

Code-wise, a simple pure R implementation of R's glm algorithm, based on IRLS / Fisher scoring is given by:

    glm_irls =
    function(X, # design matrix
             y, # response
             weights = rep(1, ncol(X)), # prior observation weights 
                        # e.g. total nr. of trials for proportions with
                        family=binomial
             start = NULL, # coefficient starting values, here optional
             offset = rep(0, nrow(X)), # model offset 
             family = gaussian(identity), # distribution & link function
             maxit = 25, 
             tol = 1e-08)
    {
      if (!is.null(start[[1]])) beta = start # no coefficient starting values needed
      nobs = nrow(X)    
      nvars = ncol(X)  
      eval(family$initialize) # initializes n and mustart
  eta = family$linkfun(mustart) # initialize η = g(µ)
      mu = family$linkinv(eta) # predictions on response scale µ
    
      for (i in 1:maxit)
      {
        var      = family$variance(mu) # variance in function of the mean µ
    gprime   = family$mu.eta(eta) # derivative of link function w.r.t. η = d(g-1)/dη=dμ/dη
        gradient = y - mu # gradient of log-likelihood with respect to η = ∂ℓ/∂η = deviance residual
        z        = eta - offset + gradient / gprime 
                 # adjusted response 
                 # = linearised version of log-likelihood function ℓ around η
        W        = weights * as.vector(gprime^2 / var) 
                 # = working weights
        betaold  = beta
        beta     = solve(crossprod(X,W*X), crossprod(X,W*z)) 
        # coefficient update based on quadratic approximation of log likelihood 
        # using weighted least square regression = as.matrix(coef(lm.wfit(x=X, y=z, w=W)), ncol=1)
        eta    = offset + X %*% beta # linear predictor, i.e. predictions on link scale
        mu     = family$linkinv(eta) # predictions on response scale µ = g-1(η)
        if  (sqrt(crossprod(beta-betaold)) < tol) break
      }
      return(list(coefficients=beta, iterations=i))
    }

A Newton-Raphson algorithm to fit a GLM, by contrast, would use something like

    glm_newton_raphson = function(X, # design matrix
                                  y, # response
                                  weights = rep(1, nrow(X)), # prior observation weights
                                  start = rep(0, ncol(X)), # coefficient starting values, here required
                                  offset = rep(0, nrow(X)), # model offset
                                  family = gaussian(identity), # distribution & link function
                                  maxit = 25,
                                  tol = 1e-08) {
    
      beta = start # coefficient starting values, here required
      nobs = nrow(X)
      nvars = ncol(X)
      eval(family$initialize) # initializes n and mustart
  eta = family$linkfun(mustart) # initialize η = g(µ)
      mu = family$linkinv(eta) # predictions on response scale µ
    
      for (i in 1:maxit) {
        var    = family$variance(mu) # variance as a function of the mean µ
    gprime = family$mu.eta(eta) # derivative of the link function with respect to η = d(g^-1)/dη = dμ/dη
        gradient = t(X) %*% ((y - mu) * gprime * weights) # gradient of the log-likelihood
    
        W = diag(as.vector(weights*(gprime^2 / var))) # working weights
    
        # Compute the Fisher information matrix = negative of observed Hessian matrix
        XWX = t(X) %*% W %*% X
        information = XWX # Fisher information matrix = negative of the observed Hessian (second derivatives of the log-likelihood)
    
        betaold = beta
        beta = beta + solve(information, gradient) # Newton-Raphson update step
    
        eta = offset + X %*% beta # linear predictor, i.e., predictions on link scale
        mu = family$linkinv(eta) # predictions on response scale µ = g^-1(η)
    
        if (sqrt(crossprod(beta - betaold)) < tol) break
      }
    
      return(list(coefficients = beta, iterations = i))
    }

Conceptually, the popularity and advantages of the IRLS algorithm are (1) that one merely has to perform a weighted least square regression in every update step (for which any range of state of the art least squares solvers for dense or sparse systems can be used, e.g. the Eigen solvers), (2) that the algorithm does not need coefficient starting values, unlike Newton-Raphson, and (3) that unlike Newton-Raphson, the IRLS algorithm does not form the full Hessian matrix (implicitly it uses the expected Hessian, but it doesn't actually form it; by contrast, Newton-Raphson forms the observed Hessian in every iteration, which is slow & inefficient). I haven't seen greatly improved GLM algorithms using more fancy state of the art solvers to be honest - it is hard to beat the best least square solvers once the algorithm is cast to merely use weighted least squares... IRLS using Eigen's least squares conjugate gradient solver for dense systems and Eigen's Cholesky LLT solver for sparse systems is very efficient e.g. In H20, they implement a couple of other solvers to fit GLMs, including LBFGS and coordinate descent, and claim LBFGS is more efficient for problems with very many covariates. But I am not sure what least square solver they use in the IRLS method (definitely not least square conjugate gradient from the description, which would be the fastest) & this might already make a huge difference.