![\"\"](\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1691775%2Fd83f505b9c36a921ac2a9e51560ab3a1%2Ferror.png?generation=1599774968672355&alt=media\")
Our goal is to predict the start_state that will come to target_stop_state in the delta iteration.
\nBut the problem is that many start_state can lead us to target_stop_state.
Even if we know one of start_state(lets call it start_state_0) that lead to stop_state
\nWe cannot use start_state_0 as a target because there are many other start_states that lead to stop_state, and how is our model supposed to understand that we need to accurately predict start_state_0?
\nHence, the real goal is stop_state.
\nWe need to somehow build a model that will count the error as the difference between stop_state_prediction (predicting start_state through delta iterations) and stop_state_true.
\nIn the case of neural networks, the problem is binary rules (the loss cannot flow through the forward iteration)
\n
Does anyone have any ideas for solving this problem?
\nOr maybe there is another approach that gets around this problem?
Our goal is to predict the start_state that will come to target_stop_state in the delta iteration.
\nBut the problem is that many start_state can lead us to target_stop_state.
Even if we know one of start_state(lets call it start_state_0) that lead to stop_state
\nWe cannot use start_state_0 as a target because there are many other start_states that lead to stop_state, and how is our model supposed to understand that we need to accurately predict start_state_0?
\nHence, the real goal is stop_state.
\nWe need to somehow build a model that will count the error as the difference between stop_state_prediction (predicting start_state through delta iterations) and stop_state_true.
\nIn the case of neural networks, the problem is binary rules (the loss cannot flow through the forward iteration)
\n
Does anyone have any ideas for solving this problem?
\nOr maybe there is another approach that gets around this problem?
Here's my approach to solving this problem: [CRGL] Probability Extension | True Target Problem
", "rawMarkdown": "Here's my approach to solving this problem: [[CRGL] Probability Extension | True Target Problem](https://www.kaggle.com/yakuben/crgl-probability-extension-true-target-problem#Result-evaluation)", "votes": null }, { "id": "1005957", "postDate": "09/10/2020 23:04:26", "content": "Hello @yakuben
\nI think it isn't important to know the start_state as an input data. The goal of this competition is to actually find it because it's a REVERSE game of life.
", "rawMarkdown": "Hello @yakuben\n\nI think it isn't important to know the start_state as an input data. The goal of this competition is to actually find it because it's a **REVERSE** game of life.", "votes": null }, { "id": "1008791", "postDate": "09/13/2020 11:58:09", "content": "A SAT solver run to T=-5 (with the extra constraint of no empty boards) will in theory give you an answer. Even with simply 4 pixel boards, there are a very large number of possibilities at T=0, and that is after excluding the zero-point energy solutions (random clusters of cells that were born and died in the vaccume of whitespace)
\n\nThe major problem with this approach is that the runtime is NP-hard and the last entry in my localhost log file (running to only T=0) is. This hasn't even started to touch the boards with both high cell count and high deltas.
\n81096 | delta = 1 | cells = 95 -> 369 | Solved! in 11364.7s = 3.1 hours\nI've also started exploring the symmetries of the board, and figured out a hash function that can detect geometric duplicates (flip, roll, rotate). About 13% of the test dataset could be predicted by hash lookup from the training dataset, which reduces the problem that of solving the geometric transform and applying the same transform to the input and output. This reminds me of the Abstraction and Reasoning Corpus
\n\nIf you look at the top public kernel on the leaderboard, they have tried to solve for the probability superposition of history states (which is sort of how a quantum computer would approach this problem)
\n", "rawMarkdown": "A SAT solver run to T=-5 (with the extra constraint of no empty boards) will in theory give you an answer. Even with simply 4 pixel boards, there are a very large number of possibilities at T=0, and that is after excluding the zero-point energy solutions (random clusters of cells that were born and died in the vaccume of whitespace)\n- https://www.kaggle.com/jamesmcguigan/game-of-life-z3-constraint-satisfaction/\n\nThe major problem with this approach is that the runtime is NP-hard and the last entry in my localhost log file (running to only T=0) is. This hasn't even started to touch the boards with both high cell count and high deltas. \n```\n81096 | delta = 1 | cells = 95 -> 369 | Solved! in 11364.7s = 3.1 hours\n```\n\nI've also started exploring the symmetries of the board, and figured out a hash function that can detect geometric duplicates (flip, roll, rotate). About 13% of the test dataset could be predicted by hash lookup from the training dataset, which reduces the problem that of solving the geometric transform and applying the same transform to the input and output. This reminds me of the [Abstraction and Reasoning Corpus](https://www.kaggle.com/c/abstraction-and-reasoning-challenge) \n- https://www.kaggle.com/jamesmcguigan/game-of-life-hashmap-solver\n\n\nIf you look at the top public kernel on the leaderboard, they have tried to solve for the probability superposition of history states (which is sort of how a quantum computer would approach this problem) \n- https://www.kaggle.com/yakuben/crgl-probability-extension-true-target-problem", "votes": null }, { "id": "1016677", "postDate": "09/19/2020 06:50:17", "content": "You can use an autoencoder or GAN easily with encoder/generator doing the reverse step, and the decoder/discriminator doing the forward step and this output is checked with expected output state(which is same as input to encoder/generator) for calculating loss. This is basically the scheme you have put in figure, but in more ML terms.
", "rawMarkdown": "You can use an autoencoder or GAN easily with encoder/generator doing the reverse step, and the decoder/discriminator doing the forward step and this output is checked with expected output state(which is same as input to encoder/generator) for calculating loss. This is basically the scheme you have put in figure, but in more ML terms.", "votes": null } ], "comments": [ { "id": 1005946, "author_name": "yakuben", "author_url": "", "post_date": "09/10/2020 22:43:37", "content": "Here's my approach to solving this problem: [CRGL] Probability Extension | True Target Problem
", "votes": null, "replies": [] }, { "id": 1005957, "author_name": "trikialaaa", "author_url": "", "post_date": "09/10/2020 23:04:26", "content": "Hello @yakuben
\nI think it isn't important to know the start_state as an input data. The goal of this competition is to actually find it because it's a REVERSE game of life.
", "votes": null, "replies": [] }, { "id": 1008791, "author_name": "jamesmcguigan", "author_url": "", "post_date": "09/13/2020 11:58:09", "content": "A SAT solver run to T=-5 (with the extra constraint of no empty boards) will in theory give you an answer. Even with simply 4 pixel boards, there are a very large number of possibilities at T=0, and that is after excluding the zero-point energy solutions (random clusters of cells that were born and died in the vaccume of whitespace)
\n\nThe major problem with this approach is that the runtime is NP-hard and the last entry in my localhost log file (running to only T=0) is. This hasn't even started to touch the boards with both high cell count and high deltas.
\n81096 | delta = 1 | cells = 95 -> 369 | Solved! in 11364.7s = 3.1 hours\nI've also started exploring the symmetries of the board, and figured out a hash function that can detect geometric duplicates (flip, roll, rotate). About 13% of the test dataset could be predicted by hash lookup from the training dataset, which reduces the problem that of solving the geometric transform and applying the same transform to the input and output. This reminds me of the Abstraction and Reasoning Corpus
\n\nIf you look at the top public kernel on the leaderboard, they have tried to solve for the probability superposition of history states (which is sort of how a quantum computer would approach this problem)
\n", "votes": null, "replies": [] }, { "id": 1016677, "author_name": "arunprathap", "author_url": "", "post_date": "09/19/2020 06:50:17", "content": "You can use an autoencoder or GAN easily with encoder/generator doing the reverse step, and the decoder/discriminator doing the forward step and this output is checked with expected output state(which is same as input to encoder/generator) for calculating loss. This is basically the scheme you have put in figure, but in more ML terms.
", "votes": null, "replies": [] } ], "raw_markdown_by_id": { "1005930": "Our goal is to predict the start_state that will come to target_stop_state in the delta iteration.\nBut the problem is that many start_state can lead us to target_stop_state.\n\nEven if we know one of start_state(lets call it start_state_0) that lead to stop_state\n\nWe cannot use start_state_0 as a target because there are many other start_states that lead to stop_state, and how is our model supposed to understand that we need to accurately predict start_state_0?\n\nHence, the real goal is stop_state.\n\nWe need to somehow build a model that will count the error as the difference between stop_state_prediction (predicting start_state through delta iterations) and stop_state_true.\n\nIn the case of neural networks, the problem is binary rules (the loss cannot flow through the forward iteration)\n\n\n\nDoes anyone have any ideas for solving this problem?\nOr maybe there is another approach that gets around this problem?", "1005946": "Here's my approach to solving this problem: [[CRGL] Probability Extension | True Target Problem](https://www.kaggle.com/yakuben/crgl-probability-extension-true-target-problem#Result-evaluation)", "1005957": "Hello @yakuben\n\nI think it isn't important to know the start_state as an input data. The goal of this competition is to actually find it because it's a **REVERSE** game of life.", "1008791": "A SAT solver run to T=-5 (with the extra constraint of no empty boards) will in theory give you an answer. Even with simply 4 pixel boards, there are a very large number of possibilities at T=0, and that is after excluding the zero-point energy solutions (random clusters of cells that were born and died in the vaccume of whitespace)\n- https://www.kaggle.com/jamesmcguigan/game-of-life-z3-constraint-satisfaction/\n\nThe major problem with this approach is that the runtime is NP-hard and the last entry in my localhost log file (running to only T=0) is. This hasn't even started to touch the boards with both high cell count and high deltas. \n```\n81096 | delta = 1 | cells = 95 -> 369 | Solved! in 11364.7s = 3.1 hours\n```\n\nI've also started exploring the symmetries of the board, and figured out a hash function that can detect geometric duplicates (flip, roll, rotate). About 13% of the test dataset could be predicted by hash lookup from the training dataset, which reduces the problem that of solving the geometric transform and applying the same transform to the input and output. This reminds me of the [Abstraction and Reasoning Corpus](https://www.kaggle.com/c/abstraction-and-reasoning-challenge) \n- https://www.kaggle.com/jamesmcguigan/game-of-life-hashmap-solver\n\n\nIf you look at the top public kernel on the leaderboard, they have tried to solve for the probability superposition of history states (which is sort of how a quantum computer would approach this problem) \n- https://www.kaggle.com/yakuben/crgl-probability-extension-true-target-problem", "1016677": "You can use an autoencoder or GAN easily with encoder/generator doing the reverse step, and the decoder/discriminator doing the forward step and this output is checked with expected output state(which is same as input to encoder/generator) for calculating loss. This is basically the scheme you have put in figure, but in more ML terms." }, "source": "meta" }