Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
Petr Baudis wrote: The point here is to prevent the program from playing the MC-hamete moves that in most cases have no hope of working, but instead still aim at a close game and wait for some opponent's yose mistake. This closely matches human approach to the game as well - if you are confident in yose and see you are only little behind, you frequently don't start overplaying hopelessly, but instead still play the best you can and hope for an overturn in yose. That's right. This isn't just a theoretical case: it happens in practice when I play the publicly available mogo on 9x9. If I reach an endgame position where it thinks it's unlikely to win, it goes into self-destruct mode and loses. But it is better than me at the 9x9 endgame, and if it were to lower its sights and wait for me to go wrong it could win (I can verify this after the end of the game by going back to an earlier position and fiddling the komi). One way to think of this is that the computer's opponent model has broken down (ie, its effective assumption that it's playing against another instance of mogo). This also suggests that trying to investigate such a rule using self-play is unlikely to work well. -M- ___ computer-go mailing list computer-go@computer-go.org http://www.computer-go.org/mailman/listinfo/computer-go/
Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
On Thu, Feb 28, 2008 at 01:01:08PM -0500, Don Dailey wrote: It's naive to think some simplistic deception imposed upon the program is going to correct the error when you don't even know if the program is erring in the first place. How can you say, the program thinks it is losing, but it MUST be in error and I'm going to change the komi so that it will 'play better'?You must have some basis for knowing the program is in error before you can lower it's goal. I think there is a misunderstanding here, this was (I suppose) never to correct error in program's perception of the board. (From watching MoGo and such, it often overestimates its board position, but rarely underestimates it. :-) The point here is to prevent the program from playing the MC-hamete moves that in most cases have no hope of working, but instead still aim at a close game and wait for some opponent's yose mistake. This closely matches human approach to the game as well - if you are confident in yose and see you are only little behind, you frequently don't start overplaying hopelessly, but instead still play the best you can and hope for an overturn in yose. -- Petr Pasky Baudis Whatever you can do, or dream you can, begin it. Boldness has genius, power, and magic in it.-- J. W. von Goethe ___ computer-go mailing list computer-go@computer-go.org http://www.computer-go.org/mailman/listinfo/computer-go/
[EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
I experimented with something similar a while ago, using the publicly available mogo and manipulating komi between moves. If its win probability fell below a certain threshold (and the move number wasn't too high), I told it to play on the assumption that it would receive a few points more komi (and similarly when the win probability became high). That's certainly a nice solution ! It's probably easy to implement, and relatively easy to tune. Now, the question is: did it seem stronger to our eyes because it played more human-like ? As a remark, tests of strength with this kind of strategy could be made through self-play with handicap games. Moreover, if a program plays better when he is ahead (or conversely behind), it might be an idea to make the program play initially with a higher (resp. lower) komi. I seem to remember someone saying that a MC program (I don't remember which one) was better when he had handicap stones, than against them, because he used these stones well. I wonder if there was any link with the estimation of position. Jonas ___ computer-go mailing list computer-go@computer-go.org http://www.computer-go.org/mailman/listinfo/computer-go/
Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
[EMAIL PROTECTED] wrote: I experimented with something similar a while ago, using the publicly available mogo and manipulating komi between moves. If its win probability fell below a certain threshold (and the move number wasn't too high), I told it to play on the assumption that it would receive a few points more komi (and similarly when the win probability became high). That's certainly a nice solution ! It's probably easy to implement, and relatively easy to tune. Now, the question is: did it seem stronger to our eyes because it played more human-like ? I experimented with this idea extensively a while back and never found an implementation that improved it's playing ability.In fact every version played weaker.I tried versions that dynamically adjusted komi during the course of a game when things looked close to hopeless (or certain) and I came to the eventual conclusion that whenever you didn't use the correct komi, you were in fact decreasing it winning chances. If you tell it that is not winning when it really IS winning by 1/2 point, then there will be games where it plays stupid desperate moves when it doesn't have to. If it is almost losing and you tell it (by adjusting komi) that it has a good chance, it will tend to lose with a higher score, but you have essentially treated it as a spoiled child, lowering your expectations for it and it is happy to play with the new goal of losing. This whole concept is based on what appears to be a flawed idea, deceive the program into believing something that isn't true in the hopes that it will somehow make it play better. We had this conversation recently but with idea of changing the scoring algorithm, not the komi.I think the same principles apply. I actually think some variation of the idea would work if we understood the issues better.In SOME positions it might very well play objectively better if we lie to it by lowering or raising the komi or manipulating the scoring algorithm, but we have to pick and choose the types of positions where this doesn't lead to weaker play. For instance it's good if it makes it fight better, but in many positions lowering the komi to make it fight in a losing position will cause it to consolidate a losing position. UCT isn't going to fight when it can consolidate. It doesn't care how difficult a position is to play for you, only for it. - Don As a remark, tests of strength with this kind of strategy could be made through self-play with handicap games. Moreover, if a program plays better when he is ahead (or conversely behind), it might be an idea to make the program play initially with a higher (resp. lower) komi. I seem to remember someone saying that a MC program (I don't remember which one) was better when he had handicap stones, than against them, because he used these stones well. I wonder if there was any link with the estimation of position. Jonas ___ computer-go mailing list computer-go@computer-go.org http://www.computer-go.org/mailman/listinfo/computer-go/ ___ computer-go mailing list computer-go@computer-go.org http://www.computer-go.org/mailman/listinfo/computer-go/
Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
Don Dailey: [EMAIL PROTECTED]: [EMAIL PROTECTED] wrote: I experimented with something similar a while ago, using the publicly available mogo and manipulating komi between moves. If its win probability fell below a certain threshold (and the move number wasn't too high), I told it to play on the assumption that it would receive a few points more komi (and similarly when the win probability became high). That's certainly a nice solution ! It's probably easy to implement, and relatively easy to tune. Now, the question is: did it seem stronger to our eyes because it played more human-like ? I experimented with this idea extensively a while back and never found an implementation that improved it's playing ability.In fact every version played weaker.I tried versions that dynamically adjusted komi during the course of a game when things looked close to hopeless (or certain) and I came to the eventual conclusion that whenever you didn't use the correct komi, you were in fact decreasing it winning chances. If you tell it that is not winning when it really IS winning by 1/2 point, then there will be games where it plays stupid desperate moves when it doesn't have to. If it is almost losing and you tell it (by adjusting komi) that it has a good chance, it will tend to lose with a higher score, but you have essentially treated it as a spoiled child, lowering your expectations for it and it is happy to play with the new goal of losing. This whole concept is based on what appears to be a flawed idea, deceive the program into believing something that isn't true in the hopes that it will somehow make it play better. I don't agree. If the estimated score by playouts had no error, you were correct. I've applied my formula (in my previous post) when estimated winning probability beyonds 65% and beneth 45% or so and get better results. For example, withou this, my program sometime lost games against weaker programs due to misunderstanding of LD at corners with nakade. -Hideki We had this conversation recently but with idea of changing the scoring algorithm, not the komi.I think the same principles apply. I actually think some variation of the idea would work if we understood the issues better.In SOME positions it might very well play objectively better if we lie to it by lowering or raising the komi or manipulating the scoring algorithm, but we have to pick and choose the types of positions where this doesn't lead to weaker play. For instance it's good if it makes it fight better, but in many positions lowering the komi to make it fight in a losing position will cause it to consolidate a losing position. UCT isn't going to fight when it can consolidate. It doesn't care how difficult a position is to play for you, only for it. It depends on the property of playouts of programs, I guess. That is, if the error of the estimated score decreases in monotonic manner, this idea won't help any. -Hideki -- [EMAIL PROTECTED] (Kato) ___ computer-go mailing list computer-go@computer-go.org http://www.computer-go.org/mailman/listinfo/computer-go/
Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
Hideki Kato wrote: Don Dailey: [EMAIL PROTECTED]: [EMAIL PROTECTED] wrote: I experimented with something similar a while ago, using the publicly available mogo and manipulating komi between moves. If its win probability fell below a certain threshold (and the move number wasn't too high), I told it to play on the assumption that it would receive a few points more komi (and similarly when the win probability became high). That's certainly a nice solution ! It's probably easy to implement, and relatively easy to tune. Now, the question is: did it seem stronger to our eyes because it played more human-like ? I experimented with this idea extensively a while back and never found an implementation that improved it's playing ability.In fact every version played weaker.I tried versions that dynamically adjusted komi during the course of a game when things looked close to hopeless (or certain) and I came to the eventual conclusion that whenever you didn't use the correct komi, you were in fact decreasing it winning chances. If you tell it that is not winning when it really IS winning by 1/2 point, then there will be games where it plays stupid desperate moves when it doesn't have to. If it is almost losing and you tell it (by adjusting komi) that it has a good chance, it will tend to lose with a higher score, but you have essentially treated it as a spoiled child, lowering your expectations for it and it is happy to play with the new goal of losing. This whole concept is based on what appears to be a flawed idea, deceive the program into believing something that isn't true in the hopes that it will somehow make it play better. I don't agree. If the estimated score by playouts had no error, you were correct. It's not about the error - it's about the side-effects of trying to second guess the cure.My grandmother used to think castor oil was the solution to every illness. It's naive to think some simplistic deception imposed upon the program is going to correct the error when you don't even know if the program is erring in the first place. How can you say, the program thinks it is losing, but it MUST be in error and I'm going to change the komi so that it will 'play better'?You must have some basis for knowing the program is in error before you can lower it's goal. You have basically 2 cases when losing. One case is that the program really is busted and is in a dead lost position.The other case is that the program THINKS it's lost but really is winning (or at least has excellent chances.) In the first case, we are simply playing for a miracle, hoping that if we lower our expectations the opponent will falter. This is at best a speculative and extremely minor enhancement if we can even make it work and I argue that it also imposes risks of it's own.Unless the score is actually zero in every line, the program is going to play for any outside chance of a win, no matter how small. Telling it that a big loss is good enough will cause it to play safer, not more aggressively like you think. (Yes, you can hand pick specific positions where you can trick it into doing the right thing, but that is cooking the books, it's not a real solution.) The other case is that the program really isn't losing even though it thinks it is dead busted.How does the program know this is really the case?If it knew that, your program would be better.So you don't even know why it thinks it's busted.Even so, I argue that telling it to accept less than what is required to win is risky and will lose more games than it will win (which isn't very many since it almost certainly losing anyway.) So the bottom line is that you are trying to make it play better in positions where it is probably dead lost. That is a noble cause worth a tiny gain in strength if you are fine tuning your program and if you can even make it work, but I would rather focus on other things. I honestly believe this whole concept is a big waste of time if you are trying to do it to make your program stronger.It's slightly more worthwhile as a cosmetic improvement if that's what you want and you are willing to give up a little bit of strength. I've applied my formula (in my previous post) when estimated winning probability beyonds 65% and beneth 45% or so and get better results. For example, withou this, my program sometime lost games against weaker programs due to misunderstanding of LD at corners with nakade. I'm impressed if you actually got a measurable improvement doing this. I have no doubt that in hand picked individual positions it will play better. When I test things like this I am not happy with anything less than thousands of games unless the improvement is large.How many ELO points of improvement do you think that you achieved and how many games
Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?
An alternative (also maddening to tune) is to make the playout strength asymmetrical. For a high handicap game, making the playout rules for black stones lighter (more random) can make the bot play serious moves where otherwise it would see every move as having the same outcome. The implicit assumption, that the color that's ahead is blunder prone, is justified: those handicap stones are there for a reason. My subjective impression is that it's hard to make things better, very easy to make things worse, and it's probably best only to do this when one color has a much stronger position. Discussion of asymmetric playouts, and the general balance of stupidity, principle crops up here, from time to time. - Dave Hillis -Original Message- From: Don Dailey [EMAIL PROTECTED] To: computer-go computer-go@computer-go.org Sent: Thu, 28 Feb 2008 1:01 pm Subject: Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?] Hideki Kato wrote: Don Dailey: [EMAIL PROTECTED]: [EMAIL PROTECTED] wrote: I experimented with something similar a while ago, using the publicly available mogo and manipulating komi between moves. If its win probability fell below a certain threshold (and the move number wasn't too high), I told it to play on the assumption that it would receive a few points more komi (and similarly when the win probability became high). That's certainly a nice solution ! It's probably easy to implement, and relatively easy to tune. Now, the question is: did it seem stronger to our eyes because it played more human-like ? I experimented with this idea extensively a while back and never found an implementation that improved it's playing ability.In fact every version played weaker.I tried versions that dynamically adjusted komi during the course of a game when things looked close to hopeless (or certain) and I came to the eventual conclusion that whenever you didn't use the correct komi, you were in fact decreasing it winning chances. If you tell it that is not winning when it really IS winning by 1/2 point, then there will be games where it plays stupid desperate moves when it doesn't have to. If it is almost losing and you tell it (by adjusting komi) that it has a good chance, it will tend to lose with a higher score, but you have essentially treated it as a spoiled child, lowering your expectations for it and it is happy to play with the new goal of losing. This whole concept is based on what appears to be a flawed idea, deceive the program into believing something that isn't true in the hopes that it will somehow make it play better. I don't agree. If the estimated score by playouts had no error, you were correct. It's not about the error - it's about the side-effects of trying to second guess the cure.My grandmother used to think castor oil was the solution to every illness. It's naive to think some simplistic deception imposed upon the program is going to correct the error when you don't even know if the program is erring in the first place. How can you say, the program thinks it is losing, but it MUST be in error and I'm going to change the komi so that it will 'play better'?You must have some basis for knowing the program is in error before you can lower it's goal. You have basically 2 cases when losing. One case is that the program really is busted and is in a dead lost position.The other case is that the program THINKS it's lost but really is winning (or at least has excellent chances.) In the first case, we are simply playing for a miracle, hoping that if we lower our expectations the opponent will falter. This is at best a speculative and extremely minor enhancement if we can even make it work and I argue that it also imposes risks of it's own.Unless the score is actually zero in every line, the program is going to play for any outside chance of a win, no matter how small. Telling it that a big loss is good enough will cause it to play safer, not more aggressively like you think. (Yes, you can hand pick specific positions where you can trick it into doing the right thing, but that is cooking the books, it's not a real solution.) The other case is that the program really isn't losing even though it thinks it is dead busted.How does the program know this is really the case?If it knew that, your program would be better.So you don't even know why it thinks it's busted.Even so, I argue that telling it to accept less than what is required to win is risky and will lose more games than it will win (which isn't very many since it almost certainly losing anyway.) So the bottom line is that you are trying to make it play better in positions where it is probably dead lost. That is a noble cause worth a tiny gain in strength if you are fine tuning your program and if you can even make it work, but I would
Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
Don Dailey: [EMAIL PROTECTED]: Hideki Kato wrote: Don Dailey: [EMAIL PROTECTED]: [EMAIL PROTECTED] wrote: I experimented with something similar a while ago, using the publicly available mogo and manipulating komi between moves. If its win probability fell below a certain threshold (and the move number wasn't too high), I told it to play on the assumption that it would receive a few points more komi (and similarly when the win probability became high). That's certainly a nice solution ! It's probably easy to implement, and relatively easy to tune. Now, the question is: did it seem stronger to our eyes because it played more human-like ? I experimented with this idea extensively a while back and never found an implementation that improved it's playing ability.In fact every version played weaker.I tried versions that dynamically adjusted komi during the course of a game when things looked close to hopeless (or certain) and I came to the eventual conclusion that whenever you didn't use the correct komi, you were in fact decreasing it winning chances. If you tell it that is not winning when it really IS winning by 1/2 point, then there will be games where it plays stupid desperate moves when it doesn't have to. If it is almost losing and you tell it (by adjusting komi) that it has a good chance, it will tend to lose with a higher score, but you have essentially treated it as a spoiled child, lowering your expectations for it and it is happy to play with the new goal of losing. This whole concept is based on what appears to be a flawed idea, deceive the program into believing something that isn't true in the hopes that it will somehow make it play better. I don't agree. If the estimated score by playouts had no error, you were correct. It's not about the error - it's about the side-effects of trying to second guess the cure.My grandmother used to think castor oil was the solution to every illness. I don't think that's a universal solver. You wrote the idea is flawed but in fact the idea is effective for, at least, my program. It's naive to think some simplistic deception imposed upon the program is going to correct the error when you don't even know if the program is erring in the first place. How can you say, the program thinks it is losing, but it MUST be in error and I'm going to change the komi so that it will 'play better'?You must have some basis for knowing the program is in error before you can lower it's goal. I never say so. Perhaps my explanation made you misunderstand my issue. Please read my example below once more. You have basically 2 cases when losing. One case is that the program really is busted and is in a dead lost position.The other case is that the program THINKS it's lost but really is winning (or at least has excellent chances.) In the first case, we are simply playing for a miracle, hoping that if we lower our expectations the opponent will falter. This is at best a speculative and extremely minor enhancement if we can even make it work and I argue that it also imposes risks of it's own.Unless the score is actually zero in every line, the program is going to play for any outside chance of a win, no matter how small. Telling it that a big loss is good enough will cause it to play safer, not more aggressively like you think. (Yes, you can hand pick specific positions where you can trick it into doing the right thing, but that is cooking the books, it's not a real solution.) The other case is that the program really isn't losing even though it thinks it is dead busted.How does the program know this is really the case?If it knew that, your program would be better.So you don't even know why it thinks it's busted.Even so, I argue that telling it to accept less than what is required to win is risky and will lose more games than it will win (which isn't very many since it almost certainly losing anyway.) So the bottom line is that you are trying to make it play better in positions where it is probably dead lost. That is a noble cause worth a tiny gain in strength if you are fine tuning your program and if you can even make it work, but I would rather focus on other things. I honestly believe this whole concept is a big waste of time if you are trying to do it to make your program stronger.It's slightly more worthwhile as a cosmetic improvement if that's what you want and you are willing to give up a little bit of strength. It's a few days hack immediately before the largest computer go tournament in Japan. So, I'd like to say thanks and don't worry. I've applied my formula (in my previous post) when estimated winning probability beyonds 65% and beneth 45% or so and get better results. For example, withou this, my program sometime lost games against weaker programs due to
Re: [EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
You have basically 2 cases when losing. One case is that the program really is busted and is in a dead lost position.The other case is that the program THINKS it's lost but really is winning (or at least has excellent chances.) In the first case, we are simply playing for a miracle, hoping that if we lower our expectations the opponent will falter. This is at best a speculative and extremely minor enhancement if we can even make it work and I argue that it also imposes risks of it's own.Unless the score is actually zero in every line, the program is going to play for any outside chance of a win, no matter how small. Telling it that a big loss is good enough will cause it to play safer, not more aggressively like you think. (Yes, you can hand pick specific positions where you can trick it into doing the right thing, but that is cooking the books, it's not a real solution.) There's a subcase of the first case, and that's either handicap games, or 9*9 with really strong and not the right komi. Then the program really IS busted, but practically can win against its weaker opponent if he plays for having best score in worst case. In fact, I first thought of handicap games when I saw these komi adjustments. One reason for it to be maybe more efficient in practice is the following: the whole aim of the evaluation function is discriminating between moves. If you really are in the tails of the outcomes of the MC, all moves may look too similar. Slightly moving your point 0 may make more easy to distinguish one move from the other. Problem: the move that gets the highest boost must also be the one that was the strongest originally (I do not take into account nakade and such, where it's definitely worth having programs fight for points). It's reasonable that the most heavy tail comes with the move whose last peak is nearer zero, but that's certainy not always the case, and that I cannot imagine how to tune. Jonas ___ computer-go mailing list computer-go@computer-go.org http://www.computer-go.org/mailman/listinfo/computer-go/
[EMAIL PROTECTED]: Re: [computer-go] Should 9x9 komi be 8.0 ?]
Hi there
I am new here, but have read the list for a few monthes.
I am a mathematician, finishing my PhD on quantum statistics (that is
statistics on quantum objects, quantum information, etc.).
So do not expect me to write any code, but I could have suggestions for
heuristics in the choice of moves and so on.
I'll speak more about one of them in the coming days.
I shall just begin with a short reflexion upon the evaluation function,
starting from the Don's fear that we might have to curb too powerful and
pessimistic programs.
The funny thing about MC scoring is that if white DOES win, then it
doesn't matter what black plays, everything loses!
That would mean that in a scalability study, where colors are
alternated, really strong versions of Mogo would score poorly against
the weaker programs.
In a serious competition you would want to throttle down the playing
strength (when playing black) so that it could win more and not just
quit (resign) out of frustration!
There was the suggestion of
something like tanh(K*score), instead of 0-1 scoring.
A similar system would make some sense, without loss of strength, if we
scale K like 1/n, where n is the number of simulations. A consequence
would be that programs would choose among 100% victory or defeat moves
according to the score they expect.
Let us analyze all this more precisely.
First, I consider that the true evaluation function E of the node is
the
exact probability of winning by using the MC simulations. In other
words,
that's the value we would get with infinitely many runs and 1-0 scoring,
and that's what I want to approximate as precisely as possible with my
finite number of runs.
Second I evaluate here only at one node, without growth of the tree.
Given the conclusions, there should not be much difference. If the
conclusion had been: we can do much better than 0-1, that would have
been quite another matter.
The 1-0 evalutation function has convergence in 1/\sqrt{n}, impossible
to beat if there is sufficient irregularity in the expectation of each
result.
Now, let us write p_i for the probability that the score of the MC
simulation is i. So that i=0.5, -3.5, or 7.5 for example.
We have \sum p_i = 1, and our evaluation function is
E = \sum_i p_i sign(i)
(Well that is rather counting -1 for a defeat, but that's the same and
is more symmetrical, so nicer for presentations of the following
calculations).
We observe
\hat{p}_i = n_i / n
where n_i is the number of our simulations that give result i, on the n
simulations we have carried out.
0-1 evaluation corresponds to estimate E by
\hat{E} = \sum_i \hat{p}_i sign(i).
Now the p_i are heavily correlated (**), so that I am convinced that I
could
get better results than 0-1 for low number of simulations. For high
number of simulations, certainly not (the autocorrelation would
dominate).
Now these methods (probably using low-band filters on the array of
\hat{p}_i) would probably be much slower than running a few more
simulations...
If we keep to something simple, we could use functions of the form
\hat{E}_{\lambda} = \sum_i \hat{p}_i sign(i) (1 - \lambda_i).
This includes the suggestion of using tan(K i)...
Notice that 0-1 corresponds to taking lambda_i = 0.
Let us compute the expected mean square error (MSE) = Bias^2 + Variance:
Bias :
B = - E + \sum_i p_i sign(i) (1 - \lambda_i)
= - \sum_i p_i sign(i) \lambda_i
This is zero with the 0-1 evaluation function.
Variance :
V = (1/n) (\sum_i p_i (1 - \lambda(i))^2 - (E + B)^2)
We are only interested in the difference with the 0-1 case, so I do not
develop further the variance. For 0-1, the variance would be 1/n (1 -
E^2).
MSE(\lambda) - MSE(0-1) =
B^2 (1 - 1/n) - 2 E*B / n + (1/n) [ \sum_i p_i (\lambda(i)^2 - 2 \lambda_i)]
So that if we want this value to be negative, showing better results
than 0-1, we first need the bias to be of order 1/n.
The only way to achieve this with pre-chosen p_i is to take (\lambda_i _
1) of order 1/n.
The change would then be only cosmetic: this means changing at most a
fixed number of outcomes when n goes to infinity !
Then the first order (that is 1/n^2) can be rewritten:
B^2 + (2/n) (\sum_i p_i \lambda(i) [E sgn(i) - 1] )
If we restrict to the cases where \lambda(i) = \lambda(-i), then we see
that the positive contributions imply (products of) terms or the form:
(p_i - p_{-i}) \lambda(i)
whereas the negative contribution implies
(p_i + p_{-i}) \lambda(i)
As we want to be as negative as possible, we could get a small
improvement if \lambda_i is bigger when p_i is near p_{-i}.
A priori, this should be the case for small i: if there are high chances
that final score is -.5, there are high chances that it is 1.5. No link
between 20.5 and -19.5 a priori, on the other hand...
We have to keep \sum \lambda_i very low, though, otherwise the squared bias
gets dominant.
*** CONCLUSION ***
If we restrict our attention to scheme where we add a value to the
node after the simulation, WE
