Modify damping and add lambda_max #65
Conversation
|
Just FYI: the tests in |
There was a problem hiding this comment.
Thank you for working on this. I think the idea of slowly increasing lambda has some merit, to get out of a local minima, but I think in general this would best be implemented in an alternately named dampening algorithm; in principle, if we provide a reference when implementing a method that method should faithfully implement the approach in the reference.
We could also set the default growth to 1.0 to have the default behavior implement the original algorithm. That said, the change to the rate at which bigK gets lowered would (depending on the original algorithm) possibly have to be undone.
Adding the lamdba_max option seems like a good addition.
| new_λ = min(λ * λ_growth, λ_max) # Gradually increase λ but cap at λ_max | ||
|
|
||
| if abs(norm(F, 2) - nF2) < 1e-12 # Convergence check to break loops | ||
| verbose && @info "Solver converged: residual change too small." |
There was a problem hiding this comment.
Check for verbose should be before the check on the norm to save processing.
| # Armijo test pass => accept the given λ | ||
| return true, λ | ||
| # Armijo test passed => accept the given λ | ||
| new_λ = min(λ * λ_growth, λ_max) # Gradually increase λ but cap at λ_max |
There was a problem hiding this comment.
We should call this solver something else if we are not in fact implementing the armijo rule.
| bigK = bigK / rateK | ||
| # ... and accept given λ | ||
| # Lower `bigK` more aggressively when convergence is happening | ||
| bigK /= sqrt(rateK) |
There was a problem hiding this comment.
I'm not sure about this change; why not have a different rateK? Using the square root is actually less agressive than the previous implementation since rateK > 1.
I don't have access to the Bank & Rose paper, but we should also here write a different dampener if we are changing the algorithm. Same this with the lambda growth line below.
| bigK /= sqrt(rateK) | ||
|
|
||
| # If λ is near the lower bound for many steps, slowly increase it | ||
| λ = min(λ * λ_growth, λ_max) |
There was a problem hiding this comment.
It's not quite clear to me why we need to grow lambda here? The br algorithm already increases lambda when it lowers bigK.
| if nF2_it != it | ||
| # first time we're called this iteration | ||
| # First time we're called in this iteration | ||
| nF2 = norm(F, 2) # store the residual | ||
| nF2_it = it | ||
| return false, calc_λ() |
There was a problem hiding this comment.
calc_lambda should respect/enforce lambda_max, or is that option only in the signature to make all the signatures align?
I played with a few difficult simulations and I found that these changes were helpful. In particular, this setting was able to solve very problematic simulations:
StateSpaceEcon.StackedTimeSolver.damping_br81(; delta=0.3, rateK=1.2, lambda_min=0.05, lambda_max=1.0)I'd be happy to discuss these changes and find the best way to package them.
Thank you.