Meep

an experimental chess engine as subject of research on machine learning techniques and automated tuning, written by Joel Veness, supported by David Silver, William Uther, and Alan Blair, as elaborated in their 2009 research paper this page is based on, and in Joel Veness' Ph.D. thesis. Meep is based on the UCI compliant tournament chess engine Bodo, where the hand-crafted evaluation function is replaced by a weighted [|linear combination] of 1812 features. Given a position s, a [|feature vector] Φ(s) can be constructed from the 1812 numeric values of each feature. The majority of these features are binary. Φ(s) is typically sparse, with approximately 100 features active in any given position. Five wellknown, chess specific feature construction concepts, material, piece square tables, pawn structure, mobility and king safety were used to generate the 1812 distinct features. In a training mode with various search frameworks, Meep learns from self-play to adjust the weights of its evaluation function towards the value of the deep search. A tournament mode is later used to verify the strength of a trained weight configuration. || toc =BootStrap= In contrast to temporal difference methods such as TD-Leaf as used in KnightCap, where the target search is performed at subsequent time-steps, after a real move and response have been played, Meep performs various [|bootstrapping] techniques during training, dubbed **RootStrap** and **TreeStrap**, to adjust the weights at every time-step inside either a minimax or alpha-beta search.
 * Home * Engines * Meep**
 * [[image:151px-Bizarre_1946_volume_3.jpg link="https://commons.wikimedia.org/wiki/File:Bizarre_1946_volume_3.jpg?uselang=en"]] ||~  || **Meep**,
 * Strapped woman ||~  ||^   ||

With the heuristic evaluation function as linear combination of > math \displaystyle {H_\theta}(s) = \Phi(s)^T \theta math

