Implement training observer.

CMakeLists.txt

@@ -30,6 +30,8 @@ option(USE_OPENMP "Build with OpenMP support." ON)
 option(JVM_BINDINGS "Build JVM bindings" OFF)
 option(R_LIB "Build shared library for R package" OFF)
 ## Dev
+option(USE_DEBUG_OUTPUT "Dump internal training results like gradients and predictions to stdout.
+Should only be used for debugging." OFF)
 option(GOOGLE_TEST "Build google tests" OFF)
 option(USE_DMLC_GTEST "Use google tests bundled with dmlc-core submodule" OFF)
 option(USE_NVTX "Build with cuda profiling annotations. Developers only." OFF)
@@ -39,17 +41,12 @@ option(RABIT_MOCK "Build rabit with mock" OFF)
 option(USE_CUDA  "Build with GPU acceleration" OFF)
 option(USE_NCCL  "Build with NCCL to enable distributed GPU support." OFF)
 option(BUILD_WITH_SHARED_NCCL "Build with shared NCCL library." OFF)
-
+set(GPU_COMPUTE_VER "" CACHE STRING
+  "Semicolon separated list of compute versions to be built against, e.g. '35;61'")
 ## Copied From dmlc
 option(USE_HDFS "Build with HDFS support" OFF)
 option(USE_AZURE "Build with AZURE support" OFF)
 option(USE_S3 "Build with S3 support" OFF)
-
-set(GPU_COMPUTE_VER "" CACHE STRING
-  "Semicolon separated list of compute versions to be built against, e.g. '35;61'")
-if (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
-  message(SEND_ERROR "Build XGBoost with -DUSE_NCCL=ON to enable BUILD_WITH_SHARED_NCCL.")
-endif (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
 ## Sanitizers
 option(USE_SANITIZER "Use santizer flags" OFF)
 option(SANITIZER_PATH "Path to sanitizes.")
@@ -60,12 +57,28 @@ address, leak and thread.")
 option(PLUGIN_LZ4 "Build lz4 plugin" OFF)
 option(PLUGIN_DENSE_PARSER "Build dense parser plugin" OFF)
 
-## Deprecation warning
+#-- Checks for building XGBoost
+if (USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
+  message(SEND_ERROR "Do not enable `USE_DEBUG_OUTPUT' with release build.")
+endif (USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
+if (USE_NCCL AND NOT (USE_CUDA))
+  message(SEND_ERROR "`USE_NCCL` must be enabled with `USE_CUDA` flag.")
+endif (USE_NCCL AND NOT (USE_CUDA))
+if (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
+  message(SEND_ERROR "Build XGBoost with -DUSE_NCCL=ON to enable BUILD_WITH_SHARED_NCCL.")
+endif (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
+if (JVM_BINDINGS AND R_LIB)
+  message(SEND_ERROR "`R_LIB' is not compatible with `JVM_BINDINGS' as they both have customized configurations.")
+endif (JVM_BINDINGS AND R_LIB)
+if (R_LIB AND GOOGLE_TEST)
+  message(WARNING "Some C++ unittests will fail with `R_LIB` enabled,
+ as R package redirects some functions to R runtime implementation.")
+endif (R_LIB AND GOOGLE_TEST)
 if (USE_AVX)
-  message(WARNING "The option 'USE_AVX' is deprecated as experimental AVX features have been removed from xgboost.")
+  message(SEND_ERROR  "The option 'USE_AVX' is deprecated as experimental AVX features have been removed from XGBoost.")
 endif (USE_AVX)
 
-# Sanitizer
+#-- Sanitizer
 if (USE_SANITIZER)
   # Older CMake versions have had troubles with Sanitizer
   cmake_minimum_required(VERSION 3.12)

src/CMakeLists.txt

@@ -63,6 +63,9 @@ target_compile_definitions(objxgboost
   -DDMLC_LOG_CUSTOMIZE=1  # enable custom logging
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:_MWAITXINTRIN_H_INCLUDED>
   ${XGBOOST_DEFINITIONS})
+if (USE_DEBUG_OUTPUT)
+  target_compile_definitions(objxgboost PRIVATE -DXGBOOST_USE_DEBUG_OUTPUT=1)
+endif (USE_DEBUG_OUTPUT)
 
 if (XGBOOST_MM_PREFETCH_PRESENT)
   target_compile_definitions(objxgboost

src/common/observer.h

@@ -0,0 +1,101 @@
+/*!
+ * Copyright 2019 XGBoost contributors
+ * \file observer.h
+ */
+#ifndef XGBOOST_COMMON_OBSERVER_H_
+#define XGBOOST_COMMON_OBSERVER_H_
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "xgboost/host_device_vector.h"
+#include "xgboost/parameter.h"
+#include "xgboost/json.h"
+#include "xgboost/base.h"
+#include "xgboost/tree_model.h"
+
+namespace xgboost {
+/*\brief  An observer for logging internal data structures.
+ *
+ *  This class is designed to be `diff` tool friendly, which means it uses plain
+ *  `std::cout` for printing to avoid the time information emitted by `LOG(DEBUG)` or
+ *  similiar facilities.
+ */
+class TrainingObserver {
+#if defined(XGBOOST_USE_DEBUG_OUTPUT)
+  bool constexpr static observe_ {true};
+#else
+  bool constexpr static observe_ {false};
+#endif  // defined(XGBOOST_USE_DEBUG_OUTPUT)
+
+ public:
+  void Update(int32_t iter) const {
+    if (XGBOOST_EXPECT(!observe_, true)) { return; }
+    std::cout << "Iter: " << iter << std::endl;
+  }
+  /*\brief Observe tree. */
+  void Observe(RegTree const& tree) {
+    if (XGBOOST_EXPECT(!observe_, true)) { return; }
+    std::cout << "Tree:" << std::endl;
+    Json j_tree {Object()};
+    tree.SaveModel(&j_tree);
+    std::string str;
+    Json::Dump(j_tree, &str, true);
+    std::cout << str << std::endl;
+  }
+  /*\brief Observe tree. */
+  void Observe(RegTree const* p_tree) {
+    if (XGBOOST_EXPECT(!observe_, true)) { return; }
+    auto const& tree = *p_tree;
+    this->Observe(tree);
+  }
+  /*\brief Observe data hosted by `std::vector'. */
+  template <typename T>
+  void Observe(std::vector<T> const& h_vec, std::string name) const {
+    if (XGBOOST_EXPECT(!observe_, true)) { return; }
+    std::cout << "Procedure: " << name << std::endl;
+
+    for (size_t i = 0; i < h_vec.size(); ++i) {
+      std::cout << h_vec[i] << ", ";
+      if (i % 8 == 0) {
+        std::cout << '\n';
+      }
+    }
+    std::cout << std::endl;
+  }
+  /*\brief Observe data hosted by `HostDeviceVector'. */
+  template <typename T>
+  void Observe(HostDeviceVector<T> const& vec, std::string name) const {
+    if (XGBOOST_EXPECT(!observe_, true)) { return; }
+    auto const& h_vec = vec.HostVector();
+    this->Observe(h_vec, name);
+  }
+  /*\brief Observe objects with `XGBoostParamer' type. */
+  template <typename Parameter,
+            typename std::enable_if<
+              std::is_base_of<XGBoostParameter<Parameter>, Parameter>::value>::type* = nullptr>
+  void Observe(const Parameter &p, std::string name) const {
+    if (XGBOOST_EXPECT(!observe_, true)) { return; }
+
+    Json obj {toJson(p)};
+    std::cout << "Parameter: " << name << ":\n" << obj << std::endl;
+  }
+  /*\brief Observe parameters provided by users. */
+  void Observe(Args const& args) const {
+    if (XGBOOST_EXPECT(!observe_, true)) { return; }
+
+    for (auto kv : args) {
+      std::cout << kv.first << ": " << kv.second << "\n";
+    }
+    std::cout << std::endl;
+  }
+
+  /*\brief Get a global instance. */
+  static TrainingObserver& Instance() {
+    static TrainingObserver observer;
+    return observer;
+  }
+};
+}  // namespace xgboost
+#endif  // XGBOOST_COMMON_OBSERVER_H_