May 15th, 2015

I had some trouble getting the Stochastic RBF optimization code up in C++, so I am using Juliane Müller's Python version, available here.

The way this stuff works is as follows: first it does some random sampling around the parameter space, within the specified constraints. I believe for a pure RBF model you need n+1 samples minimum, where n is the dimension of the problem, but Müller's code uses 2*(n+1) always. Once you have a set of initial samples, the code builds an internal model of the function that you are trying to minimize. In the original paper by Gutman, the algorithm then picked the next point to evaluate based on what the model predicted would be the best point (global minimum). But finding the exact minimum of the model is itself a nonlinear global optimization problem. So the "Stochastic RBF" method instead generates randomly a large number of candidate points and picks the one that has the best "merit function." Most of the merit function is based on the RBF value, so it tries to get near to the predicted minimum point from the model, but there is also a term that tries to maximize the distance from existing points, so you are encouraging exploration a little bit, and also not wasting evals by trying very similar values twice. Once it has found the predicted best point, that point is evaluated and then it is added to the model and a new predicted best point is calculated based on the new eval and all previous evaluations. In addition, if the code detects that it might be stuck in a local mimimum, there is a restart mechanism to try to break out of it.

All this is designed to find a global optimal point with very few function evaluations. In fact, quite a lot of computation is done for for each step, so it is only really a worthwhile method when you are going to do few evaluations.

May 5th, 2015

I have been occasionally running some validation matches to verify that the tuning process is giving valid results. I have been making some bug fixes too along the way so I expect some considerable fluctuation in rating. Still I noticed that at one point the rating was pretty decent (close to the 17.5 version from which the tuning stuff branched), but at some point it had dropped significantly, so I decided to go back and find out exactly when that occurred, and why.

And what I found was that it was when I first applied the early results from king safety tuning. In other words, those were no good. And the reason seems to be this: the modified version of the executable that is used for tuning has some code to set the current version of the parameters from the command line. And that code updated the internal state but did not call a crucial method that applied the new parameters to the Scoring module, including calculating some derived values. So because of this, basically I have been getting only noise when measuring the objective function from the tuning runs so far, and so those have tuned the parameters into a worse region.

This is fixed now and I have put back the code into a state with good validation results. I am now preparing to merge the tuning branch (or actually an edited version of it, cherry-picked) back into the master branch. Now that the tuner is fixed I expect to start making much better progress from this point.

I have also been working in the background on a C++ implementation of an RBF tuning method (particularly the one called MSRBF aka "Stochastic RBF" by Regis and Shoemaker). Advantages of this method include the fact that it is oriented towards rapid convergence to a reasonably good point with few function evaluations, and all evaluated points are strictly within the constraint boundary.