where Φ(s) is a vector of features of position s, and θ is a parameter vector specifying the weight of each feature in the linear combination, following backup rules are given, using V as backed up value of the minimax or alpha-beta search (left arrow [|theta] (←//θ// ) denotes the operator that updates the heuristic function towards some target value):

\displaystyle {H_\theta}(s_t) \; {\leftarrow^{\!\!\!\! \theta}} \; {H_\theta}(s_{t+1}) math || \displaystyle {H_\theta}(s_t) \; {\leftarrow^{\!\!\!\! \theta}} \; {V_{s_{t+1}}^D}(s_{t+1}) math || \displaystyle {H_\theta}(l^D(s_t)) \; {\leftarrow^{\!\!\!\! \theta}} \; {V_{s_{t+1}}^D}(s_{t+1}) math || \displaystyle {H_\theta}(s_t) \; {\leftarrow^{\!\!\!\! \theta}} \; {V_{s_t}^D}(s_t) math || \displaystyle {H_\theta}(s) \; {\leftarrow^{\!\!\!\! \theta}} \; {V_{s_t}^D}(s), \forall s \in T_{s_t}^D math || \displaystyle {H_\theta}(s) \; {\leftarrow^{\!\!\!\! \theta}} \; \big[{b_{s_t}^D}(s), {a_{s_t}^D}(s)\big], \forall s \in T_{s_t}^{\alpha\beta} math ||
 * ~ Algorithm ||~ ||~ Backup ||
 * TD ||~ || math
 * TD-Root ||~ || math
 * TD-Leaf ||~ || math
 * RootStrap(minimax) ||~ || math
 * TreeStrap(minimax) ||~ || math
 * TreeStrap(αβ) ||~ || math


 * [[image:TDRootAndLeaf.jpg]] ||~  || [[image:Straps.jpg]] ||
 * TD, TD-Root and TD-Leaf backups ||~  || RootStrap and TreeStrap(minimax) backups ||

RootStrap
RootStrap(minimax) or the identical RootStrap(αβ) adjust the weights by [|stochastic gradient descent] on the [|squared error] between the static evaluation and the minimax (or alpha-beta) search value of the root.

> math \displaystyle \delta_{t} = {V_{S_t}^D}(S_t) - {H_\theta}(S_t) math

> math \displaystyle \Delta\theta = -\frac{\eta}{2} {\nabla_\theta} {\delta_{t}^2} = \eta\delta_{t} {\nabla_\theta} {H_\theta}(S_t) math

where η is a step size constant. 

TreeStrap
TreeStrap(mm) also considers all interior nodes of the search tree for the [|stochastic gradient descent] on the [|squared error]. The minimax algorithm used for TreeStrap(mm), keeps the entire tree in memory. TreeStrap(αβ) applies a generic implementation, that uses only a few enhancements, transposition table, killer and history heuristics, and check extensions.

Bounds computed by alpha-beta can be exploited by using a one-sided [|loss functions]. If the static evaluation is larger than alpha, then it is reduced towards alpha. If the value from the heuristic evaluation is smaller than beta, then it is increased respectively.

=Results= A tournament of ~16,000 games of 1 minute per game plus 1 second per move Fischer time between different trained Meep versions and a reference player with randomly initialised weights and arbitrarily assigned rating of 250 was played. Training was previously done by self-play with the same time, using a small opening book to maintain diversity. The target values were determined by at least one ply of full-width search, plus a varying amount of quiescence search. All Elo values are calculated relative to the reference player, the best performance with 95% confidence intervals given :


 * ~ Algorithm ||~ ||~ Elo ||
 * < Untrained ||~ ||> 250 ± 63 ||
 * < TD-Leaf ||~ ||> 1068 ± 36 ||
 * < RootStrap(αβ) ||~ ||> 1362 ± 59 ||
 * < TreeStrap(mm) ||~ ||> 1807 ± 32 ||
 * < TreeStrap(αβ) ||~ ||> 2157 ± 31 ||

=See also=
 * Automated Tuning
 * Bodo
 * KnightCap

=Publications=
 * Joel Veness, David Silver, William Uther, Alan Blair (**2009**). //[|Bootstrapping from Game Tree Search]//. [|pdf]
 * Joel Veness (**2011**). //Approximate Universal Artificial Intelligence and Self-Play Learning for Games//. Ph.D. thesis, [|University of New South Wales], supervisors: Kee Siong Ng, Marcus Hutter, Alan Blair, William Uther, John Lloyd; [|pdf]
 * István Szita (**2012**). //[|Reinforcement Learning in Games]//. in Marco Wiering, [|Martijn Van Otterlo] (eds.). //[|Reinforcement learning: State-of-the-art]//. [|Adaptation, Learning, and Optimization, Vol. 12], [|Springer]

=Forum Posts= > [|Re: A paper about parameter tuning] by Joel Veness, CCC, January 15, 2010 > [|Re: A paper about parameter tuning] by Joel Veness, CCC, January 15, 2010
 * [|A paper about parameter tuning] by Rémi Coulom, CCC, January 12, 2010

=External Links= > [|Wearing suspenders or garter belts from Wikipedia] > feat: Eberhard Weber, John Marshall, [|Stan Sulzmann], [|John Taylor], [|Cees See], Zbigniew Seifert > media type="youtube" key="neBBmEAHQoQ" width="560"
 * [|Bootstrapping from Game Tree Search], video presentation by Joel Veness, from [|VideoLectures - exchange ideas & share knowledge], December 2009
 * [|Meep from Wikipedia]
 * [|Urban Dictionary: meep]
 * [|Bootstrapping from Wikipedia]
 * [|Bootstrapping (disambiguation) from Wikipedia]
 * [|Bootstrap aggregating from Wikipedia]
 * [|Strapping from Wikipedia]
 * [|Strapse from Wikipedia.de] (German)
 * Volker Kriegel - Three Or Two In One, [|Lift!], 1973, [|YouTube] Video

=References= =What links here?= include page="Meep" component="backlinks" limit="40"
 * Up one level**