fbshipit-source-id: a0c34d05c8b4d5e6de3d81a17c77718961e6313b

Author: vineelpratap

CMakeLists.txt

@@ -73,24 +73,6 @@ elseif (FLASHLIGHT_USE_UNIFIED AND NOT ArrayFire_Unified_FOUND)
   message(FATAL_ERROR "ArrayFire Unified not found: cannot build unified backend")
 endif()
 
-# TODO(@jacobkahn): remove these when glog is purged
-# Find GLog
-find_package(GLOG REQUIRED)
-if (GLOG_FOUND)
-  message(STATUS "GLOG found")
-else()
-  message(FATAL_ERROR "GLOG not found")
-endif()
-
-# TODO(@jacobkahn): remove these when glog is purged
-# Find GFlags
-find_package(GFLAGS REQUIRED)
-if (GFLAGS_FOUND)
-  message(STATUS "GFLAGS found")
-else()
-  message(FATAL_ERROR "GFLAGS not found")
-endif()
-
 # Find cereal
 find_package(cereal REQUIRED)
 if (cereal_FOUND)
@@ -169,26 +151,20 @@ set(
   Distributed
   Meter
   NN
-  Optim  
+  Optim
   )
 
 target_link_libraries(
   flashlight
   PUBLIC # export dependency library and include paths for each module
   ${FLASHLIGHT_MODULES}
-  # TODO(@jacobkahn) remove this once glog is purged
-  ${GLOG_LIBRARIES}
-  ${GFLAGS_LIBRARIES}
   )
 
 # Internal includes are impl defined as <flashlight...>
 target_include_directories(
   flashlight
   PRIVATE
   ${CMAKE_SOURCE_DIR}
-  # TODO(@jacobkahn) remove these once glog is purged
-  ${GLOG_INCLUDE_DIRS}
-  ${GFLAGS_INCLUDE_DIRS}
 )
 
 # Link appropriate ArrayFire backend, set global compile time macros
@@ -275,11 +251,11 @@ install(
   flashlightTargets
   NAMESPACE
   flashlight::
-  DESTINATION 
+  DESTINATION
   ${FL_INSTALL_CMAKE_DIR}
   COMPONENT
   cmake)
