0.2.0 release (#21)

* 0.2.0 release

* Run clang-format.

Author: romerojosh

docs/installation.rst

@@ -7,20 +7,20 @@ TorchFort can be installed in multiple ways but we highly recommend building and
 Docker Installation
 -------------------
 
-We provide a ``Dockerfile`` which contains all relevant dependencies and builds using the `NVIDIA HPC SDK <https://developer.nvidia.com/hpc-sdk>`_ software libraries and compilers, which is our recommended way to build TorchFort. In order to build TorchFort using Docker, simply clone the repo and call:
+We provide a `Dockerfile <https://github.com/NVIDIA/TorchFort/blob/master/docker/Dockerfile>`_ which contains all relevant dependencies and builds using the `NVIDIA HPC SDK <https://developer.nvidia.com/hpc-sdk>`_ software libraries and compilers, which is our recommended way to build TorchFort. In order to build TorchFort using Docker, simply clone the repo and call:
 
 .. code-block:: bash
 
     docker build -t torchfort:latest -f docker/Dockerfile .
 
 from the top level directory of the repo. Inside the container, TorchFort will be installed in ``/opt/torchfort``.
 
-We provide an alternative docker file ``Dockerfile_gnu`` which can be used to build TorchFort using GNU compilers.
+We provide an alternative docker file `Dockerfile_gnu <https://github.com/NVIDIA/TorchFort/blob/master/docker/Dockerfile_gnu>`_ which can be used to build TorchFort using GNU compilers. Additionally, we provide a docker file `Dockerfile_gnu_cpuonly <https://github.com/NVIDIA/TorchFort/blob/master/docker/Dockerfile_gnu_cpuonly>`_ which can be used to build TorchFort using GNU compilers without GPU support enabled.
 
 CMake Installation
 ------------------
 
-For a native installation TorchFort provides a ``CMakeList.txt`` file. Please make sure that the following required packages are installed on your system before installing TorchFort:
+For a native installation TorchFort provides a `CMakeList.txt <https://github.com/NVIDIA/TorchFort/blob/master/CMakeLists.txt>`_ file. Please make sure that the following required packages are installed on your system before installing TorchFort:
 
 * Requirements for core functionality and examples:
 
@@ -31,14 +31,16 @@ For a native installation TorchFort provides a ``CMakeList.txt`` file. Please ma
   - MPI
   - NVIDIA Collective Communication Library (``NCCL``)
   - ``HDF5``
-  - the Python modules specified in ``requirements.txt``
+  - the Python modules specified in `requirements.txt <https://github.com/NVIDIA/TorchFort/blob/master/requirements.txt>`_
   - GNU or `NVHPC <https://developer.nvidia.com/hpc-sdk>`_ compilers. NVHPC compilers are **required** if CUDA Fortran device array support is desired.
 
-
 * Additional requirements for building this documentation:
 
   - Doxygen
-  - the Python modules specified in ``docs/requirements.txt``
+  - the Python modules specified in `docs/requirements.txt <https://github.com/NVIDIA/TorchFort/blob/master/docs/requirements.txt>`_
+
+For CPU-only builds, CUDA and NCCL are not required.
+
 
 To build TorchFort, clone the repo then call the following from the root directory:
 
@@ -52,7 +54,7 @@ To build TorchFort, clone the repo then call the following from the root directo
         ..
     make -j install
 
-See the top level ``CMakeLists.txt`` file for additional CMake configuration options.
+See the top level `CMakeList.txt <https://github.com/NVIDIA/TorchFort/blob/master/CMakeLists.txt>`_ file for additional CMake configuration options.
 
 Build Documentation
 -------------------

examples/cpp/cart_pole/train.cpp

@@ -50,7 +50,6 @@
     }                                                                                                                  \
   } while (false)
 
