public ExtremumSearcher(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
DataSet data_set,
Action <TestResultsInfo> test_results_info_callback,
CancellationToken cancellation_token)
{
this.data_set = data_set;
this.cancellation_token = cancellation_token;
this.test_results_info_callback = test_results_info_callback;
iterator = new CalibrationModeIterator(starting_mode);
handled_extremums.Add(iterator.GetUniqueKey(starting_mode));
extremums_queue.Add(new UtilityAndModePair(0, starting_mode));
}
List <UtilityAndModePair> FindNeighbourExtremums(
eye_tracking_mouse.Options.CalibrationMode starting_mode)
{
var iterator = new CalibrationModeIterator(starting_mode);
List <UtilityAndModePair> retval = new List <UtilityAndModePair>();
for (int i = 0; i < iterator.Fields.Count - 2; i++)
{
var selected_fields = new List <CalibrationModeIterator.OptionsField> {
iterator.Fields[i],
iterator.Fields[i + 1],
iterator.Fields[i + 2],
};
retval.InsertRange(retval.Count, FindNeighbourExtremums(starting_mode, selected_fields));
}
return(retval);
}
private void MaxOutEachDimension(
eye_tracking_mouse.Options.CalibrationMode mode,
DataSet data_set, string tag)
{
eye_tracking_mouse.Options.CalibrationMode local_best_calibration_mode = mode;
float local_best_utility = 0;
CalibrationModeIterator iterator = new CalibrationModeIterator(mode);
while (true)
{
float old_best_utility = local_best_utility;
foreach (var field in iterator.Fields)
{
var range = field.Range;
List <eye_tracking_mouse.Options.CalibrationMode> modes_to_test = new List <eye_tracking_mouse.Options.CalibrationMode>();
for (int i = 0; i < range.Length; i++)
{
eye_tracking_mouse.Options.CalibrationMode calibration_mode = local_best_calibration_mode.Clone();
field.SetFieldValue(calibration_mode, range[i]);
modes_to_test.Add(calibration_mode);
}
RunTests(data_set, modes_to_test, ref local_best_calibration_mode, ref local_best_utility);
}
number_of_local_iterations++;
Dispatcher.BeginInvoke((Action)(() =>
{
Text_LastIterationUtilityDelta.Text = "Last Iteration Utility Delta: " + (local_best_utility - old_best_utility);
}));
if (local_best_utility == old_best_utility)
{
break;
}
}
local_best_calibration_mode.tag_for_testing = tag + "_max_out";
TryAddToLinearResults(local_best_utility, local_best_calibration_mode);
}
public static void UniqueKeysAreUnique(eye_tracking_mouse.Options.CalibrationMode mode)
{
var unique_keys = new HashSet <long>();
var iterator = new CalibrationModeIterator(mode);
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
for (int i = 0; i < 10; i++)
{
foreach (var field in iterator.Fields)
{
if (field.Increment(mode, 1))
{
long key = iterator.GetUniqueKey(mode);
Assert(!unique_keys.Contains(key));
unique_keys.Add(key);
}
}
}
unique_keys.Clear();
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
long tests_to_run = 1000000;
try
{
ForEachFieldValue(0, iterator.Fields, mode, (x) => {
if (--tests_to_run < 0)
{
throw new NotImplementedException("Удалые пляски на костылях.");
}
else
{
long key = iterator.GetUniqueKey(x);
Assert(!unique_keys.Contains(key));
unique_keys.Add(key);
}
});
} catch (NotImplementedException)
{
Assert(tests_to_run < 0);
}
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
tests_to_run = 1000001;
try
{
ForEachFieldValue(0, iterator.Fields, mode, (x) => {
if (--tests_to_run < 0)
{
throw new NotImplementedException("Удалые пляски на костылях.");
}
else if (tests_to_run == 0)
{
long key = iterator.GetUniqueKey(x);
Assert(!unique_keys.Contains(key));
}
else
{
long key = iterator.GetUniqueKey(x);
Assert(unique_keys.Contains(key));
}
});
}
catch (NotImplementedException)
{
Assert(tests_to_run < 0);
}
}
private async Task GenerateConfiguration(DataSet data_set)
{
// VS unit tests don't work and I don't want to fix them.
IteratorTest.UniqueKeysAreUnique(CalibrationModesForTesting.Short.First());
eye_tracking_mouse.Options.Instance = new eye_tracking_mouse.Options();
CalibrationModeIterator iterator;
foreach (var mode in CalibrationModesForTesting.Short)
{
Dispatcher.Invoke((Action)(() =>
{
Text_CurrentPermutation.Text = JsonConvert.SerializeObject(mode, Formatting.Indented);
}));
iterator = new CalibrationModeIterator(mode);
iterator.ForModeAndItsVariations(mode, (x, tag) =>
{
Dispatcher.Invoke((Action)(() =>
{
Text_CurrentPermutation.Text = JsonConvert.SerializeObject(mode, Formatting.Indented);
}));
MaxOutEachDimension(x.Clone(), data_set, tag);
IncrementalImprove(x.Clone(), data_set, tag);
});
//iterator.ForEachMinMaxPermutation(mode, x => {
// Dispatcher.Invoke((Action)(() =>
// {
// Text_CurrentPermutation.Text = JsonConvert.SerializeObject(mode, Formatting.Indented);
// }));
// remaining_min_max_permutations++;
// IncrementalImprove(x, data_points, tag); });
number_of_global_iterations++;
}
if (results.best_calibration_mode == null)
{
return;
}
number_of_tests = 0;
iterator = new CalibrationModeIterator(results.best_calibration_mode.mode);
var extremum_searcher = new ExtremumSearcher(
results.best_calibration_mode.mode,
data_set,
(ExtremumSearcher.TestResultsInfo info) =>
{
Dispatcher.BeginInvoke((Action)(() =>
{
number_of_cached_results_reused += info.cached_results_reused;
number_of_tests += info.modes_tested;
Text_ExtremumsProgressInfo.Text =
"number of tests during extremums search: " + number_of_tests +
" max tests number:" + iterator.NumberOfDifferentModes +
" number of cached results reused " + number_of_cached_results_reused;
}));
},
cancellation.Token);
while (true)
{
var new_extremums = await extremum_searcher.SearchNext();
if (new_extremums == null)
{
break;
}
results.extremum_search_results.AddRange(new_extremums);
results.extremum_search_results.Sort((x, y) => {
if (x.utility < y.utility)
{
return(1);
}
if (x.utility == y.utility)
{
return(0);
}
return(-1);
});
if (results.extremum_search_results.Count > 1000)
{
results.extremum_search_results.RemoveRange(
1000, results.extremum_search_results.Count - 1000);
}
if (results.best_calibration_mode.utility < results.extremum_search_results.First().utility)
{
results.best_calibration_mode = results.extremum_search_results.First();
}
string progress_info = extremum_searcher.QueueInfo;
Dispatcher.Invoke((Action)(() =>
{
progress_info += "Top extremums.: ";
for (int i = 0;
i < results.extremum_search_results.Count && i < 10;
i++)
{
progress_info += results.extremum_search_results[i].utility + " ";
}
Text_ExtremumsQueueInfo.Text = progress_info;
}));
}
}
private void IncrementalImprove(
eye_tracking_mouse.Options.CalibrationMode mode,
DataSet data_set,
string tag)
{
eye_tracking_mouse.Options.CalibrationMode local_best_calibration_mode = mode;
float local_best_utility = 0;
RunTests(
data_set,
new List <eye_tracking_mouse.Options.CalibrationMode> {
local_best_calibration_mode
},
ref local_best_calibration_mode,
ref local_best_utility);
CalibrationModeIterator iterator = new CalibrationModeIterator(mode);
int steps_number = 0;
while (true)
{
float old_best_utility = local_best_utility;
List <eye_tracking_mouse.Options.CalibrationMode> modes_to_test = new List <eye_tracking_mouse.Options.CalibrationMode>();
for (int i = 0; i < iterator.Fields.Count; i++)
{
var field = iterator.Fields[i];
eye_tracking_mouse.Options.CalibrationMode calibration_mode = local_best_calibration_mode.Clone();
if (field.Increment(calibration_mode, steps_number))
{
modes_to_test.Add(calibration_mode);
}
calibration_mode = local_best_calibration_mode.Clone();
if (field.Increment(calibration_mode, -steps_number))
{
modes_to_test.Add(calibration_mode);
}
}
if (modes_to_test.Count == 0)
{
break;
}
RunTests(data_set, modes_to_test, ref local_best_calibration_mode, ref local_best_utility);
if (local_best_utility == old_best_utility)
{
steps_number++;
}
else
{
steps_number = 0;
}
number_of_local_iterations++;
Dispatcher.BeginInvoke((Action)(() =>
{
Text_LastIterationUtilityDelta.Text = "Last Iteration Utility Delta: " + (local_best_utility - old_best_utility);
}));
}
local_best_calibration_mode.tag_for_testing = tag + "_incremental";
TryAddToLinearResults(local_best_utility, local_best_calibration_mode);
}
