Implement Levenberg-Marquardt algorithm in R

Question

I have been told to implement the Levenberg-Marquardt algorithm in R studio, considering lambda's initial value equals 10. The algorithm must stop when the gradient's norm is lower than the tolerance. I also need to print the values that x1, x2, λ, ∇f(x), d1 and d2 take for each iteration. Any ideas on how to do it? Many thanks in advance

This is what I have:

library(pracma)
library(matlib)
MetodeLM<-function(f,xi,t)
{
  l=10
  stop=FALSE
  x<-xi
  k=0
  while (stop==FALSE){
    dk<- inv(hessian(f,x)+l*diag(diag(hessian(f,x))))
    x1<-x+dk
    if (Norm(grad(f,x1))<t){
      stop<-TRUE
    }
    else{
      if (f(x1) < f(x)){
        l<-l/10
        k<-k+1
        stop<-FALSE
      }
      else{
        l<-l*10
        stop<-FALSE
      }
    }
  }
}

Answer 1

Correcting a few mistakes in your code, the following implementation of Levenberg Marquadt's algorithm should work (note that the update rule for the algorithm is shown in the following figure):

library(pracma)

# tolerance = t, λ = l 
LM <- function(f, x0, t, l=10, r=10) { 
    
    x <- x0
    k <- 0
    while (TRUE) {
      H <- hessian(f, x)
      G <- grad(f, x)
      dk <- inv(H + l * diag(nrow(H))) %*% G   # dk <- solve(H + l * diag(nrow(H)), G)
      x1 <- x - dk   # update rule
      print(k)  # iteration
      # print(l) # λ
      print(x1) # x1, x2
      print(G)  # ∇f(x)
      print(dk) # d1, d2
      if (Norm(G) < t) break
      l <- ifelse(f(x1) < f(x), l / r, l * r)
      k <- k + 1
      x <- x1 # update the old point 
    }
}

For example, with the following function, the non-linear optimization algorithm will quickly find a local minimum point (in the 10th iteration) as shown below

f <- function(x) {
   return ((x[1]^2+x[2]-25)^2 + (x[1]+x[2]^2-25)^2)
}

x0 <- rep(0,2)
LM(f, x0, t=1e-3, l=400, r=2)
# [1] 0
#      [,1]
# [1,] 0.165563
# [2,] 0.165563
# [1] -50 -50
#      [,1]
# [1,] -0.165563
# [2,] -0.165563
# [1] 1
#      [,1]
# [1,] 0.7986661
# [2,] 0.7986661
# [1] -66.04255 -66.04255
#      [,1]
# [1,] -0.6331031
# [2,] -0.6331031
# ...
# [1] 10
#     [,1]
# [1,] 4.524938
# [2,] 4.524938
# [1] 0.0001194898 0.0001194898
#         [,1]
# [1,] 5.869924e-07
# [2,] 5.869924e-07

The following animation shows the convergence to the local minimum point for the function:

The following one is with LoG function