Answers.Body: <p>Here's a good starting point. Material comparison is key (and easy), then you can tune that to consider positional aspects like open ranks/files/diagonals, pawn structure, etc.</p>
  
  <p><a href="https://www.chessprogramming.org/Evaluation" rel="nofollow noreferrer">https://www.chessprogramming.org/Evaluation</a></p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2012-05-11T03:39:43.070Z
Answers.LastActivityDate: 2019-06-30T18:46:46.227Z
Answers.LastEditDate: 2019-06-30T18:46:46.227Z
Answers.UserDisplayName: Eve Freeman
Answers.Body: <p>I have a feeling I'm a little late on this answer but - I'm also in the process of making an engine.  The source code is in Python (which is fairly easy to read, even if you don't know it) and is available <a href="https://www.github.com/671620616/PhantomChess" rel="nofollow noreferrer">here</a> if you wish to read it.  The list of currently active 'heuristics' (at the time of posting):</p>
  
  <ul>
  <li>Farther developed (closer to the opposite side) pieces are better</li>
  <li>Pawns closer to promotion are good </li>
  <li>Kings are scored separately based on what phase the game is in (opening, middlegame, endgame)</li>
  <li>If the player has both bishops, that receives a bonus</li>
  <li>If the player has castled, receive a bonus</li>
  <li>Isolated pawns (pawns with nothing around them) are not good</li>
  <li>Doubled pawns (two pawns on the same file with no gap between) are not good</li>
  <li>Having all 8 pawns is not necessary a good thing and is penalized (they clutter the board and get in the way)</li>
  <li>Have a look at <a href="http://chessprogramming.wikispaces.com/Simplified+evaluation+function" rel="nofollow noreferrer">this great evaluation function</a> which is also used</li>
  <li>Bishops with more pawns on the same color square as the bishop are penalized (they aren't as good in crowded situations)</li>
  <li>Not yet implemented, but planned: Knights get a bonus in more crowded situations</li>
  </ul>
  
  <p>In one of those points, I mentioned the 'phase' of the game (e.g. opening, middlegame, endgame), and if you wish to include that in your engine, you'll probably run into the same problem as I did: there's no clear line separating those.  My function that decides what phase the game is in uses a few things:</p>
  
  <ul>
  <li>Amount of material on the board (as soon as any piece is killed, it marks the game as not in the opening)</li>
  <li>Number of moves (less than 6 full moves is the opening, no matter what)</li>
  <li>movement of the queens (if both queens have been moved, mark the game as middlegame)</li>
  </ul>
  
  <p>This answer may have been long, late and off-topic, but I hope it was helpful anyways.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2015-03-01T03:17:29.000Z
Answers.LastActivityDate: 2020-03-03T17:02:11.260Z
Answers.LastEditDate: 2020-03-03T17:02:11.260Z
Answers.UserDisplayName: mishaturnbull
Answers.Body: <p>Adding up to the answer by @Eve Freeman, I would suggest looking up how does the best computer engine in the world, Stockfish, evaluate a given position. As the <a href="https://github.com/official-stockfish/Stockfish" rel="nofollow noreferrer">source code</a> is open, you can do it for free. I think the file with the evaluation function you are looking for is <a href="https://github.com/official-stockfish/Stockfish/blob/master/src/evaluate.cpp" rel="nofollow noreferrer">this one</a>.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2014-09-20T21:53:40.120Z
Answers.LastActivityDate: 2019-06-30T18:47:17.747Z
Answers.LastEditDate: 2019-06-30T18:47:17.747Z
Answers.UserDisplayName: Pablo S. Ocal
Answers.Body: <p>Surprisingly, it turns out that a Minimax engine will play reasonably well when the evaluation function is <strong>random</strong>; this is known as the Beale effect, and results from the principle that positions which give you more options and your opponent fewer options are generally favourable.  One reasonable way to generate random evaluations consistently and efficiently is to generate a Zobrist hash for the position (using coefficients chosen randomly at the start of the game), and derive the random evaluation directly from the hash.</p>
  
  <p>At the opposite end of the scale, AlphaZero and Leela conduct an extremely sophisticated evaluation of each position searched, using a <strong>large neural network</strong>.  It is impractical to describe in human terms what functions this network effectively implements, but it is undeniably more effective than Stockfish's evaluation function.  The AlphaZero research paper indicates that this approach works best with Monte-Carlo Tree Search rather than Minimax.</p>
  
  <p>If, on the other hand, you want to develop an <strong>analysis engine</strong> to help human players or commentators understand the nuances of a position, it may be worthwhile to implement a conventional evaluation function using <strong>established material values and positional theory</strong>.  A good example is set by Ed Schröder's <a href="http://members.home.nl/matador/Inside%20Rebel.pdf" rel="nofollow noreferrer"><em>Inside Rebel</em></a>, documenting the major design features of a well-regarded engine used in several of Mephisto's chess computers.  You may wish to use a certain degree of machine learning to determine the relative importance of each element of your evaluation function, and also break out these elements individually for presentation in a GUI.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-06-30T23:48:44.640Z
Answers.LastActivityDate: 2019-07-02T11:52:39.573Z
Answers.LastEditDate: 2019-07-02T11:52:39.573Z
Answers.UserDisplayName: Chromatix
Answers.Body: <p>I think chess programmers tend not to rely on the knowledge of strong chess players when designing their evaluation functions, but instead try out different elements, and then test them in games against other engines, and decide what to keep.  Larry Kaufman talks a fair bit about his views on what a human's understanding is, but it sounds like both Rajlich and Dailey were very results oriented, and did not adopt Kaufman's ideas wholesale.</p>
  
  <p>One article I found interesting was Zach Wegner comparing the evaluation functions of Rybka and Fruit.  One of the areas where Rybka may have represented a step forward was in its incorporation of material imbalance tables based on specific combinations of pieces.  Kaufman wrote an article on this as well.</p>
  
  <p><a href="http://www.top-5000.nl/ZW_Rybka_Fruit.pdf" rel="nofollow">http://www.top-5000.nl/ZW_Rybka_Fruit.pdf</a>
  <a href="http://danheisman.home.comcast.net/~danheisman/Articles/evaluation_of_material_imbalance.htm" rel="nofollow">http://danheisman.home.comcast.net/~danheisman/Articles/evaluation_of_material_imbalance.htm</a></p>
  
Answers.ContentLicense: CC BY-SA 3.0
Answers.CreationDate: 2015-09-23T11:46:38.790Z
Answers.LastActivityDate: 2015-09-23T11:46:38.790Z
Answers.UserDisplayName: A passerby
Answers.Body: <p>In a nutshell, the standard approach to tuning a chess engine's parameters is to:</p>
  
  <ol>
  <li>Define the parameters</li>
  <li>Give the parameters nominal (starting) values</li>
  <li>Run the engine to see how it performs</li>
  <li>Tune the parameter values to try to improve its performance</li>
  </ol>
  
  <p>Then repeat Steps 3 and 4 until you've reached your goal for performance.</p>
  
  <p>The usual approach to doing this is to set up a laboratory where engines face off in engine tournaments.  Multiple games are used in which the engine plays both colors.  The main tournaments of interest involve running an engine with parameter value set A against the same engine with parameter value set B.</p>
  
  <p>As you can probably guess, results from this approach are heavily dependent on:</p>
  
  <ul>
  <li>The parameters chosen</li>
  <li>How the parameters are specified</li>
  <li>How the parameter values are varied throughout the testing</li>
  <li>How the engines are run (limited ply-depth, limited time, sensitivity, etc)</li>
  </ul>
  
  <p>This approach also consumes <em>a lot</em> of time.</p>
  
  <p>A more recent (and innovative approach) was developed in 2010 by researchers using Genetic Algorithm techniques to a) specify the parameters, and b) tune the parameter values.  The investigators first ran an engine with a starting, nominal set of parameter values against a <em>set of grandmaster games</em> to see if it could effectively choose the "best move". The "best move" was defined as the move the grandmaster made*.  Wherever it failed to do so was recorded.  Then, another parameter value set was tried, and relative performance vs the prior run determined.  </p>
  
  <p>Then, a programmatic approach to <em>combining the parameter values</em> was tried, using the Genetic Algorithm principle of survival of the "fittest". Here, "fittest" means the one that generates output that most closely matches the ideal. (It also happens to be a pun on the statistical technique of "least squares fit" regression, a technique used to judge the quality of the approximation.)</p>
  
  <p>Only after engine parameters have been found that can mimic a GM reasonably well does the actual engine tournament phase begin.  In this phase, different parameter value sets are once again pitted against each other, this time <em>directly</em>.  Genetic Algorithm improvement techniques are applied to generate successively better generations of the engine.</p>
  
  <p>In this research project, 36 parameters were used, including all of the material values of the pieces, and many of the more common strategic evaluation criteria, such as backward pawns, weak squares, bishop pair, and so on.  However, the researchers added some new parameters, such as "king pressure", "mobility" values for each kind of piece, rook on a file adjacent to the king, rook on a semi-open file, rook attacking the king on the a-/b-/g-/h-file, separation between a passed pawn and the defending king, and more.</p>
  
  <p>Unfortunately, the researchers don't elaborate on how they came up with this suite of parameters, and what alternate parameters they may have tested and rejected.  It would be reasonable to assume that they began with a much larger set, and determined (through trial and error) which ones had the greatest effect on performance, and which ones were either insignificant or derivative, and so could be dropped.</p>
  
  <p>If this sounds like it might be useful, you can find the research <a href="https://www.researchgate.net/publication/220174485_Genetic_Algorithms_for_Automatic_Search_Tuning?enrichId=rgreq-f65e8ac5722304e4f9b279e10f30e55f-XXX&amp;enrichSource=Y292ZXJQYWdlOzIyMDE3NDQ4NTtBUzoxMDUwMjM1MzA4NjQ2NDNAMTQwMjA1MDk2OTUxMA%3D%3D&amp;el=1_x_2" rel="nofollow"><strong><em>here</em></strong></a>.</p>
  
  <p>*A caveat about a phase of the approach that the researchers used is in order. In his Introduction to <em>Understanding Chess Move by Move</em>, John Nunn chose "...hard fought games between strong grandmasters..." to illustrate his themes.  He then adds:</p>
  
  <blockquote>
    <p>Readers may be quite surprised to see the number of question marks that adorn the games in this book. Surely, you might think, with just thirty games to select, it should have been easy to find some sound games. However, I can assure you that it was not. ... it is possible to find fault with virtually any complex, hard-fought game... I have never felt that my play was anywhere near completely accurate, so I personally don't find these revelations distressing. However, some may find it hard to admit that chess as played by human beings is less accurate than previously thought.</p>
  </blockquote>
  
  <p>The point that Dr Nunn raises suggests that the researchers' initial approach to setting the engine parameters by requiring them to imitate grandmaster moves may be flawed <em>because human play is flawed</em>. In fact, it's well established that <em>engines already play better than humans</em>.</p>
  
  <p>Therefore, perhaps a better approach to setting the initial parameters would be to match a new engine against <em>a superior existing engine</em>.</p>
  
