what is the difference between wiggle sidechains and shake?

Case number:845813-2000169
Topic:Game: Tools
Opened by:jeff101
Status:Open
Type:Question
Opened on:Thursday, January 8, 2015 - 04:09
Last modified:Friday, February 13, 2015 - 19:05

Can anyone explain how wiggle sidechains and shake differ?

(Thu, 01/08/2015 - 04:09  |  11 comments)


MarMaj's picture
User offline. Last seen 4 years 30 weeks ago. Offline
Joined: 12/24/2014
Groups: None

Wiggle has to do more with adjusting the larger pieces of the protein such as the helices, backbones, and any attached sheets. Shake has to do with adjustment of individual, visible, hydrophobic (orange) and hydrophilic (blue) extensions of the protein that puzzles allow us to see in order to make sense of the structure of a certain protein. My suggestion is to give a go at wiggle before putting the finishing touches on with shake, but either sequence will work and if you're new to Foldit, you will quickly learn how useful those tools can be, but still try learning by following the guides given in the tutorials before you put on these 2 finishing touches. ;)

jflat06's picture
User offline. Last seen 19 hours 44 min ago. Offline
Joined: 09/29/2010
Groups: Window Group

Shake is a discrete optimization that chooses among a set of 'rotamers' for each sidechain. These rotamers are common shapes for a given sidechain, and are weighted by their statistical likelihood. Shake goes through the chain and tries out different rotamers at each position.

Wiggle Sidechains is a continuous optimization that functions the same way as Wiggle - It uses an algorithm to minimize the energy across the degrees of freedom in the sidechains. (Normal Wiggle does the same thing, except it includes the degrees of freedom in the backbone as well).

Joined: 09/24/2012
Groups: Go Science

Questions:

So if I understand well, shake gives (only) the more probabilistic positions to each sidechain considered. This would explain why it jumps so quick to high scores (comparing to wiggle sidechains).

It would do something like:
Loop 1:
-calculating current score;
-setting the most probable position for one random sidechain and calculate score;
-retaining the best score;
-same for all sidechains considered;

loop 2:
-trying a "second best" solution for one random sidechain and calculate score;
-retaining the best score;
-same for all sidechains considered;

etc.

Is it something like that? That would explain why the first round shake gives the more points and the more chance to change score, but that it's possible still to gain points on round 4 or 5 after rounds with no result.

Now wiggle sidechains

Loop 1:
-move a random sidechain slightly in random direction and calculate score until there is a score gain
-does the same to all sidechains

Loop 2: exactly the same on a second round

That would explain why we observe small point gains until an infinite number of rounds ?

The result of a shake would then be more likely to be correct than the result of a wiggle sidechain?

And the backbone does not move during this process (unless in normal wiggle of course).

Many questions. Is that more or less a good interpretation?

