Welcome!
\nI'd like to present a solution, that gives a score 0.035 after just 9 hours of computation and goes to 0.015 after couple of weeks.
\nShortly, there was used a combination of SAT, greedy gradient optimization (annealing) and hardcore optimizations.
\nFor developing was chosen C++ language as it seems a task that is critical for performance and every small advantage can be beneficial.
for who'd like to read code rather than text:
\nNotebook with final submission (binaries): https://www.kaggle.com/knstqq/knst-conways-rt
\nCommented version with source code: https://www.kaggle.com/knstqq/conway-notebook-annealing-sat
\nGitHub with more details and tools: (will be added soon)
Let's take input and put it as output. ~0.17 is here. It is not too bad score, good baseline to start.
\nSome boards become periodic, so, choose delta+1, delta+2, … position and look to score. Tiny improvement: ~0.145
\nTrying more position: random fields, empty… Tiny improvement again: ~0.138
Instead of generating completely new board, better to try to improve current one step-by-step. For the \"best\" position get by Phase 1 the each cell is changed one-by-one. If score is improved, changed is preserved, otherwise return previous state. To repeat it millions of times… ~0.105
\nLet's do it smarter. If score is not actually changed we preserve some changed values if it does not become worse. It will help to achieve position that need more than 1 bit to change without actually changing position to become worse. ~0.075 achieved.
\nThis solution is running on Ryzen 3900 and after long computations the score is improving, but very slowly… Good progress at the moment, but I need more!
\nTo avoid be stucked in local maximums I added some random noise after thousands of greedy iterations. Score became 0.068.
That works nice, but it is slower and slower with every hour, every day and at some moment it started to be that slow, that heating of my CPU lost attractiveness.
\nTime to put stimulants to solution.
\nIn implementation, the field is presented as linear array of N*N elements. And every time, when just a single position is changed, the score is heavily re-calculated.
const int dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};\nconst int dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};\nbool calc(const vector<bool>& field, int pos) {\n int x = pos % n;\n int y = pos / n;\n int count = 0;\n for (int i = 0; i < 8; ++i) {\n int a = x + dx8[i];\n int b = y + dy8[i];\n while (a < 0) a += n;\n while (a >= n) a -= n;\n while (b < 0) b += n;\n while (b >= n) b -= n;\n\n if (field[b * n + a]) ++count;\n }\n if (count < 2) return false;\n if (count > 3) return false;\n if (field[pos]) return true;\n if (count == 3) return true;\n return false;\n}\nvector<bool> run_step(vector<bool> start) {\n vector<bool> next(N, false);\n for (int i = 0; i < N; ++i) {\n next[i] = calc(start, i);\n }\n}\nFor sure, profiler shows that run_step and calc together are consuming 99% of CPU time.
\nAfter lots of runs benchmark, profiler (perf) and looking to generated asm code, this simple solution evolved and speeded up in 100x times:
-O3 -march=native -funroll-loops -fno-omit-frame-pointer (10% faster)vector<bool> is too inefficient in C++, the replacement to vector<char> with 1 field in 1 byte works much faster. Even it consume more memory, but the asm code is much more efficient (20% faster)unsigned ints let GCC to generate more efficient code rather than signed int due to more efficient asm code again (20% faster)return (count | field[pos]) == 3 instead of 4 condition if-else (5% faster)(2delta + 1) cells (+1000% faster)I stopped to write down achieved score here… So, whatever exact number is, but greediness becomes much faster. ~0.05 ?
\nUntil now perfect solution have been found very inefficient even for delta=1, just some good estimation.
\nTime to look for SAT.
\nThe winner of SAT Competition 2020 is KISSAT. There is no any other option for me rather then best sat solver at the moment.
\nIndeed, as checked someday later Z3 works well, but worse. Pycosat is much slower. Some other solver (I will not call their names) are much slower, some even just crashes with no reason.
Each task is converted to CNF with hundreds of thousands of conjunctions. They are minimized sufficiently by sympy something like that:
\n$ python3\n>>> from sympy import *\n>>> x, y, z = symbols('x y z')\n>>> simplify_logic((x & y & ~z) | (x & ~y & z), form=\"cnf\")\nx & (y | z) & (~y | ~z)\nYou just need to wait an hour until sympy will finish my rigorous conjunction (single-thread).
\nSerialization throught files DIMACS is too slow (10 Mb CNF to deserialize/parse back), so, necessary objects are extract for kissat solver and staticly linked to my solution, called directly by C interfaces.
\nThat give me all solved delta=1 in less than 5 minutes (24 cores with eaten just 4Gb RAM).
\n99% of delta 2 is solved in 4 hours, and fully solved in 36 hours.
\nSome minor changes (added time-outs, pre-selecting tasks with low weight, with big empty space, etc) let to solve 50% of delta=3, 30% of delta=4, 20% of delta=5
\nScore is 0.03
A beeing greedy is good in short-term, but some times you need to give away things… Don't be too greedy. Heheh.
\nLet score in greedy methods sometime drop down from maximum, to 1-2-3-4-5 lost poings… After some tuning and experiments I re-invent Annealing for optimization.
\nJump to 0.015 in less than 1 day of computation.
Until this moment I did not used sat more, but as was written in duscussion, lots of delta=3, 4, 5 can be solved.
\nAfter carefully chosed team members (and lots because their achievements) we jumped to 0.07: annealing for good aproximation is not good enough without \"perfect\" solutions.
\nScore: under 0.0064 at the final (offline solution)
In last day all code was re-written a lot of times, all params carefully adjusted. More than 100 tests on subset of data is done to find the best combination for real-time notebook solution
\nThanks @robertc for an advice to use \"checked\" position as start one helped significantly.
\nHere is it, *the score 0.035 for notebook*.
Approaches that didn't worked well:
\nfalseLet's discuss, which bugs did you do?
\nAnyone make successfully \"step-by-step SAT\" or \"genetic\" with good precision?
Thanks for all public solution. Each of them was good start for my greedy solution to get small improvement 0.001 or even more..
\nEspecially, for:
SAT notebooks inspired me to Phase 4, otherwise I was keeping only gredy things.
\nThanks @golubev (1st place) for inviting to participate here.
\nThanks team-mates for good perfect solutions, for additional CPUs and nice discussions.
\nEric's write-up: https://www.kaggle.com/c/conways-reverse-game-of-life-2020/discussion/200531
Welcome!
\nI'd like to present a solution, that gives a score 0.035 after just 9 hours of computation and goes to 0.015 after couple of weeks.
\nShortly, there was used a combination of SAT, greedy gradient optimization (annealing) and hardcore optimizations.
\nFor developing was chosen C++ language as it seems a task that is critical for performance and every small advantage can be beneficial.
for who'd like to read code rather than text:
\nNotebook with final submission (binaries): https://www.kaggle.com/knstqq/knst-conways-rt
\nCommented version with source code: https://www.kaggle.com/knstqq/conway-notebook-annealing-sat
\nGitHub with more details and tools: (will be added soon)
Let's take input and put it as output. ~0.17 is here. It is not too bad score, good baseline to start.
\nSome boards become periodic, so, choose delta+1, delta+2, … position and look to score. Tiny improvement: ~0.145
\nTrying more position: random fields, empty… Tiny improvement again: ~0.138
Instead of generating completely new board, better to try to improve current one step-by-step. For the \"best\" position get by Phase 1 the each cell is changed one-by-one. If score is improved, changed is preserved, otherwise return previous state. To repeat it millions of times… ~0.105
\nLet's do it smarter. If score is not actually changed we preserve some changed values if it does not become worse. It will help to achieve position that need more than 1 bit to change without actually changing position to become worse. ~0.075 achieved.
\nThis solution is running on Ryzen 3900 and after long computations the score is improving, but very slowly… Good progress at the moment, but I need more!
\nTo avoid be stucked in local maximums I added some random noise after thousands of greedy iterations. Score became 0.068.
That works nice, but it is slower and slower with every hour, every day and at some moment it started to be that slow, that heating of my CPU lost attractiveness.
\nTime to put stimulants to solution.
\nIn implementation, the field is presented as linear array of N*N elements. And every time, when just a single position is changed, the score is heavily re-calculated.
const int dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};\nconst int dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};\nbool calc(const vector<bool>& field, int pos) {\n int x = pos % n;\n int y = pos / n;\n int count = 0;\n for (int i = 0; i < 8; ++i) {\n int a = x + dx8[i];\n int b = y + dy8[i];\n while (a < 0) a += n;\n while (a >= n) a -= n;\n while (b < 0) b += n;\n while (b >= n) b -= n;\n\n if (field[b * n + a]) ++count;\n }\n if (count < 2) return false;\n if (count > 3) return false;\n if (field[pos]) return true;\n if (count == 3) return true;\n return false;\n}\nvector<bool> run_step(vector<bool> start) {\n vector<bool> next(N, false);\n for (int i = 0; i < N; ++i) {\n next[i] = calc(start, i);\n }\n}\nFor sure, profiler shows that run_step and calc together are consuming 99% of CPU time.
\nAfter lots of runs benchmark, profiler (perf) and looking to generated asm code, this simple solution evolved and speeded up in 100x times:
-O3 -march=native -funroll-loops -fno-omit-frame-pointer (10% faster)vector<bool> is too inefficient in C++, the replacement to vector<char> with 1 field in 1 byte works much faster. Even it consume more memory, but the asm code is much more efficient (20% faster)unsigned ints let GCC to generate more efficient code rather than signed int due to more efficient asm code again (20% faster)return (count | field[pos]) == 3 instead of 4 condition if-else (5% faster)(2delta + 1) cells (+1000% faster)I stopped to write down achieved score here… So, whatever exact number is, but greediness becomes much faster. ~0.05 ?
\nUntil now perfect solution have been found very inefficient even for delta=1, just some good estimation.
\nTime to look for SAT.
\nThe winner of SAT Competition 2020 is KISSAT. There is no any other option for me rather then best sat solver at the moment.
\nIndeed, as checked someday later Z3 works well, but worse. Pycosat is much slower. Some other solver (I will not call their names) are much slower, some even just crashes with no reason.
Each task is converted to CNF with hundreds of thousands of conjunctions. They are minimized sufficiently by sympy something like that:
\n$ python3\n>>> from sympy import *\n>>> x, y, z = symbols('x y z')\n>>> simplify_logic((x & y & ~z) | (x & ~y & z), form=\"cnf\")\nx & (y | z) & (~y | ~z)\nYou just need to wait an hour until sympy will finish my rigorous conjunction (single-thread).
\nSerialization throught files DIMACS is too slow (10 Mb CNF to deserialize/parse back), so, necessary objects are extract for kissat solver and staticly linked to my solution, called directly by C interfaces.
\nThat give me all solved delta=1 in less than 5 minutes (24 cores with eaten just 4Gb RAM).
\n99% of delta 2 is solved in 4 hours, and fully solved in 36 hours.
\nSome minor changes (added time-outs, pre-selecting tasks with low weight, with big empty space, etc) let to solve 50% of delta=3, 30% of delta=4, 20% of delta=5
\nScore is 0.03
A beeing greedy is good in short-term, but some times you need to give away things… Don't be too greedy. Heheh.
\nLet score in greedy methods sometime drop down from maximum, to 1-2-3-4-5 lost poings… After some tuning and experiments I re-invent Annealing for optimization.
\nJump to 0.015 in less than 1 day of computation.
Until this moment I did not used sat more, but as was written in duscussion, lots of delta=3, 4, 5 can be solved.
\nAfter carefully chosed team members (and lots because their achievements) we jumped to 0.07: annealing for good aproximation is not good enough without \"perfect\" solutions.
\nScore: under 0.0064 at the final (offline solution)
In last day all code was re-written a lot of times, all params carefully adjusted. More than 100 tests on subset of data is done to find the best combination for real-time notebook solution
\nThanks @robertc for an advice to use \"checked\" position as start one helped significantly.
\nHere is it, *the score 0.035 for notebook*.
Approaches that didn't worked well:
\nfalseLet's discuss, which bugs did you do?
\nAnyone make successfully \"step-by-step SAT\" or \"genetic\" with good precision?
Thanks for all public solution. Each of them was good start for my greedy solution to get small improvement 0.001 or even more..
\nEspecially, for:
SAT notebooks inspired me to Phase 4, otherwise I was keeping only gredy things.
\nThanks @golubev (1st place) for inviting to participate here.
\nThanks team-mates for good perfect solutions, for additional CPUs and nice discussions.
\nEric's write-up: https://www.kaggle.com/c/conways-reverse-game-of-life-2020/discussion/200531
\n\nAnyone make successfully \"step-by-step SAT\" or \"genetic\" with good precision?
\n
My final result is 100% \"step-by-step\" SAT and it can do better if more time was given.
\nI think I found set of additional optional constraints to make previous step solvable with high probability knowing that all start boards have another 5 previous steps, thus ideally solvable to depth \"delta+5\".
\nMy bad that I have not done good research on other available solvers to find and use KISSAT. I feel my solution could land somewhere in top 3 with faster SAT solver, especially the one that supports optional clauses.
\n\nAnyone make successfully \"step-by-step SAT\" or \"genetic\" with good precision?
\n
My final result is 100% \"step-by-step\" SAT and it can do better if more time was given.
\nI think I found set of additional optional constraints to make previous step solvable with high probability knowing that all start boards have another 5 previous steps, thus ideally solvable to depth \"delta+5\".
\nMy bad that I have not done good research on other available solvers to find and use KISSAT. I feel my solution could land somewhere in top 3 with faster SAT solver, especially the one that supports optional clauses.