-     
+
 # Move headers
 install(
   DIRECTORY
@@ -312,7 +288,7 @@ configure_package_config_file(
   PATH_VARS INCLUDE_DIRS CMAKE_DIR
   )
 install(FILES
-  ${PROJECT_BINARY_DIR}/cmake/install/flashlightConfig.cmake 
+  ${PROJECT_BINARY_DIR}/cmake/install/flashlightConfig.cmake
   DESTINATION ${FL_INSTALL_CMAKE_DIR}
   COMPONENT cmake
   )

Dockerfile-CUDA

@@ -4,7 +4,6 @@
 # Ubuntu           16.04
 # CUDA             9.2
 # CuDNN            7-dev
-# glog             lastest  (apt)
 # boost            latest   (apt)
 # arrayfire        3.6.1    (git, CUDA backend)
 # googletest       master   (git)
@@ -35,24 +34,21 @@ RUN APT_INSTALL="apt-get install -y --no-install-recommends" && \
         g++ \
         # for Cereal
         libboost-all-dev \
-        # glogs: for flashlight logging
-        libgoogle-glog-dev \
-        # for Cereal 
         gcc-multilib g++-multilib \
         # nccl: for flashlight
         libnccl2 libnccl-dev && \
 # ==================================================================
 # arrayfire https://github.com/arrayfire/arrayfire/wiki/
 # ------------------------------------------------------------------
-    cd /tmp && git clone --recursive https://github.com/arrayfire/arrayfire.git && \    
+    cd /tmp && git clone --recursive https://github.com/arrayfire/arrayfire.git && \
     cd arrayfire && git checkout b443e14 && \
     mkdir build && cd build && \
     cmake .. -DCMAKE_BUILD_TYPE=Release -DAF_BUILD_CPU=OFF -DAF_BUILD_OPENCL=OFF -DAF_BUILD_EXAMPLES=OFF && \
     make -j8 && \
     make install && \
 # ==================================================================
 # GoogleTest https://github.com/google/googletest/
-# ------------------------------------------------------------------   
+# ------------------------------------------------------------------
     cd /tmp && git clone --recursive https://github.com/google/googletest && \
     cd googletest && \
     mkdir build && cd build && \
@@ -84,12 +80,11 @@ RUN APT_INSTALL="apt-get install -y --no-install-recommends" && \
     mkdir -p build && cd build && \
     cmake .. -DCMAKE_BUILD_TYPE=Release -DFLASHLIGHT_BACKEND=CUDA &&  \
     make -j8  && \
-    make install && \ 
+    make install && \
 # ========================================================= =========
 # config & cleanup
 # ------------------------------------------------------------------
     ldconfig && \
     apt-get clean && \
     apt-get autoremove && \
     rm -rf /var/lib/apt/lists/* /tmp/* ~/*
-

LICENSE

@@ -19,7 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-
-
-

cmake/FindGFLAGS.cmake

@@ -23,7 +23,7 @@ Dependencies
 flashlight can be built with either a CUDA, CPU (coming soon), or OpenCL (coming soon) backend. Requirements vary depending on which backend is selected. All dependencies must be built/installed before building flashlight.
 
 - For all backends, `ArrayFire <https://github.com/arrayfire/arrayfire/wiki>`_ >= 3.6.1 is required. flashlight has been tested with `ArrayFire 3.6.1 <https://github.com/arrayfire/arrayfire/releases/tag/v3.6.1>`_.
-- `Cereal <https://github.com/USCiLab/cereal>`_ is required for serialization -- the ``develop`` branch must be used.
+- `Cereal <https://github.com/USCiLab/cereal> `_ is required for serialization -- the `develop` branch must be used.
 - If building tests, `Google Test <https://github.com/google/googletest>`_ >= 1.8.0 is required -- Google Test is downloaded and built when building flashlight with tests.
 
 Distributed Training Dependencies

cmake/FindGLOG.cmake

@@ -22,6 +22,7 @@
 
 #include <iomanip>
 #include <iostream>
+#include <stdexcept>
 
 #include <arrayfire.h>
 #include <flashlight/flashlight.h>

docs/source/installation.rst

@@ -23,6 +23,7 @@
  */
 #include <iomanip>
 #include <iostream>
+#include <stdexcept>
 #include <unordered_map>
 #include <vector>
 
@@ -86,8 +87,12 @@ class RnnLm : public Container {
     add(LogSoftmax());
   }
 
-  Variable forward(const Variable& input) override {
-    return std::get<0>(forward(input, Variable(), Variable()));
+  std::vector<Variable> forward(const std::vector<Variable>& inputs) override {
+    auto inSz = inputs.size();
+    if (inSz < 1 || inSz > 3) {
+      throw std::invalid_argument("Invalid inputs size");
+    }
+    return rnn(inputs);
   }
 
   std::tuple<Variable, Variable, Variable>

examples/Mnist.cpp

@@ -15,10 +15,10 @@
 
 #include <algorithm>
 #include <array>
+#include <stdexcept>
 
 #include <af/internal.h>
 
-#include <flashlight/common/Exception.h>
 #include "Functions.h"
 #include "Variable.h"
 
@@ -426,22 +426,19 @@ Variable sumAs(const Variable& input, const Variable& reference) {
 
 Variable concatenate(const std::vector<Variable>& concatInputs, int dim) {
   if (concatInputs.empty()) {
-    AFML_THROW_ERR(
-        "[Variable concatenate] Need at least one variable.", AF_ERR_ARG);
+    throw std::invalid_argument("cannot concatenate zero variables");
   }
   if (dim < 0 || dim > 3) {
-    AFML_THROW_ERR("[Variable concatenate] Invalid dimension.", AF_ERR_ARG);
+    throw std::invalid_argument("invalid dimension to concatenate along");
   }
   auto dims = concatInputs[0].dims();
   int concat_size = dims[dim];
   for (int i = 1; i < concatInputs.size(); i++) {
     concat_size += concatInputs[i].dims(dim);
     for (int d = 0; d < 4; d++) {
       if (dim != d && concatInputs[i].dims(d) != dims[d]) {
-        AFML_THROW_ERR(
-            "[Variable concatenate] Mismatch in dimension "
-            "not being concatenated.",
-            AF_ERR_ARG);
+        throw std::invalid_argument(
+            "mismatch in dimension not being concatenated");
       }
     }
   }
@@ -531,8 +528,10 @@ Variable var(
   for (auto ax : axes) {
     n *= input.dims(ax);
   }
-  AFML_ASSERT(
-      isbiased || n > 1, "Division by zero when computing var", AF_ERR_SIZE)
+  if (!isbiased && n == 1) {
+    throw std::invalid_argument(
+        "cannot compute unbiased variance with only one sample");
+  }
   auto val = 1.0 / (isbiased ? n : n - 1);
   result = val * (result - n * avg * avg);
   auto gradFunc =
@@ -688,15 +687,13 @@ Variable moddims(const Variable& input, const af::dim4& dims) {
     }
   }
 
-  AFML_ASSERT(
-      n_infer <= 1,
-      "[Variable moddims] Only infer a single dimension",
-      AF_ERR_ARG);
+  if (n_infer > 1) {
+    throw std::invalid_argument("too many dimensions for moddims to infer");
+  }
 
-  AFML_ASSERT(
-      infer_dims.elements() == input.elements(),
-      "[Variable moddims] Number of elements must match.",
-      AF_ERR_ARG);
+  if (infer_dims.elements() != input.elements()) {
+    throw std::invalid_argument("mismatched # of elements in moddims");
+  }
 
   auto result = af::moddims(input.array(), infer_dims);
 
@@ -760,15 +757,13 @@ Variable categoricalCrossEntropy(
   // target -- [X1, X2, X3, 1]
   for (int i = 1; i < 4; i++) {
     if (input.dims(i) != targets.dims(i - 1)) {
-      AFML_THROW_ERR(
-          "[categoricalCrossEntropy] Size mismatch between input and target.",
-          AF_ERR_ARG);
+      throw std::invalid_argument(
+          "dimension mismatch in categorical cross entropy");
     }
   }
   if (targets.dims(3) != 1) {
-    AFML_THROW_ERR(
-        "[categoricalCrossEntropy] Size mismatch between input and target.",
-        AF_ERR_ARG);
+    throw std::invalid_argument(
+        "dimension mismatch in categorical cross entropy");
   }
 
   int categories = input.dims(0);
@@ -789,7 +784,8 @@ Variable categoricalCrossEntropy(
   } else if (reduction == ReduceMode::SUM) {
     result = af::sum(result, 1);
   } else {
-    AFML_THROW_ERR("[nLLLoss] Invalid reduction method.", AF_ERR_ARG);
+    throw std::invalid_argument(
+        "unknown reduction method for categorical cross entropy");
   }
 
   af::dim4 in_dims = input.dims();
@@ -898,7 +894,7 @@ linear(const Variable& input, const Variable& weight, const Variable& bias) {
 Variable gatedlinearunit(const Variable& input, const int dim) {
   auto in_size = input.dims(dim);
   if (in_size % 2 == 1) {
-    AFML_THROW_ERR("Halving dimension needs to be even for GLU.", AF_ERR_ARG);
+    throw std::invalid_argument("halving dimension must be even for GLU");
   }
   std::array<af::seq, 4> fhalf = {af::span, af::span, af::span, af::span};
   fhalf[dim] = af::seq(in_size / 2);
@@ -928,7 +924,7 @@ Variable gatedlinearunit(const Variable& input, const int dim) {
 
 Variable embedding(const Variable& input, const Variable& embeddings) {
   if (input.numdims() >= 4) {
-    AFML_THROW_ERR("[embedding] Input must have 3 or fewer dims.", AF_ERR_ARG);
+    throw std::invalid_argument("embedding input must have 3 or fewer dims");
   }
 
   auto idxs = af::flat(input.array());