-
 int main(int argc, char* argv[]) {
 
   // load config file
@@ -94,11 +93,10 @@ int main(int argc, char* argv[]) {
 
   // instantiate torchfort
 #if ENABLE_GPU
-  CHECK_TORCHFORT(torchfort_rl_off_policy_create_system("td3_system", "config.yaml",
-							0, TORCHFORT_DEVICE_CPU));
+  CHECK_TORCHFORT(torchfort_rl_off_policy_create_system("td3_system", "config.yaml", 0, TORCHFORT_DEVICE_CPU));
 #else
-  CHECK_TORCHFORT(torchfort_rl_off_policy_create_system("td3_system", "config.yaml",
-                                                        TORCHFORT_DEVICE_CPU, TORCHFORT_DEVICE_CPU));
+  CHECK_TORCHFORT(
+      torchfort_rl_off_policy_create_system("td3_system", "config.yaml", TORCHFORT_DEVICE_CPU, TORCHFORT_DEVICE_CPU));
 #endif
 
   // define variables
@@ -167,7 +165,7 @@ int main(int argc, char* argv[]) {
                                                                 daction, 2, action_shape_batch.data(), TORCHFORT_FLOAT,
                                                                 0));
 
-      // copy data to host
+        // copy data to host
 #ifdef ENABLE_GPU
       cudaMemcpy(action.data(), daction, action.size() * sizeof(float), cudaMemcpyDeviceToHost);
 #else

src/csrc/distributed.cpp

@@ -103,9 +103,12 @@ void Comm::initialize(bool initialize_nccl) {
 
 void Comm::finalize() {
 #ifdef ENABLE_GPU
-  if (nccl_comm) CHECK_NCCL(ncclCommDestroy(nccl_comm));
-  if (stream) CHECK_CUDA(cudaStreamDestroy(stream));
-  if (event) CHECK_CUDA(cudaEventDestroy(event));
+  if (nccl_comm)
+    CHECK_NCCL(ncclCommDestroy(nccl_comm));
+  if (stream)
+    CHECK_CUDA(cudaStreamDestroy(stream));
+  if (event)
+    CHECK_CUDA(cudaEventDestroy(event));
 #endif
 }
 
@@ -124,8 +127,8 @@ void Comm::allreduce(torch::Tensor& tensor, bool average) const {
     } else {
       nccl_dtype = get_nccl_dtype(tensor);
     }
-    CHECK_NCCL(ncclAllReduce(tensor.data_ptr(), tensor.data_ptr(), count, nccl_dtype,
-                             (average) ? ncclAvg : ncclSum, nccl_comm, stream));
+    CHECK_NCCL(ncclAllReduce(tensor.data_ptr(), tensor.data_ptr(), count, nccl_dtype, (average) ? ncclAvg : ncclSum,
+                             nccl_comm, stream));
 
     CHECK_CUDA(cudaEventRecord(event, stream));
     CHECK_CUDA(cudaStreamWaitEvent(torch_stream, event));
@@ -139,8 +142,7 @@ void Comm::allreduce(torch::Tensor& tensor, bool average) const {
     } else {
       mpi_dtype = get_mpi_dtype(tensor);
     }
-    CHECK_MPI(MPI_Allreduce(MPI_IN_PLACE, tensor.data_ptr(), count, mpi_dtype,
-                            MPI_SUM, mpi_comm));
+    CHECK_MPI(MPI_Allreduce(MPI_IN_PLACE, tensor.data_ptr(), count, mpi_dtype, MPI_SUM, mpi_comm));
 
     if (average) {
       tensor /= size;
@@ -205,8 +207,7 @@ void Comm::broadcast(torch::Tensor& tensor, int root) const {
     CHECK_CUDA(cudaEventRecord(event, torch_stream));
     CHECK_CUDA(cudaStreamWaitEvent(stream, event));
 
-    CHECK_NCCL(
-        ncclBroadcast(tensor.data_ptr(), tensor.data_ptr(), count, nccl_dtype, root, nccl_comm, stream));
+    CHECK_NCCL(ncclBroadcast(tensor.data_ptr(), tensor.data_ptr(), count, nccl_dtype, root, nccl_comm, stream));
 
     CHECK_CUDA(cudaEventRecord(event, stream));
     CHECK_CUDA(cudaStreamWaitEvent(torch_stream, event));

src/csrc/include/internal/distributed.h

@@ -59,7 +59,7 @@ struct Comm {
 #endif
   bool initialized = false;
 
-  Comm(MPI_Comm mpi_comm) : mpi_comm(mpi_comm) {};
+  Comm(MPI_Comm mpi_comm) : mpi_comm(mpi_comm){};
 };
 
 } // namespace torchfort

src/csrc/include/internal/lr_schedulers.h

@@ -85,7 +85,8 @@ class StepLR : public BaseLRScheduler {
 
 class LinearLR : public BaseLRScheduler {
 public:
-  LinearLR(torch::optim::Optimizer& optimizer, const unsigned total_iters, const double start_factor=0.333, const double end_factor = 1.0);
+  LinearLR(torch::optim::Optimizer& optimizer, const unsigned total_iters, const double start_factor = 0.333,
+           const double end_factor = 1.0);
 
 private:
   std::vector<double> get_lrs() override;

src/csrc/include/internal/models.h

@@ -53,7 +53,6 @@ struct MLPModel : BaseModel, public std::enable_shared_from_this<BaseModel> {
   std::vector<torch::Tensor> biases;
 };
 
-
 struct SACMLPModel : BaseModel, public std::enable_shared_from_this<BaseModel> {
   void setup(const ParamMap& params) override;
   std::vector<torch::Tensor> forward(const std::vector<torch::Tensor>& inputs) override;
@@ -67,10 +66,8 @@ struct SACMLPModel : BaseModel, public std::enable_shared_from_this<BaseModel> {
   std::vector<torch::nn::Linear> out_layers;
   std::vector<torch::Tensor> biases;
   std::vector<torch::Tensor> out_biases;
-
 };
 
-
 struct ActorCriticMLPModel : BaseModel, public std::enable_shared_from_this<BaseModel> {
   void setup(const ParamMap& params) override;
   std::vector<torch::Tensor> forward(const std::vector<torch::Tensor>& inputs) override;

src/csrc/include/internal/rl/off_policy.h

@@ -114,14 +114,14 @@ static void update_replay_buffer(const char* name, T* state_old, T* state_new, s
   auto action_old_tensor = get_tensor<L>(action_old, action_dim, action_shape)
                                .to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
 
-  registry[name]->updateReplayBuffer(state_old_tensor, action_old_tensor, state_new_tensor,
-				     static_cast<float>(reward), final_state);
+  registry[name]->updateReplayBuffer(state_old_tensor, action_old_tensor, state_new_tensor, static_cast<float>(reward),
+                                     final_state);
   return;
 }
 
 template <MemoryLayout L, typename T>
 static void predict_explore(const char* name, T* state, size_t state_dim, int64_t* state_shape, T* action,
-			    size_t action_dim, int64_t* action_shape, cudaStream_t ext_stream) {
+                            size_t action_dim, int64_t* action_shape, cudaStream_t ext_stream) {
 
 #ifdef ENABLE_GPU
   // device and stream handling
@@ -134,8 +134,8 @@ static void predict_explore(const char* name, T* state, size_t state_dim, int64_
 #endif
 
   // create tensors
-  auto state_tensor = get_tensor<L>(state, state_dim, state_shape)
-                          .to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
+  auto state_tensor =
+      get_tensor<L>(state, state_dim, state_shape).to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
   auto action_tensor = get_tensor<L>(action, action_dim, action_shape);
 
   // fwd pass
@@ -147,7 +147,7 @@ static void predict_explore(const char* name, T* state, size_t state_dim, int64_
 
 template <MemoryLayout L, typename T>
 static void predict(const char* name, T* state, size_t state_dim, int64_t* state_shape, T* action, size_t action_dim,
-		    int64_t* action_shape, cudaStream_t ext_stream) {
+                    int64_t* action_shape, cudaStream_t ext_stream) {
 
 #ifdef ENABLE_GPU
   // device and stream handling
@@ -158,10 +158,10 @@ static void predict(const char* name, T* state, size_t state_dim, int64_t* state
     guard.reset_stream(stream);
   }
 #endif
-  
+
   // create tensors
-  auto state_tensor = get_tensor<L>(state, state_dim, state_shape)
-                          .to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
+  auto state_tensor =
+      get_tensor<L>(state, state_dim, state_shape).to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
   auto action_tensor = get_tensor<L>(action, action_dim, action_shape);
 
   // fwd pass
@@ -172,9 +172,9 @@ static void predict(const char* name, T* state, size_t state_dim, int64_t* state
 }
 
 template <MemoryLayout L, typename T>
-static void policy_evaluate(const char* name, T* state, size_t state_dim, int64_t* state_shape, T* action, size_t action_dim,
-			    int64_t* action_shape, T* reward, size_t reward_dim, int64_t* reward_shape,
-			    cudaStream_t ext_stream) {
+static void policy_evaluate(const char* name, T* state, size_t state_dim, int64_t* state_shape, T* action,
+                            size_t action_dim, int64_t* action_shape, T* reward, size_t reward_dim,
+                            int64_t* reward_shape, cudaStream_t ext_stream) {
 
 #ifdef ENABLE_GPU
   // device and stream handling
@@ -187,8 +187,8 @@ static void policy_evaluate(const char* name, T* state, size_t state_dim, int64_
 #endif
 
   // create tensors
-  auto state_tensor = get_tensor<L>(state, state_dim, state_shape)
-                          .to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
+  auto state_tensor =
+      get_tensor<L>(state, state_dim, state_shape).to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
   auto action_tensor = get_tensor<L>(action, action_dim, action_shape)
                            .to(torch::kFloat32, /* non_blocking = */ false, /* copy = */ true);
   auto reward_tensor = get_tensor<L>(reward, reward_dim, reward_shape);
@@ -208,6 +208,6 @@ template <typename T> void wandb_log_system(const char* name, const char* metric
 }
 
 } // namespace off_policy
-  
+
 } // namespace rl
 } // namespace torchfort

src/csrc/include/internal/rl/off_policy/ddpg.h

@@ -43,16 +43,16 @@
 
 // rl stuff
 #include "internal/rl/noise_actor.h"
-#include "internal/rl/replay_buffer.h"
 #include "internal/rl/off_policy.h"
+#include "internal/rl/replay_buffer.h"
 #include "internal/rl/utils.h"
 
 namespace torchfort {
 
 namespace rl {
 
 namespace off_policy {
-    
+
 // implementing https://spinningup.openai.com/en/latest/algorithms/ddpg.html#pseudocode
 // we implement the update on a single batch with (s, a, r, s', d):
 // gamma is a tensor here to support multi-step delayed learning. Here, gamma^n
@@ -100,7 +100,8 @@ void train_ddpg(const ModelPack& p_model, const ModelPack& p_model_target, const
 
   // backward and update step
   // compute loss
-  torch::Tensor q_old_tensor = q_model.model->forward(std::vector<torch::Tensor>{state_old_tensor, action_old_tensor})[0];
+  torch::Tensor q_old_tensor =
+      q_model.model->forward(std::vector<torch::Tensor>{state_old_tensor, action_old_tensor})[0];
   torch::Tensor q_loss_tensor = q_loss_func->forward(q_old_tensor, y_tensor);
   q_model.optimizer->zero_grad();
   q_loss_tensor.backward();
@@ -277,7 +278,7 @@ class DDPGSystem : public RLOffPolicySystem, public std::enable_shared_from_this
 };
 
 } // namespace off_policy
-  
+
 } // namespace rl
 
 } // namespace torchfort