Answers.ContentLicense: CC BY-SA 3.0
Answers.CreationDate: 2016-10-21T16:20:08.307Z
Answers.LastActivityDate: 2016-10-21T16:20:08.307Z
Answers.UserDisplayName: jaxter
Answers.Body: <p>There is a nice website at:</p>
  
  <blockquote>
    <p><a href="https://hxim.github.io/Stockfish-Evaluation-Guide/" rel="nofollow noreferrer">https://hxim.github.io/Stockfish-Evaluation-Guide/</a></p>
  </blockquote>
  
  <p>It gives you an introduction on how the Stockfish functions work.</p>
  
  <p><a href="https://i.sstatic.net/miAcF.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/miAcF.png" alt="enter image description here"></a></p>
  
Answers.ContentLicense: CC BY-SA 3.0
Answers.CreationDate: 2017-04-19T01:47:56.747Z
Answers.LastActivityDate: 2017-04-19T01:47:56.747Z
Answers.UserDisplayName: SmallChess
Answers.Body: <p>This link is the best starting point IMHO. I am using this as my starting point for my own chess program &amp; finding it simple to understand and useful too.</p>
  
  <p><a href="https://chessprogramming.wikispaces.com/Simplified+evaluation+function" rel="nofollow">https://chessprogramming.wikispaces.com/Simplified+evaluation+function</a></p>
  
