Certainty propagation negabound [WIP]

.gitignore

@@ -8,3 +8,5 @@ subprojects/*
 !subprojects/*.wrap
 lc0.xcodeproj/
 *.swp
+.vs/
+build-cuda.cmd

build-cuda.cmd

@@ -1,14 +1,20 @@
 rd /s build
 
-call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
-meson.py build --backend vs2015 --buildtype release ^
--Dcudnn_libdirs="C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.2\lib\x64","C:\dev\cuDNN\cuda\lib\x64" ^
--Dcudnn_include="C:\dev\cuDNN\cuda\include" ^
+rem set MSBuild="C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe"
+set MSBuild="C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin\MSBuild.exe"
+rem call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" amd64
+meson.py build --backend vs2017 --buildtype release ^
+-Dcudnn_libdirs="C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\lib\x64","C:\dev\cuDNN\cuda\lib\x64" ^
+-Dcudnn_include="C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\include","C:\dev\cuDNN\cuda\include" ^
 -Ddefault_library=static
 
+pause
+
+
 cd build
 
-"C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe" ^
+%MSBuild%  ^
 /p:Configuration=Release ^
 /p:Platform=x64 ^
 /p:PreferredToolArchitecture=x64 lc0.sln ^

src/chess/board.cc

@@ -186,6 +186,7 @@ BitBoard ChessBoard::en_passant() const { return pawns_ - pawns(); }
 
 MoveList ChessBoard::GeneratePseudolegalMoves() const {
   MoveList result;
+  result.reserve(60);
   for (auto source : our_pieces_) {
     // King
     if (source == our_king_) {

src/chess/callbacks.h

@@ -69,6 +69,8 @@ struct ThinkingInfo {
   int hashfull = -1;
   // Win in centipawns.
   optional<int> score;
+  // Distance to Mate
+  optional<int> mate;
   // Number of successful TB probes (not the same as playouts ending in TB hit).
   int tb_hits = -1;
   // Best line found. Moves are from perspective of white player.

src/chess/position.h

@@ -82,6 +82,7 @@ class Position {
 };
 
 enum class GameResult { UNDECIDED, WHITE_WON, DRAW, BLACK_WON };
+enum class CertaintyTrigger { NONE, TB_HIT, TWO_FOLD, TERMINAL, NORMAL };
 
 class PositionHistory {
  public:

src/chess/uciloop.cc

@@ -247,7 +247,13 @@ void UciLoop::SendInfo(const std::vector<ThinkingInfo>& infos) {
     if (info.seldepth >= 0) res += " seldepth " + std::to_string(info.seldepth);
     if (info.time >= 0) res += " time " + std::to_string(info.time);
     if (info.nodes >= 0) res += " nodes " + std::to_string(info.nodes);
-    if (info.score) res += " score cp " + std::to_string(*info.score);
+
+    // If mate display mate, otherwise if score display score.
+    if (info.mate) {
+      res += " score mate " + std::to_string(*info.mate);
+    } else if (info.score) {
+      res += " score cp " + std::to_string(*info.score);
+    }
     if (info.hashfull >= 0) res += " hashfull " + std::to_string(info.hashfull);
     if (info.nps >= 0) res += " nps " + std::to_string(info.nps);
     if (info.tb_hits >= 0) res += " tbhits " + std::to_string(info.tb_hits);

src/chess/uciloop.h

@@ -82,6 +82,7 @@ class UciLoop {
   virtual void CmdStop() { throw Exception("Not supported"); }
   virtual void CmdPonderHit() { throw Exception("Not supported"); }
   virtual void CmdStart() { throw Exception("Not supported"); }
+  virtual void CmdStats() { throw Exception("Not supported"); }
 
  private:
   bool DispatchCommand(

src/engine.cc

@@ -36,7 +36,7 @@
 
 namespace lczero {
 namespace {
-const int kDefaultThreads = 2;
+const int kDefaultThreads = 4;
 
 const OptionId kThreadsOptionId{"threads", "Threads",
                                 "Number of (CPU) worker threads to use.", 't'};
@@ -98,7 +98,6 @@ const size_t kAvgNodeSize = sizeof(Node) + kAvgMovesPerPosition * sizeof(Edge);
 const size_t kAvgCacheItemSize =
     NNCache::GetItemStructSize() + sizeof(CachedNNRequest) +
     sizeof(CachedNNRequest::IdxAndProb) * kAvgMovesPerPosition;
-
 float ComputeMoveWeight(int ply, float peak, float left_width,
                         float right_width) {
   // Inflection points of the function are at ply = peak +/- width.
@@ -154,6 +153,8 @@ void EngineController::PopulateOptions(OptionsParser* options) {
   defaults->Set<int>(SearchParams::kMaxCollisionEventsId.GetId(), 32);
   defaults->Set<int>(SearchParams::kCacheHistoryLengthId.GetId(), 0);
   defaults->Set<bool>(SearchParams::kOutOfOrderEvalId.GetId(), true);
+  defaults->Set<int>(SearchParams::kCertaintyPropagationId.GetId(), 2);
+  defaults->Set<int>(SearchParams::kCertaintyPropagationDepthId.GetId(), 1);
 }
 
 SearchLimits EngineController::PopulateSearchLimits(
@@ -356,6 +357,7 @@ void EngineController::Go(const GoParams& params) {
           if (info.multipv <= 1) {
             ponder_info = info;
             if (ponder_info.score) ponder_info.score = -*ponder_info.score;
+            if (ponder_info.mate) ponder_info.mate = -*ponder_info.mate;
             if (ponder_info.depth > 1) ponder_info.depth--;
             if (ponder_info.seldepth > 1) ponder_info.seldepth--;
             ponder_info.pv.clear();
@@ -465,4 +467,6 @@ void EngineLoop::CmdPonderHit() { engine_.PonderHit(); }
 
 void EngineLoop::CmdStop() { engine_.Stop(); }
 
+
+
 }  // namespace lczero

src/engine.h

@@ -77,7 +77,8 @@ class EngineController {
   void PonderHit();
   // Must not block.
   void Stop();
-
+  // Prints verbose move stats of current root
+
   SearchLimits PopulateSearchLimits(int ply, bool is_black,
       const GoParams& params,
       std::chrono::steady_clock::time_point start_time);

src/mcts/node.cc

@@ -28,9 +28,11 @@
 #include "mcts/node.h"
 
 #include <algorithm>
+#include <bitset>
 #include <cassert>
 #include <cmath>
 #include <cstring>
+#include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <thread>
@@ -160,9 +162,58 @@ float Edge::GetP() const {
   return ret;
 }
 
+void Edge::MakeTerminal(GameResult result) {
+  certainty_state_ |= kTerminalMask | kCertainMask | kUpperBound | kLowerBound;
+  certainty_state_ &= kGameResultClear;
+  if (result == GameResult::WHITE_WON) {
+    certainty_state_ |= kGameResultWin;
+  } else if (result == GameResult::BLACK_WON) {
+    certainty_state_ |= kGameResultLoss;
+  }
+}
+
+void Edge::MakeCertain(GameResult result, CertaintyTrigger trigger) {
+  certainty_state_ |= kCertainMask | kUpperBound | kLowerBound;
+  certainty_state_ &= kGameResultClear;
+  if (result == GameResult::WHITE_WON) {
+    certainty_state_ |= kGameResultWin;
+  } else if (result == GameResult::BLACK_WON) {
+    certainty_state_ |= kGameResultLoss;
+  }
+  if (trigger == CertaintyTrigger::TB_HIT) certainty_state_ |= kTBHit;
+  if (trigger == CertaintyTrigger::TWO_FOLD) certainty_state_ |= kTwoFold;
+}
+
+void Edge::MakeCertain(int q, CertaintyTrigger trigger) {
+  certainty_state_ |= kCertainMask | kUpperBound | kLowerBound;
+  certainty_state_ &= kGameResultClear;
+  if (q == 1) {
+    certainty_state_ |= kGameResultWin;
+  } else if (q == -1) {
+    certainty_state_ |= kGameResultLoss;
+  }
+  if (trigger == CertaintyTrigger::TB_HIT) certainty_state_ |= kTBHit;
+  if (trigger == CertaintyTrigger::TWO_FOLD) certainty_state_ |= kTwoFold;
+}
+void Edge::SetEQ(int eq) {
+  certainty_state_ &= kGameResultClear;
+  if (eq == 1) {
+    certainty_state_ |= kGameResultWin;
+  } else if (eq == -1) {
+    certainty_state_ |= kGameResultLoss;
+  }
+}
+
+int Edge::GetEQ() const {
+  if (certainty_state_ & kGameResultLoss) return -1;
+  if (certainty_state_ & kGameResultWin) return 1;
+  return 0;
+}
+
 std::string Edge::DebugString() const {
   std::ostringstream oss;
-  oss << "Move: " << move_.as_string() << " p_: " << p_ << " GetP: " << GetP();
+  oss << "Move: " << move_.as_string() << " p_: " << p_ << " GetP: " << GetP()
+      << " Certainty:" << std::bitset<8>(certainty_state_);
   return oss.str();
 }
 
@@ -197,36 +248,50 @@ void Node::CreateEdges(const MoveList& moves) {
 Node::ConstIterator Node::Edges() const { return {edges_, &child_}; }
 Node::Iterator Node::Edges() { return {edges_, &child_}; }
 
+// Recalculate n_ from real children visits.
+// This is needed if a node was proved to be certain in a prior
+// search and later gets to be root of search.
+void Node::RecomputeNfromChildren() {
+  if (n_ > 1) {
+    uint32_t visits = 1;
+    for (const auto& child : Edges()) visits += child.GetN();
+    n_ = visits;
+  }
+  assert(n_in_flight_ == 0);
+}
+
 float Node::GetVisitedPolicy() const { return visited_policy_; }
 
+float Node::GetQ() const {
+  if (parent_) {
+    auto edge = parent_->GetEdgeToNode(this);
+    if (edge->IsCertain()) return (float)edge->GetEQ();
+  }
+  return q_;
+}
+
 Edge* Node::GetEdgeToNode(const Node* node) const {
   assert(node->parent_ == this);
   assert(node->index_ < edges_.size());
   return &edges_[node->index_];
 }
 
-Edge* Node::GetOwnEdge() const { return GetParent()->GetEdgeToNode(this); }
+Edge* Node::GetOwnEdge() const {
+  if (GetParent()) {
+    return GetParent()->GetEdgeToNode(this);
+  } else
+    return nullptr;
+}
 
 std::string Node::DebugString() const {
   std::ostringstream oss;
-  oss << " Term:" << is_terminal_ << " This:" << this << " Parent:" << parent_
-      << " Index:" << index_ << " Child:" << child_.get()
-      << " Sibling:" << sibling_.get() << " Q:" << q_ << " N:" << n_
-      << " N_:" << n_in_flight_ << " Edges:" << edges_.size();
+  oss << " This:" << this << " Parent:" << parent_ << " Index:" << index_
+      << " Child:" << child_.get() << " Sibling:" << sibling_.get()
+      << " Q:" << q_ << " N:" << n_ << " N_:" << n_in_flight_
+      << " Edges:" << edges_.size();
   return oss.str();
 }
 
-void Node::MakeTerminal(GameResult result) {
-  is_terminal_ = true;
-  if (result == GameResult::DRAW) {
-    q_ = 0.0f;
-  } else if (result == GameResult::WHITE_WON) {
-    q_ = 1.0f;
-  } else if (result == GameResult::BLACK_WON) {
-    q_ = -1.0f;
-  }
-}
-
 bool Node::TryStartScoreUpdate() {
   if (n_ == 0 && n_in_flight_ > 0) return false;
   ++n_in_flight_;
@@ -358,6 +423,8 @@ void NodeTree::MakeMove(Move move) {
   current_head_->ReleaseChildrenExceptOne(new_head);
   current_head_ =
       new_head ? new_head : current_head_->CreateSingleChildNode(move);
+  if (current_head_->GetParent()) current_head_->GetOwnEdge()->ClearCertaintyState();
+  current_head_->RecomputeNfromChildren();
   history_.Append(move);
 }
 
@@ -402,8 +469,13 @@ bool NodeTree::ResetToPosition(const std::string& starting_fen,
   // previously trimmed; we need to reset current_head_ in that case.
   // Also, if the current_head_ is terminal, reset that as well to allow forced
   // analysis of WDL hits, or possibly 3 fold or 50 move "draws", etc.
-  if (!seen_old_head || current_head_->IsTerminal()) TrimTreeAtHead();
+  if (!seen_old_head) TrimTreeAtHead();  // must check if edges are created
 
+  // Certainty Propagation: No need to trim the head, just resetting certainty
+  // state and recomputing N should suffice even with WDL hits.
+  // TODO: Works, but maybe recheck if there are crititcal edge cases.
+  if (current_head_->GetParent()) current_head_->GetOwnEdge()->ClearCertaintyState();
+  current_head_->RecomputeNfromChildren();
   return seen_old_head;
 }