uct/internal.h

   1 #ifndef PACHI_UCT_INTERNAL_H
   2 #define PACHI_UCT_INTERNAL_H
   3
   4 /* Internal UCT structures */
   5
   6 #include "debug.h"
   7 #include "move.h"
   8 #include "ownermap.h"
   9 #include "pattern.h"
  10 #include "patternsp.h"
  11 #include "patternprob.h"
  12 #include "playout.h"
  13 #include "stats.h"
  14
  15 struct tree;
  16 struct tree_node;
  17 struct uct_policy;
  18 struct uct_prior;
  19 struct uct_dynkomi;
  20 struct uct_pluginset;
  21 struct joseki_dict;
  22
  23 /* How big proportion of ownermap counts must be of one color to consider
  24  * the point sure. */
  25 #define GJ_THRES        0.8
  26 /* How many games to consider at minimum before judging groups. */
  27 #define GJ_MINGAMES     500
  28
  29 /* Internal engine state. */
  30 struct uct {
  31         int debug_level;
  32         enum uct_reporting {
  33                 UR_TEXT,
  34                 UR_JSON,
  35                 UR_JSON_BIG,
  36         } reporting;
  37         int reportfreq;
  38
  39         int games, gamelen;
  40         floating_t resign_threshold, sure_win_threshold;
  41         double best2_ratio, bestr_ratio;
  42         floating_t max_maintime_ratio;
  43         bool pass_all_alive; /* Current value */
  44         bool allow_losing_pass;
  45         bool territory_scoring;
  46         int expand_p;
  47         bool playout_amaf;
  48         bool amaf_prior;
  49         int playout_amaf_cutoff;
  50         int dumpthres;
  51         int force_seed;
  52         bool no_tbook;
  53         bool fast_alloc;
  54         unsigned long max_tree_size;
  55         unsigned long max_pruned_size;
  56         unsigned long pruning_threshold;
  57         int mercymin;
  58         int significant_threshold;
  59
  60         int threads;
  61         enum uct_thread_model {
  62                 TM_TREE, /* Tree parallelization w/o virtual loss. */
  63                 TM_TREEVL, /* Tree parallelization with virtual loss. */
  64         } thread_model;
  65         int virtual_loss;
  66         bool pondering_opt; /* User wants pondering */
  67         bool pondering; /* Actually pondering now */
  68         bool slave; /* Act as slave in distributed engine. */
  69         int max_slaves; /* Optional, -1 if not set */
  70         int slave_index; /* 0..max_slaves-1, or -1 if not set */
  71         enum stone my_color;
  72
  73         int fuseki_end;
  74         int yose_start;
  75
  76         int dynkomi_mask;
  77         int dynkomi_interval;
  78         struct uct_dynkomi *dynkomi;
  79         floating_t initial_extra_komi;
  80
  81         floating_t val_scale;
  82         int val_points;
  83         bool val_extra;
  84         bool val_byavg;
  85         bool val_bytemp;
  86         floating_t val_bytemp_min;
  87
  88         int random_policy_chance;
  89         bool local_tree;
  90         int tenuki_d;
  91         floating_t local_tree_aging;
  92 #define LTREE_PLAYOUTS_MULTIPLIER 100
  93         floating_t local_tree_depth_decay;
  94         bool local_tree_allseq;
  95         bool local_tree_neival;
  96         enum {
  97                 LTE_ROOT,
  98                 LTE_EACH,
  99                 LTE_TOTAL,
 100         } local_tree_eval;
 101         bool local_tree_rootchoose;
 102
 103         char *banner;
 104
 105         struct uct_policy *policy;
 106         struct uct_policy *random_policy;
 107         struct playout_policy *playout;
 108         struct uct_prior *prior;
 109         struct uct_pluginset *plugins;
 110         struct joseki_dict *jdict;
 111
 112         struct pattern_setup pat;
 113         /* Various modules (prior, policy, ...) set this if they want pattern
 114          * database to be loaded. */
 115         bool want_pat;
 116
 117         /* Used within frame of single genmove. */
 118         struct board_ownermap ownermap;
 119         /* Used for coordination among slaves of the distributed engine. */
 120         int stats_hbits;
 121         int shared_nodes;
 122         int shared_levels;
 123         double stats_delay; /* stored in seconds */
 124         int played_own;
 125         int played_all; /* games played by all slaves */
 126
 127         /* Game state - maintained by setup_state(), reset_state(). */
 128         struct tree *t;
 129 };
 130
 131 #define UDEBUGL(n) DEBUGL_(u->debug_level, n)
 132
 133 bool uct_pass_is_safe(struct uct *u, struct board *b, enum stone color, bool pass_all_alive);
 134
 135 void uct_prepare_move(struct uct *u, struct board *b, enum stone color);
 136 void uct_genmove_setup(struct uct *u, struct board *b, enum stone color);
 137 void uct_pondering_stop(struct uct *u);
 138
 139
 140 /* This is the state used for descending the tree; we use this wrapper
 141  * structure in order to be able to easily descend in multiple trees
 142  * in parallel (e.g. main tree and local tree) or compute cummulative
 143  * "path value" throughout the tree descent. */
 144 struct uct_descent {
 145         /* Active tree nodes: */
 146         struct tree_node *node; /* Main tree. */
 147         struct tree_node *lnode; /* Local tree. */
 148         /* Value of main tree node (with all value factors, but unbiased
 149          * - without exploration factor), from black's perspective. */
 150         struct move_stats value;
 151 };
 152
 153
 154 typedef struct tree_node *(*uctp_choose)(struct uct_policy *p, struct tree_node *node, struct board *b, enum stone color, coord_t exclude);
 155 typedef floating_t (*uctp_evaluate)(struct uct_policy *p, struct tree *tree, struct uct_descent *descent, int parity);
 156 typedef void (*uctp_descend)(struct uct_policy *p, struct tree *tree, struct uct_descent *descent, int parity, bool allow_pass);
 157 typedef void (*uctp_winner)(struct uct_policy *p, struct tree *tree, struct uct_descent *descent);
 158 typedef void (*uctp_prior)(struct uct_policy *p, struct tree *tree, struct tree_node *node, struct board *b, enum stone color, int parity);
 159 typedef void (*uctp_update)(struct uct_policy *p, struct tree *tree, struct tree_node *node, enum stone node_color, enum stone player_color, struct playout_amafmap *amaf, struct board *final_board, floating_t result);
 160
 161 struct uct_policy {
 162         struct uct *uct;
 163         uctp_choose choose;
 164         uctp_winner winner;
 165         uctp_evaluate evaluate;
 166         uctp_descend descend;
 167         uctp_update update;
 168         uctp_prior prior;
 169         bool wants_amaf;
 170         void *data;
 171 };
 172
 173 #endif