Answers.ContentLicense: CC BY-SA 3.0
Answers.CreationDate: 2015-01-11T10:50:17.897Z
Answers.Text: Could you please expand briefly on the contents of the link?
Answers.UserDisplayName: Pablo S. Ocal
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-07-01T01:05:58.583Z
Answers.Text: The Wikispaces site is now defunct.  A corrected link to its new home: https://www.chessprogramming.org/Simplified_Evaluation_Function
Answers.UserDisplayName: Chromatix
Answers.ContentLicense: CC BY-SA 3.0
Answers.CreationDate: 2015-01-10T05:27:18.377Z
Answers.LastActivityDate: 2015-01-10T05:27:18.377Z
Answers.UserDisplayName: techcraver
Body: <p>I've been interested for a while about a computer chess AI algorithms (and got the chance to work on one at some point) like <a href="http://en.wikipedia.org/wiki/Minimax" rel="noreferrer">Minimax</a>, and as the core component of these algorithms is the so-called <strong>evaluation function</strong> to determine what is a <em>good</em> board configuration, and what is a <em>bad</em> one.</p>
  
  <p>In other terms, given a configuration of your Chess board, how do you determine that it is to your advantage, and with what degree of confidence?</p>
  
  <p>For example:</p>
  
  <ul>
  <li>If you <em>own</em> the center, this is rather favorable.</li>
  <li>If you have more pieces than your opponent, this is rather favorable.</li>
  <li>If you lost your Queen, this is rather not favorable.</li>
  <li>If you have a pawn that is close to being promoted this is favorable.</li>
  <li>...</li>
  </ul>
  
  <p>So I would like to ask for some advice on how to create a <em>good</em> evaluation function, based on some expert knowledge about the Chess game in general. And if possible, a degree of favorability (say between 1 being very not favorable, to 100 being extremely favorable).</p>
  
  <p>The idea in the end is to be able to create an algorithm that will look in the tree of possibilities up to a certain depth and evaluate what the most favorable configuration for next move is (taking into account several moves in the future) based on what is favorable to the player and not favorable to the opponent. But without a good evaluation function the algorithm is nothing.</p>
  
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-01-22T18:17:06.393Z
Comments.Text: How accurate. The only completely accurate way is did  you win or lose or tie.
Comments.UserDisplayName: edwina oliver
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2012-05-10T18:05:08.707Z
Comments.Text: I think this question would do well on StackOverflow. There are a lot of questions on there already regarding Chess AI
Comments.UserDisplayName: xaisoft
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2012-05-10T23:36:38.147Z
Comments.Text: I thought to post it on SO before, but I'm almost sure it would be closed as not constructive or not a real question there. Maybe if I need more emphasis on the code itself, but I think for the evaluation function it requires knowledge about chess, not so much about code or algorithms.
Comments.UserDisplayName: Charles Menguy
Tags: <engines><positional-play><evaluation><chess-algorithms>
Title: What is an accurate way to evaluate chess positions?
ThreadText: # What is an accurate way to evaluate chess positions?
  
  (Asked by: username_0 on 2012-05-10)
  
  I've been interested for a while about a computer chess AI algorithms (and got the chance to work on one at some point) like [Minimax](http://en.wikipedia.org/wiki/Minimax), and as the core component of these algorithms is the so-called **evaluation function** to determine what is a *good* board configuration, and what is a *bad* one.
  
  In other terms, given a configuration of your Chess board, how do you determine that it is to your advantage, and with what degree of confidence?
  
  For example:
  
  * If you *own* the center, this is rather favorable.
  * If you have more pieces than your opponent, this is rather favorable.
  * If you lost your Queen, this is rather not favorable.
  * If you have a pawn that is close to being promoted this is favorable.
  * ...
  
  So I would like to ask for some advice on how to create a *good* evaluation function, based on some expert knowledge about the Chess game in general. And if possible, a degree of favorability (say between 1 being very not favorable, to 100 being extremely favorable).
  
  The idea in the end is to be able to create an algorithm that will look in the tree of possibilities up to a certain depth and evaluate what the most favorable configuration for next move is (taking into account several moves in the future) based on what is favorable to the player and not favorable to the opponent. But without a good evaluation function the algorithm is nothing.
  
  **Tags:** engines, positional-play, evaluation, chess-algorithms
  
  > **Comments:**
  > **username_2**: I think this question would do well on StackOverflow. There are a lot of questions on there already regarding Chess AI  
  > **username_0**: I thought to post it on SO before, but I'm almost sure it would be closed as not constructive or not a real question there. Maybe if I need more emphasis on the code itself, but I think for the evaluation function it requires knowledge about chess, not so much about code or algorithms.  
  > **username_1**: How accurate. The only completely accurate way is did  you win or lose or tie.  
  
  ---
  
  ## 8 answers
  
  ### Answer by username_3 on 2012-05-11. Score: 11
  
  Here's a good starting point. Material comparison is key (and easy), then you can tune that to consider positional aspects like open ranks/files/diagonals, pawn structure, etc.
  
  <https://www.chessprogramming.org/Evaluation>
  
  
  ---
  
  ### Answer by username_4 on 2015-03-01. Score: 9
  
  I have a feeling I'm a little late on this answer but - I'm also in the process of making an engine. The source code is in Python (which is fairly easy to read, even if you don't know it) and is available [here](https://www.github.com/671620616/PhantomChess) if you wish to read it. The list of currently active 'heuristics' (at the time of posting):
  
  * Farther developed (closer to the opposite side) pieces are better
  * Pawns closer to promotion are good
  * Kings are scored separately based on what phase the game is in (opening, middlegame, endgame)
  * If the player has both bishops, that receives a bonus
  * If the player has castled, receive a bonus
  * Isolated pawns (pawns with nothing around them) are not good
  * Doubled pawns (two pawns on the same file with no gap between) are not good
  * Having all 8 pawns is not necessary a good thing and is penalized (they clutter the board and get in the way)
  * Have a look at [this great evaluation function](http://chessprogramming.wikispaces.com/Simplified+evaluation+function) which is also used
  * Bishops with more pawns on the same color square as the bishop are penalized (they aren't as good in crowded situations)
  * Not yet implemented, but planned: Knights get a bonus in more crowded situations
  
  In one of those points, I mentioned the 'phase' of the game (e.g. opening, middlegame, endgame), and if you wish to include that in your engine, you'll probably run into the same problem as I did: there's no clear line separating those. My function that decides what phase the game is in uses a few things:
  
  * Amount of material on the board (as soon as any piece is killed, it marks the game as not in the opening)
  * Number of moves (less than 6 full moves is the opening, no matter what)
  * movement of the queens (if both queens have been moved, mark the game as middlegame)
  
  This answer may have been long, late and off-topic, but I hope it was helpful anyways.
  
  
  ---
  
  ### Answer by username_5 on 2014-09-20. Score: 6
  
  Adding up to the answer by @username_3, I would suggest looking up how does the best computer engine in the world, Stockfish, evaluate a given position. As the [source code](https://github.com/official-stockfish/Stockfish) is open, you can do it for free. I think the file with the evaluation function you are looking for is [this one](https://github.com/official-stockfish/Stockfish/blob/master/src/evaluate.cpp).
  
  
  ---
  
  ### Answer by username_6 on 2019-06-30. Score: 5
  
  Surprisingly, it turns out that a Minimax engine will play reasonably well when the evaluation function is **random**; this is known as the Beale effect, and results from the principle that positions which give you more options and your opponent fewer options are generally favourable. One reasonable way to generate random evaluations consistently and efficiently is to generate a Zobrist hash for the position (using coefficients chosen randomly at the start of the game), and derive the random evaluation directly from the hash.
  
  At the opposite end of the scale, AlphaZero and Leela conduct an extremely sophisticated evaluation of each position searched, using a **large neural network**. It is impractical to describe in human terms what functions this network effectively implements, but it is undeniably more effective than Stockfish's evaluation function. The AlphaZero research paper indicates that this approach works best with Monte-Carlo Tree Search rather than Minimax.
  
  If, on the other hand, you want to develop an **analysis engine** to help human players or commentators understand the nuances of a position, it may be worthwhile to implement a conventional evaluation function using **established material values and positional theory**. A good example is set by Ed Schröder's [*Inside Rebel*](http://members.home.nl/matador/Inside%20Rebel.pdf), documenting the major design features of a well-regarded engine used in several of Mephisto's chess computers. You may wish to use a certain degree of machine learning to determine the relative importance of each element of your evaluation function, and also break out these elements individually for presentation in a GUI.
  
  
  ---
  
  ### Answer by username_7 on 2015-09-23. Score: 4
  
  I think chess programmers tend not to rely on the knowledge of strong chess players when designing their evaluation functions, but instead try out different elements, and then test them in games against other engines, and decide what to keep. Larry Kaufman talks a fair bit about his views on what a human's understanding is, but it sounds like both Rajlich and Dailey were very results oriented, and did not adopt Kaufman's ideas wholesale.
  
  One article I found interesting was Zach Wegner comparing the evaluation functions of Rybka and Fruit. One of the areas where Rybka may have represented a step forward was in its incorporation of material imbalance tables based on specific combinations of pieces. Kaufman wrote an article on this as well.
  
  <http://www.top-5000.nl/ZW_Rybka_Fruit.pdf>
  <http://danheisman.home.comcast.net/~danheisman/Articles/evaluation_of_material_imbalance.htm>
  
  
  ---
  
  ### Answer by username_8 on 2016-10-21. Score: 0
  
  In a nutshell, the standard approach to tuning a chess engine's parameters is to:
  
  1. Define the parameters
  2. Give the parameters nominal (starting) values
  3. Run the engine to see how it performs
  4. Tune the parameter values to try to improve its performance
  
  Then repeat Steps 3 and 4 until you've reached your goal for performance.
  
  The usual approach to doing this is to set up a laboratory where engines face off in engine tournaments. Multiple games are used in which the engine plays both colors. The main tournaments of interest involve running an engine with parameter value set A against the same engine with parameter value set B.
  
  As you can probably guess, results from this approach are heavily dependent on:
  
  * The parameters chosen
  * How the parameters are specified
  * How the parameter values are varied throughout the testing
  * How the engines are run (limited ply-depth, limited time, sensitivity, etc)
  
  This approach also consumes *a lot* of time.
  
  A more recent (and innovative approach) was developed in 2010 by researchers using Genetic Algorithm techniques to a) specify the parameters, and b) tune the parameter values. The investigators first ran an engine with a starting, nominal set of parameter values against a *set of grandmaster games* to see if it could effectively choose the "best move". The "best move" was defined as the move the grandmaster made\*. Wherever it failed to do so was recorded. Then, another parameter value set was tried, and relative performance vs the prior run determined.
  
  Then, a programmatic approach to *combining the parameter values* was tried, using the Genetic Algorithm principle of survival of the "fittest". Here, "fittest" means the one that generates output that most closely matches the ideal. (It also happens to be a pun on the statistical technique of "least squares fit" regression, a technique used to judge the quality of the approximation.)
  
  Only after engine parameters have been found that can mimic a GM reasonably well does the actual engine tournament phase begin. In this phase, different parameter value sets are once again pitted against each other, this time *directly*. Genetic Algorithm improvement techniques are applied to generate successively better generations of the engine.
  
  In this research project, 36 parameters were used, including all of the material values of the pieces, and many of the more common strategic evaluation criteria, such as backward pawns, weak squares, bishop pair, and so on. However, the researchers added some new parameters, such as "king pressure", "mobility" values for each kind of piece, rook on a file adjacent to the king, rook on a semi-open file, rook attacking the king on the a-/b-/g-/h-file, separation between a passed pawn and the defending king, and more.
  
  Unfortunately, the researchers don't elaborate on how they came up with this suite of parameters, and what alternate parameters they may have tested and rejected. It would be reasonable to assume that they began with a much larger set, and determined (through trial and error) which ones had the greatest effect on performance, and which ones were either insignificant or derivative, and so could be dropped.
  
  If this sounds like it might be useful, you can find the research [***here***](https://www.researchgate.net/publication/220174485_Genetic_Algorithms_for_Automatic_Search_Tuning?enrichId=rgreq-f65e8ac5722304e4f9b279e10f30e55f-XXX&enrichSource=Y292ZXJQYWdlOzIyMDE3NDQ4NTtBUzoxMDUwMjM1MzA4NjQ2NDNAMTQwMjA1MDk2OTUxMA%3D%3D&el=1_x_2).
  
  \*A caveat about a phase of the approach that the researchers used is in order. In his Introduction to *Understanding Chess Move by Move*, John Nunn chose "...hard fought games between strong grandmasters..." to illustrate his themes. He then adds:
  
  > Readers may be quite surprised to see the number of question marks that adorn the games in this book. Surely, you might think, with just thirty games to select, it should have been easy to find some sound games. However, I can assure you that it was not. ... it is possible to find fault with virtually any complex, hard-fought game... I have never felt that my play was anywhere near completely accurate, so I personally don't find these revelations distressing. However, some may find it hard to admit that chess as played by human beings is less accurate than previously thought.
  
  The point that Dr Nunn raises suggests that the researchers' initial approach to setting the engine parameters by requiring them to imitate grandmaster moves may be flawed *because human play is flawed*. In fact, it's well established that *engines already play better than humans*.
  
  Therefore, perhaps a better approach to setting the initial parameters would be to match a new engine against *a superior existing engine*.
  
  
  ---
  
  ### Answer by username_9 on 2017-04-19. Score: 0
  
  There is a nice website at:
  
  > <https://hxim.github.io/Stockfish-Evaluation-Guide/>
  
  It gives you an introduction on how the Stockfish functions work.
  
  [![enter image description here](https://i.sstatic.net/miAcF.png)](https://i.sstatic.net/miAcF.png)
  
  
  ---
  
  ### Answer by username_10 on 2015-01-10. Score: 0
  
  This link is the best starting point IMHO. I am using this as my starting point for my own chess program & finding it simple to understand and useful too.
  
  <https://chessprogramming.wikispaces.com/Simplified+evaluation+function>
  
  > **Comments:**
  > **username_5**: Could you please expand briefly on the contents of the link?  
  > **username_6**: The Wikispaces site is now defunct.  A corrected link to its new home: https://www.chessprogramming.org/Simplified_Evaluation_Function  
  
  ---
  
  