(I retain that it's better to start with a shake 1 loop, then wiggle sidechain if we want to fix a done backbone configuration).

jflat06's picture
User offline. Last seen 19 hours 44 min ago. Offline
Joined: 09/29/2010
Groups: Window Group

A close interpretation - I'll try to clarify a little further with a description of the actual algorithm.

Any time you shake, you tell it which residues it should run on. This could be the whole protein, it could be some selected by the selection interface, or via the right click menu.

When an iteration begins, we generate a random permutation of these residues. So if we're shaking 1-5, it might generate (3, 1, 4, 5, 2).

Shake then takes the first residue off this list (in our case, 3), and find the nearby residues (probably 2 and 4 in our case).

Shake then takes the 2,3,4 residues and tries a ton of known likely positions for these (called rotamers), and selects the best position combination for these residues (highest scoring). It then removes them from the list (leaving us with 1, 5).

It then takes the next residue off the list and repeats this process until the list is empty.

Once the list is empty, we've finished the first iteration, and we start over with a NEW permutation. The new permutation will try the residues in a different random order, which is what leads to it being able to find even more points.

For Wiggle:

Before we move ANYTHING, we do a mathematical calculation of which direction we need to 'pull' each and every sidechain in order to get more points. This calculation is possible through the magic of Calculus.

Then we 'pull' all of these sidechains at the same time by a very very small amount.

Then we recompute the mathematical calculation again, and then continue to pull by a very very small amount.

We repeat this calculate-pull process for a while until a pre-determined amount of 'work' has been done. This marks the end of an iteration of wiggle. We then start all over again on iteration 2.

Hope this clarified a bit.

Joined: 09/24/2012
Groups: Go Science

Thanks jflat06, this clarifies a lot and it is very useful to know how to deal with our scripts. that do similar actions on a "bruteforce" way (for example in Acid Tweeker).

Just one more question: does it means that wiggle sidechain can help somehow for hiding? I visualize your explanation like a hair brush on all blue chains to the exterior and orange ones to the interior (without moving the backbones).
And shake more something like sidechains being marionettes turning and trying to mach with neighbor ones.

jflat06's picture
User offline. Last seen 19 hours 44 min ago. Offline
Joined: 09/29/2010
Groups: Window Group

A useful way of thinking about it might be:

Wiggle sidechains does help for hiding - but it's prone to getting stuck. This is due to the fact that it only makes tiny little adjustments at any given time. It's great for OPTIMIZING, but if the sidechain is supposed to be in a completely different configuration, it will never make the leap to that position.

Meanwhile, Shake tries a lot of very different configurations for the sidechain. Since it's leaping all over the place, if you try every 'rotamer', you're bound to find something CLOSE to the correct position. Once you find that position, you can use Wiggle sidechains to relax it into the correct position.

jeff101's picture
User offline. Last seen 3 days 6 hours ago. Offline
Joined: 04/20/2012
Groups: Go Science

Does wiggle (whether for the sidechains, the backbone, or both) ever use random numbers? If so, when?

How about idealize? Does it use random numbers?

jflat06's picture
User offline. Last seen 19 hours 44 min ago. Offline
Joined: 09/29/2010
Groups: Window Group

Neither use any random numbers. They are intended to be completely deterministic (though may vary from machine to machine).

spmm's picture
User offline. Last seen 41 weeks 2 days ago. Offline
Joined: 08/05/2010
Groups: Void Crushers

I think it is well worth spending a bit of time experimenting with shake and wiggle sidechains and wiggle backbone so you can see the effect.

For example move a sidechain so that either its backbone goes red or a close seg goes red, then wiggle sidechains to see how they move, also experiment with the CI at the same time, use undo to go back and try a shake at different CI.

Then go back again and see what effect wiggle has, usually at a low CI, this can be useful if you are trying to fill a void or set a sidechain into a better position, wiggle may move the backbone enough to accept the new position which shake or wiggle sidechains could not find.

Joined: 06/17/2010

Shake is just faster, because it uses possible "snap" positions of side chain for optimization.
When you have few crossing ss and you shake them, effect is almost instant, wiggle take more time.
For me, best use is shake then wiggle side chains (if I want not touch backbone). Probably only wiggle side chains get same result, but this way is just faster :)

xiando's picture
User offline. Last seen 4 years 36 weeks ago. Offline
Joined: 10/19/2008
Groups: Oma Gawd

The difference is pretty straight forward, but needs a tiny bit of background.

We are using a computer model of a real phenomena. An approximation, with inherent limits and specific properties usable for manipulation of a protein's spatial geometry (and residual content in certain cases).
It's very, very important to remember this.

Each "joint" in this model (the places where residuals join, and where sidechains join to their backbones) has a rotational component that allows it flexibility in position.

For residual-residual joints, the values it can contain are relatively infinite, ie, the value is analog.

For sidechain-backbone joints, the positions are to a large extent, discrete, ie, digital (or a subset of the concept of digital) ... Each side chain has its own specific discrete positions in which it can exist, mainly due to it's own chemical makeup but also based on the systems geometric orientation.

Two basic processes are used to manipulate the protein's geometry.

Wiggle, and shake

When the model is in "working mode" (the mode in which you flip side chains or do other things to manually manipulate it) each of the joints in the protein is locked in its present position.

When wiggle is executed, all of the locks on the residual-residual joints are turned off. This allows physical and electrical forces present in each residual to affect those around it, and the proteins' backbone will attempt to move until it reaches equilibrium among those forces.

AFAIK, sidechain positions, to a large extent if at all, do not change during this operation with respect to their carrier backbone elements.

When shake is executed, it attempts to optimize the side chain positions to minimize their forces, without allowing the backbone to move.

AFAIK, The backbone does not move during a shake operation.

Grok?

Sitemap

Developed by: UW Center for Game Science, UW Institute for Protein Design, Northeastern University, Vanderbilt University Meiler Lab, UC Davis
Supported by: DARPA, NSF, NIH, HHMI, Amazon, Microsoft, Adobe, RosettaCommons