has a collection of videos about old Foldit puzzles, like the one below:
CASP8 T0492 Start 3 Re-test (0:38 long)
These videos show how the protein changes as it is folded from its initial
structure to its final structure. Perhaps the inputs for a Neural Network
could be certain coordinates from the protein at time t, and the outputs
could be what sections were moved and how they were moved right after time t.
Thank you! Fold-it the project should really use and experiment with advanced technologies, including distributed neural network training with the best players, as well as tools for mutations of neural networks.
If the project folded knows all the best action of the players why those actions can not be programmed for the mutation of the best decisions?
This is a new feature in the client base and which has a self-study of the entire project fold it
In the movie https://www.youtube.com/watch?v=YN4tQ7tlDp0
the score seems to always rise, and the protein undergoes smooth motions.
I suppose not all trajectories to reach the best fold will be this way.
I can imagine having to tolerate some loss of points to get out of a
local extremum (when the protein seems "stuck"). Also, many recipes
only manage to raise the score after a series of false steps. Finally,
some tools and hand-folding tricks make very jerky motions.
Would the best training trajectories be ones with the least number
of simple moves to go from start to finish? Would it be best if each
move raised the score? Would it be best if each move was a smooth one?
I'd imagine that real trajectories would need to be pruned a bit to
make good training trajectories, and some real trajectories probably
contain too many jerks or complicated moves to be useful as training
trajectories, even after some pruning.
If certain players do almost no hand-folding,
maybe a Neural Network of Recipes could be made
from the series of Recipes these players choose.
First, go through all the Recipes and try to sort them into
a reasonable number of groups of closely-related Recipes. You
could use each Recipe's parent and children and each Recipe's
name to help sort them into groups. You could also compare the
actual text in their source code, sort of like looking for
sequence homology.
Next, record the sequence of Recipes used to go from the
starting structure to the best-folded structure. If a Recipe
did not improve the score, it could be omitted from the sequence.
The Neural Network's inputs could be the previous N Recipe groups
used, and the Network's output could be what Recipe group to use
next. The Network could learn which Recipe groups tend to come
first, which Recipe groups tend to follow other Recipe groups,
how many Recipes to use between each use of one from the DRW
group, how many Recipes to use between each use of one from
the GAB group, etc.
You might also include transitions between wiggle powers as
Network inputs. Then the Network could learn which Recipe groups
are best at each wiggle power, right after switching from low to
high wiggle power, etc.
If a Neural Network can learn from actions that drop
the score as well as actions that improve the score,
it could learn a lot more from our results.
After all, most of what we (and our Recipes)
do fails to improve the score, especially
near the end of a puzzle.
Does log.txt contain enough information to make
a Neural Network for each player? Maybe some
clever coder could make a program to do this.
The program could be run every time the user
quits a Foldit client. I think log.txt gets
overwritten when a new Foldit client starts.
The prototype of a neural network for the best results in the self-study.
1) We do not have comprehensive statistics of players to the neural network to make better decisions.
2) The actions of all the players should be in the public domain for self-neural networks.
On a free basis, without charges and licenses
