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.
> 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.
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.
Powered by mwForum 2.27.4 © 1999-2012 Markus Wichitill