My first wish is that the devs go read the thread about wishes for 2018 and start work on that list!
In other words, my suggestion would only apply to sequences that could be affected by minimax. As it is now, if a sequence of moves is generated in the Sandbox that contains 30 sequential ply (some possibly not the best moves), then due to the nature of minimax, only the final move in sequence needs to be evaluated. Because minimax would automatically back fill the evaluation for the others. This would all be done during the evaluation phase in IDeA (not the normal minimax). The evaluation phase should be smart enough to "see" the sequence and hold the evaluation for all moves until the actual evaluation of the final leaf node is done, then back fill all needed evaluations immediately, then (and only then) updating all fields in the IDeA tree (as needed), both the IA and regular eval columns can be filled at that time.
If done in this manner, 29 evaluations could be skipped and reduced to only 1. Heck, a potential 30 to 1 reduction is worth a little effort. This very process would make the use of the Sandbox an extremely valuable adjunct to the normal IDeA prolongation and alternative generation... which would remain unchanged (as pointed out above).... for the reasons you explained.
In practice the pv lines produced by IA can be pretty suspect beyond the first few moves. Sometimes even the second ply is not optimal. It would be very nice not to have to do it, but if you want an accurate score at the root there is no choice other than to analyse all 30 ply because a mis-direction can occur at any, and many, ply in the IA line. Would it not make more sense to send much abbreviated IA lines to IDeA, thus avoiding wasting time in creating and pursuing long potentially sub-optimal lines in the tree?
The only difference my suggestion would make is that it would eliminate the redundant evaluations (that minimax throws away immediately anyhow).
In other words, why calculate something that is immediately discarded?? A waste of time.
Of course, since my suggestion would only affect sequential sequences of moves... in the event queue... sent from the Sandbox... my suggestion would in no way affect evaluations done independently by IDeA. And the Sandbox does not send positions to the queue (hence not sequential) if the position is already in the tree, OR if the position is already IN the queue. So in that case, the sequence would not be sequential and my suggestion would not apply.
You can test my suggestion if you wish, take an empty IDeA project, one with a empty tree, turn off auto-prolongation (just for the testing) and run an engine in Sandbox linked to the tree. Set the Sandbox so that no moves are sent for a couple of minutes (to let the engine settle down) and then have everything sent to the queue. Then watch what happens when the queue finishes and does the minimax. You will see what I mean... all calculations are over-written by the minimax and replaced with the evaluations from the leaf nodes. So why bother with the intermediate calculations? If they are simply to be thrown out?
Of course, the minimax is doing a great error if the leaf node has a bad or poor move. But that is as it is now!
You argument is a good one, but what you are really saying is that we should not rely on the pv coming from the engine. And I agree 100 percent. This is why I have frequently advised people to go thru the tree and manually add alternatives at each node. Because we cannot rely on the move selection shown in the pv. It is merely the starting point. But this does not in anyway refute my suggestion.
For years, I tried the recommended shorter settings of 10 secs or less and 1 ply. The IDeA tree gets filled up quickly and true it is sufficient to get most strong lines.
However, the trees soon become too large and the optimization takes longer and longer.
With longer settings 30 secs + 30 ply, trees are smaller and faster to optimize.
> it is more effective to use longer settings than fast settings.
> With longer settings 30 secs + 30 ply,
Myself, I use 10 minutes + 40 ply. But you have to accumulate a lot of hardware and be very patient.
Using those very long time settings, does it not take almost forever to accumulate at least 500 Node counts (if that is what "N" represents)?
Or do you have 60+ cores at work in IDeA?
> Using those very long time settings, does it not take almost forever to accumulate at least 500 Node counts (if that is what "N" represents)?
> Or do you have 60+ cores at work in IDeA?
I use 60 cores, but it doesn't take too long to get 500 nodes on fairly normal hardware, for example:
An Ivy Bridge 3.0 GHz core at 10 minutes per position (which is my benchmark for my desired level of analysis quality) processes 6 positions / hour.
An overclocked quad on a modern Haswell / Skylake, running 4 cores at 4.2 GHz would process at 40 positions / hour. So in about 12 hours you'd get 500 nodes.
If you can save up and get, say, 3 of them...that's 4 hours total.
> the engine sends moves as a string of moves, one following the other in long sequences. And IDeA dutifully evaluates all
If you have the patience to read this article, I think you will be pleasantly surprised: Sending Games and Position to IDeA. You are waisting more time every day with your current method than it takes to read the article.
Unless I completely misunderstand (which I will fully admit is very possible, if not likely), I am following the suggestions/directions/tips/etc given in that article.
Great to see you back here after a long absence.
The current setup only allows White. Black is played only if you set the rounds to 2. You will have to wait until the engine is finished playing White.
This is useful if one is studying how a strong engine plays the black side of an opening position against several engines.
>to express wishes for 2019.
Really? It would be nice if someone could inform the paying public just what we got new in Aq18, other than a date change at the front. Have anyone actually found anything really new yet? Things maybe a bit faster in IDeA but that is something
I do not use very much, so not too sure about even that as 'new' or 'better'.
In simple words Aq17 was the same as Aq18 but we just paid out for the 7 man T/B I think.
1. Stop counting up analysed positions when entering a transposition. It is very confusing and time consuming to tidy up manually. Really not rocket sience.
2. A graphical interface for handling trees and sub-trees. Show the trees graphically, press left mouce button and e.g move a sub-tree into another tree, delete a sub-tree ...
>Aquarium usable under Linux/Wine
It has only been the last copy of years it has been (more or less) usable under Windows !
On the plus side, that method would enable a rigorous mathematical solution to the problem of chess if it were extended a sufficient number of ply.
The second best way to catch erroneous evaluations at the end or middle of an IA line is to send every move of the line into the IDEA queue for re-evaluation.
This also creates a permanent record of the intermediate moves that can be examined or expanded upon.
The first best way is to become a Grandmaster so you can catch the bad evaluations yourself.
The suggestion only applies to sequences of moves sent from the Sandbox to the IDeA queue. In such a sequence, the last move sent is always the "leaf" node. Whether or not any of the moves is actually a leaf node in the tree. For example, let's take the starting position of Chess and have the engine send the following sequence of moves:
e4 e5 Nf3 Nc6 Bb5 a6
We all know this sequence, very common. I propose that if such a sequence is sent from Sandbox and added to the queue, then the IDeA analysis need not waste time analyzing any move except for the last one, a6. At that point, the IDeA tree could even save further time by assigning the evaluation of a6 to all previous moves in the sequence and then processing as is done now. Of course, ANY move in this sequence can be ignored if already in the tree. And any move prior to such a move can also be ignored -- as they would all be in the tree already (i.e. a future position must have the moves leading up to it)... otherwise the tree would not have internal consistency.
Now I know that this was a trivial example. But it is provided just as a thought experiment. In the real world, I deal with exceptionally long sequences like this that are sent by the 100's, if not 1000's, into the IDeA queue. And IDeA dutifully evaluates them all, unless they are in the tree already... in which case IDeA never puts them into the queue.
In the above example, if we assume that e4 and e5 are already in the tree and only the next 4 moves are new, then we would just drop those existing moves from our analyssis, as IDeA does not actually enter them into the queue now. IDeA only enters new moves into the queue.
I seem to recall that someone has written a script that does what you are asking by taking a tree and re-evaluating only the leaf nodes.
Search around a bit on the forum and see if you can find it, since that is exactly what you are asking for.
A script to re-evaluate leaf nodes does not do what I would like. I am sure it is a great script, but my suggestion is 100 percent concerning NEW events added to the IDeA queue from the Sandbox engine, as such, by definition they do not currently exist in the tree. IDeA does not place any event in the queue from the Sandbox, if the position is already in the tree.
Again, my suggestion would not hamper this important process.
Very seldom am I interested in only the leaf node in a sub-tree. I want to see if there are better lines a long the way as well. Usually there are better lines (or worse).
If only the leaf node will be evaluated I have to manually backtrack the analysis.
Now I am not using the sandbox but only the analysis in "Database" which sends positions to the IDea queue. Hence the Sandbox may do things I am not aware of.
Edit:I wouldn't mind though a function to switch off the analysis of intermediate positions as long as default is as is currently.
The search for alternative continuations would continue under my suggestion. In fact, more resources, percentage wise, would be given to the alternative search, as the linear sequence evaluation is streamlined. Thus affording more time to look at the alternatives.
It's called the Infinite Analysis Tree.
The leaf node values computed by IA are back propagated in that tree without IDEA spending any time on the intermediate moves.
Add that to your tree configuration and you will have exactly what you are asking for as a second tree that parallels the IDEA tree.
You can always manually add positions from the IA tree to the IDEA tree by stepping through the moves in the notation window and then clicking the "Analyze All" button.
All I am suggesting is that the IDeA event queue can be evaluated in a more efficient manner. The end result of my suggestion would be exactly what I have now, just a more efficient use of engine resources in the IDeA queue. Simply put, there are evaluations done in the IDeA queue that don't need to be done. Period.
They don't need to be done because the results of these intermediate evaluations are immediately thrown out by minimax.
Now, there is one downside that I can see to my suggestion. If implemented, the infinite analysis tree would have incorrect evaluations in it. For me, this is no problem. Because I delete that tree daily. And I have multiple installs of Aquarium, and the infinite analysis trees don't sync across them (as far as I know). So even if I didn't delete them I would end up with at least 4 different IA trees that are not in agreement with each other. Not very useful. IMHO.
I totally rely on the Infinie analysis and don't run IDea besides the tasks Infinite analysis sends to its queue and occasionally to find candidates on next level.
The error, if any, introduced into the IA tree would ONLY apply to people that actually do regular IDeA in addition to IA analysis! Because, if you do both then the contents of the IA tree normally records the value from the IA engine, but the IDeA tree would contain a minimaxed value. So you would normally see a divergence between the 2 columns. Originally they are the same, but over time the minimaxed value becomes more refined (different)... largely as a result of IDeA alternative generation cycles.
If my suggestion would be implemented, you would notice no change, since you do not do any IDeA work, i.e. no alternative generation cycles!!
Actually, I find it quite interesting that you rely solely on IA analysis. But if so, my suggestion would be very very good for you. Even with deep IA analysis and very short (high quality) sequences, my suggestion could easily save you between 30 and 50 percent. A huge advantage to you. And if your sequences are longer (as mine are) your savings by avoiding duplicate analysis would truly be astronomical. I routinely process IA sequences of 30 ply that could be evaluated by 1 IDeA event (but IDeA currently does 30 evals)... a huge 30 to 1 reduction.
Of course, since I do regular IDeA analysis in addition to my IA work, the IA trees become meaningless to me AND my time savings would not be anywhere near as great as yours. I believe that the actual time savings in my work (since I use IDeA type analysis heavily) would be in the range of 5 percent. Significant, but much much less than would accrue to someone that processes only the IA events.
The specific tree to which IA writes can be set in the Advanced Engine Options of the IA engine.
In the future I will keep an infinite analysis evaluation tree for each project right next to the IDEA evaluation column in the tree configuration (Which also contains columns for various databases).
The reason I have been deleting the IA tree is because it becomes bloated with unrelated analysis from multiple projects, but that will not be the case with project-specific trees.
One advantage to doing this is that I will be able to note any discrepancies between the evaluations in the IDEA tree and IA tree.
These will be areas where more investigation is warranted.
A second advantage is that the IA engine will not be wasting it's time re-evaluating previous positions in the same project.
1. Would I not have to set the Advanced option each time I changed IDeA project? I think so. Another reason for one of my prior suggestions, i.e. to assign engines on an IDeA project basis.
If you forget to change the assignment, you would end up with partially mixed IA trees. Or the same mixed up result if you have Aquarium IDeA work on multiple projects simultaneously.
2. I cannot see how to stop the IA engine from evaluating positions in the IA tree. As it is, the IDeA engine automatically prevents re-evaluation of positions already in the IDeA tree... but I don't see how the IA tree can influence the evaluation done by the IA engine.
After IDea finished I give the result below at the moves 3.f3 and 2…Qxd5
(before minimax at move 2…Qd5):
Move IDeA N
3.Nc3 +0,45 blank
(before minimax at move 3.f3):
Move IDeA N
3…e5 -0,50 blank
(After minimax at move 2…Qd5):
Move IDeA N
3.Nc3 +0,45 blank
3.f3 -0,50 1
(After minimax at move 3.f3):
Move IDeA N
3...e5 -0,50 blank
My interpretation is that if IDeA only evaluated 3.f3 (the leaf node) we would have missed important information - 3.Nc3 is way better than 3.f3 at least under given conditions and well worth following up.
I think this must mean that you misunderstand what has been suggested.
Of course, to fully understand the evaluation, the full and complete evaluation, of any position, then alternate moves must be considered. To overlook good alternatives, for either side, at any step along the way, will lead to disaster. And many times to a lost game.
I wonder if you are even responding to the same suggestion that I am. How can we be discussing the same thing, and yet be so much out of step??
Perhaps we have a language barrier. I just don't know...
You either have to redirect the IA to the appropriate tree when changing projects or assign a specific IA engine to each project.
(The same engine with a different name works fine).
Not a problem for me because I switch projects about once per week.
As to the IA analysis taking into account what is in the IA tree, I played around with it last night and this is what it does:
When the conditions that determine when to send lines to IDEA are met it also marks the position in the IA tree with the best move evaluation and depth of ply (e.g. -0.37/20). From that point on nothing happens until it changes it's mind about what the best move is, and then it marks that move with the evaluation and depth of ply while leaving the previous best move and ply depth in place. The best move at the deepest ply is highlighted in bold font.
I like it because it keeps a record of how much time I have already spent analyzing each position and also highlights discrepancies between The IA results and IDEA tree evaluations.
My comprehension of your suggestion is very simple: If you send a line to IDeA (e.g 1.e4 d5 2.exd5 Qxd5 3.f3) you propose that IDeA only should analys the leaf - 3.f3. Analysing all positions would be waste of resoures since minimax will override previous results in the tree 1.e4 d5 2.exd5 Qxd5 3.f3.
I have read the entire thread several times coming to that conclusion. Could you please elaborate (guess you must be sick and tired) on my simple interpretation? In what way do I miss the whole thing?
That is to say, the program should go on and search for alternatives, as the IA engine does not always send optimal moves into the queue.
I thought I had stated and re-stated this, and agreed with you several times... that YES, alternatives need to be found and evaluated. That the evaluation is not to end after optimizing the queue. As better moves are found, naturally they will override earlier evaluations (as is done now...).
In other words, I totally agree with your point of view. The analysis cannot be complete until all good alternatives are included. If you are saying something else, then I am completely lost in this discussion.
Seems we agree on the description of the problem domain even if I don't fully comprehend what you mean with "the event queue is optimized". I don't think it matters anyhow.
Feel good that I understand what you mean and thank you for your kind ellaboration and patient.
From my point of view and the way I utilize IA and IDea (to be honest I use a IDeA a liitle bit more than just avaluating IA's tasks) I don't think I will gain anything with your proposed strategy. It doesn't mean that you and others wouldn't.
However, I am sure, like most people, I like to be understood. And if my suggestion is to be rejected, at least let it be rejected based on a correct understanding of the idea.
Any time there are 2 or more moves in sequence adjacent to each other in the event queue, and they are moves not currently in the IDeA tree, time could be saved.
That is my suggestion. If it does not apply, then we discuss nothing. However, it does apply often in my work... and could save me considerable amounts of time.
The strange thing is that Aquarium does already have an option to do what I suggest (in a different way, but the same thing anyhow). But it has a bug and has not worked correctly. In the Advanced Engine Options area, there is an option called "Add moves and evaluations to IDeA tree". In a round-a-bout way, this would do what I want. But sometimes engines send evaluations of +-300 or +-299 (different engines send different things) and once that evaluation gets into the tree, it is hard to get it out. Very hard. And it ruins the structure of the tree until it is removed.
If this worked, it would do what I need.
So if my suggestion is not good. Then I suggest that the Aquarium developers fix this engine option, so that any evaluation beyond +-275 be omitted from the tree and added to the IDeA queue instead. That would suit me fine... either way would work.
Say there is a game that Black wins in 30 moves.
You type the game into the notation window and tell IDEA to evaluate every position.
Since the Pawnslinger's Dream box is checked in the IDEA options menu, it only actually evaluates the final position and produces an evaluation of -300 for every position including the one where the pieces are initially set up.
That doesn't seem like it would be particularly useful.
What IDEA currently does is evaluate all of the intermediate positions and also an alternative at every move, so you can step through the game and get an idea of where the major mistakes were made.
Maybe I am still missing something here, but if so it is not due to a language barrier.
Powered by mwForum 2.27.4 © 1999-2012 Markus Wichitill