Merge pull request #68 from prabhuomkar/blitz

[feature] Popular Tutorials, Deep Learning With PyTorch: A 60 Minute Blitz

Author: prabhuomkar

.gitignore

@@ -69,3 +69,4 @@ cmake-build-*/
 # extern
 extern/*
 !extern/CMakeLists.txt
+.vscode/

CMakeLists.txt

@@ -64,6 +64,12 @@ add_subdirectory("tutorials/advanced/variational_autoencoder")
 add_subdirectory("tutorials/advanced/neural_style_transfer")
 add_subdirectory("tutorials/advanced/image_captioning")
 
+# Popular
+add_subdirectory("tutorials/popular/blitz/tensors")
+add_subdirectory("tutorials/popular/blitz/autograd")
+add_subdirectory("tutorials/popular/blitz/neural_networks")
+add_subdirectory("tutorials/popular/blitz/training_a_classifier")
+
 if(MSVC)
     include(copy_torch_dlls)
     copy_torch_dlls(${EXECUTABLE_NAME})

README.md

@@ -25,6 +25,33 @@
 This repository provides tutorial code in C++ for deep learning researchers to learn PyTorch.  
 **Python Tutorial**: [https://github.com/yunjey/pytorch-tutorial](https://github.com/yunjey/pytorch-tutorial)
 
+## Table of Contents
+
+### 1. Basics
+* [PyTorch Basics](tutorials/basics/pytorch_basics/main.cpp)
+* [Linear Regression](tutorials/basics/linear_regression/main.cpp)
+* [Logistic Regression](tutorials/basics/logistic_regression/main.cpp)
+* [Feedforward Neural Network](tutorials/basics/feedforward_neural_network/src/main.cpp)
+
+### 2. Intermediate
+* [Convolutional Neural Network](tutorials/intermediate/convolutional_neural_network/src/main.cpp)
+* [Deep Residual Network](tutorials/intermediate/deep_residual_network/src/main.cpp)
+* [Recurrent Neural Network](tutorials/intermediate/recurrent_neural_network/src/main.cpp)
+* [Bidirectional Recurrent Neural Network](tutorials/intermediate/bidirectional_recurrent_neural_network/src/main.cpp)
+* [Language Model (RNN-LM)](tutorials/intermediate/language_model/src/main.cpp)
+
+### 3. Advanced
+* [Generative Adversarial Networks](tutorials/advanced/generative_adversarial_network/main.cpp)
+* [Variational Auto-Encoder](tutorials/advanced/variational_autoencoder/src/main.cpp)
+* [Neural Style Transfer](tutorials/advanced/neural_style_transfer/src/main.cpp)
+* [Image Captioning (CNN-AttentionRNN)](tutorials/advanced/image_captioning/src/main.cpp)
+
+### 4. Interactive Tutorials
+* [Tensor Slicing](notebooks/tensor_slicing.ipynb)
+
+### 5. Other Popular Tutorials
+* [Deep Learning with PyTorch: A 60 Minute Blitz](tutorials/popular/blitz)
+
 # Getting Started
 
 ## Requirements
@@ -157,29 +184,5 @@ You can build and run the tutorials (on CPU) in a Docker container using the pro
     ```
     This will - if necessary - build all tutorials and then start the provided tutorial in a container.
 
-## Table of Contents
-
-### 1. Basics
-* [PyTorch Basics](tutorials/basics/pytorch_basics/main.cpp)
-* [Linear Regression](tutorials/basics/linear_regression/main.cpp)
-* [Logistic Regression](tutorials/basics/logistic_regression/main.cpp)
-* [Feedforward Neural Network](tutorials/basics/feedforward_neural_network/src/main.cpp)
-
-### 2. Intermediate
-* [Convolutional Neural Network](tutorials/intermediate/convolutional_neural_network/src/main.cpp)
-* [Deep Residual Network](tutorials/intermediate/deep_residual_network/src/main.cpp)
-* [Recurrent Neural Network](tutorials/intermediate/recurrent_neural_network/src/main.cpp)
-* [Bidirectional Recurrent Neural Network](tutorials/intermediate/bidirectional_recurrent_neural_network/src/main.cpp)
-* [Language Model (RNN-LM)](tutorials/intermediate/language_model/src/main.cpp)
-
-### 3. Advanced
-* [Generative Adversarial Networks](tutorials/advanced/generative_adversarial_network/main.cpp)
-* [Variational Auto-Encoder](tutorials/advanced/variational_autoencoder/src/main.cpp)
-* [Neural Style Transfer](tutorials/advanced/neural_style_transfer/src/main.cpp)
-* [Image Captioning (CNN-AttentionRNN)](tutorials/advanced/image_captioning/src/main.cpp)
-
-### 4. Interactive Tutorials
-* [Tensor Slicing](notebooks/tensor_slicing.ipynb)
-
 ## License
 This repository is licensed under MIT as given in [LICENSE](LICENSE).

tutorials/popular/blitz/README.md

@@ -0,0 +1,10 @@
+# Deep Learning with PyTorch: A 60 Minute Blitz
+
+1. *[tensors](tutorials/popular/blitz/tensors)*: What is PyTorch?  
+	https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html
+
+2. *[autograd](tutorials/popular/blitz/autograd)*: Autograd: Automatic Differentiation  
+	https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html
+
+3. *[neural_networks](tutorials/popular/blitz/neural_networks)*: Neural Networks  
+	https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html

tutorials/popular/blitz/autograd/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
+
+project(autograd VERSION 1.0.0 LANGUAGES CXX)
+
+if(NOT Torch_FOUND)
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../../cmake")
+    find_package(Torch REQUIRED PATHS "${CMAKE_CURRENT_SOURCE_DIR}/../../../../libtorch")
+endif()
+
+set(EXECUTABLE_NAME autograd)
+
+add_executable(${EXECUTABLE_NAME})
+target_sources(${EXECUTABLE_NAME} PRIVATE main.cpp)
+
+target_link_libraries(${EXECUTABLE_NAME} ${TORCH_LIBRARIES})
+
+set_target_properties(${EXECUTABLE_NAME} PROPERTIES
+  CXX_STANDARD 14
+  CXX_STANDARD_REQUIRED YES
+)
+
+if(MSVC)
+    set_target_properties(${EXECUTABLE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_CURRENT_BINARY_DIR})
+    set_target_properties(${EXECUTABLE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_CURRENT_BINARY_DIR})
+    include(copy_torch_dlls)
+    copy_torch_dlls(${EXECUTABLE_NAME})
+endif(MSVC)

tutorials/popular/blitz/autograd/main.cpp

@@ -0,0 +1,69 @@
+// Copyright 2020-present pytorch-cpp Authors
+#include <torch/torch.h>
+#include <iostream>
+#include <iomanip>
+
+int main() {
+    std::cout << "Deep Learning with PyTorch: A 60 Minute Blitz\n\n";
+    std::cout << "Autograd: Automatic Differentiation\n\n";
+
+    std::cout << "Tensor\n\n";
+
+    // Create a tensor and set requires_grad=True to track computation with it:
+    auto x = torch::ones({2, 2}, torch::TensorOptions().requires_grad(true));
+    std::cout << "x:\n" << x << '\n';
+
+    // Do a tensor operation:
+    auto y = x + 2;
+    std::cout << "y:\n" << y << '\n';
+
+    // y was created as a result of an operation, so it has a grad_fn:
+    std::cout << "y.grad_fn:\n" << y.grad_fn() << '\n';
+
+    // Do more operations on y:
+    auto z = y * y * 3;
+    auto out = z.mean();
+    std::cout << "z:\n" << z << "out:\n" << out << '\n';
+
+    // .requires_grad_(...) changes an existing Tensor’s requires_grad flag in-place:
+    auto a = torch::randn({2, 2});
+    a = ((a * 3) / (a - 1));
+    std::cout << a.requires_grad() << '\n';
+    a.requires_grad_(true);
+    std::cout << a.requires_grad() << '\n';
+    auto b = (a * a).sum();
+    std::cout << b.grad_fn() << '\n';
+
+    std::cout << "Gradients\n\n";
+
+    // Let’s backprop now:
+    out.backward();
+
+    // Print gradients d(out)/dx:
+    std::cout << "x.grad:\n" << x.grad() << '\n';
+
+    // Example of vector-Jacobian product:
+    x = torch::randn(3, torch::TensorOptions().requires_grad(true));
+    y = x * 2;
+    while (y.data().norm().item<int>() < 1000) {
+        y = y * 2;
+    }
+    std::cout << "y:\n" << y << '\n';
+
+    // Simply pass the vector to backward as argument:
+    auto v = torch::tensor({0.1, 1.0, 0.0001}, torch::TensorOptions(torch::kFloat));
+    y.backward(v);
+    std::cout << "x.grad:\n" << x.grad() << '\n';
+
+    // Stop autograd from tracking history on Tensors with .requires_grad=True:
+    std::cout << "x.requires_grad\n" << x.requires_grad() << '\n';
+    std::cout << "(x ** 2).requires_grad\n" << (x * x).requires_grad() << '\n';
+    torch::NoGradGuard no_grad;
+    std::cout << "(x ** 2).requires_grad\n" << (x * x).requires_grad() << '\n';
+
+    // Or by using .detach() to get a new Tensor with the same content but that does not require gradients:
+    std::cout << "x.requires_grad:\n" << x.requires_grad() << '\n';
+    y = x.detach();
+    std::cout << "y.requires_grad:\n" << y.requires_grad() << '\n';
+    std::cout << "x.eq(y).all():\n" << x.eq(y).all() << '\n';
+}

tutorials/popular/blitz/neural_networks/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
+
+project(neural-networks VERSION 1.0.0 LANGUAGES CXX)
+
+if(NOT Torch_FOUND)
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../../cmake")
+    find_package(Torch REQUIRED PATHS "${CMAKE_CURRENT_SOURCE_DIR}/../../../../libtorch")
+endif()
+
+set(EXECUTABLE_NAME neural-networks)
+
+add_executable(${EXECUTABLE_NAME})
+target_sources(${EXECUTABLE_NAME} PRIVATE src/main.cpp
+                                          src/nnet.cpp
+                                          include/nnet.h
+)
+
+target_include_directories(${EXECUTABLE_NAME} PRIVATE include)
+
+target_link_libraries(${EXECUTABLE_NAME} ${TORCH_LIBRARIES})
+
+set_target_properties(${EXECUTABLE_NAME} PROPERTIES
+  CXX_STANDARD 14
+  CXX_STANDARD_REQUIRED YES
+)
+
+if(MSVC)
+    set_target_properties(${EXECUTABLE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_CURRENT_BINARY_DIR})
+    set_target_properties(${EXECUTABLE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_CURRENT_BINARY_DIR})
+    include(copy_torch_dlls)
+    copy_torch_dlls(${EXECUTABLE_NAME})
+endif(MSVC)

tutorials/popular/blitz/neural_networks/include/nnet.h

@@ -0,0 +1,21 @@
+// Copyright 2020-present pytorch-cpp Authors
+#pragma once
+
+#include <torch/torch.h>
+
+class NetImpl : public torch::nn::Module {
+ public:
+    NetImpl();
+    torch::Tensor forward(torch::Tensor x);
+
+    torch::nn::Conv2d conv1;
+    torch::nn::Conv2d conv2;
+    torch::nn::Linear fc1;
+    torch::nn::Linear fc2;
+    torch::nn::Linear fc3;
+
+ private:
+    int num_flat_features(torch::Tensor x);
+};
+
+TORCH_MODULE(Net);

tutorials/popular/blitz/neural_networks/src/main.cpp

@@ -0,0 +1,61 @@
+// Copyright 2020-present pytorch-cpp Authors
+#include <torch/torch.h>
+#include <iostream>
+#include <iomanip>
+#include "nnet.h"
+
+int main() {
+    std::cout << "Deep Learning with PyTorch: A 60 Minute Blitz\n\n";
+    std::cout << "Neural Networks\n\n";
+
+    std::cout << "Define the network\n\n";
+    Net net = Net();
+    net->to(torch::kCPU);
+    std::cout << net << "\n\n";
+
+    // The learnable parameters of a model are returned by net.parameters():
+    auto params = net->parameters();
+    std::cout << params.size() << '\n';
+    std::cout << params.at(0).sizes() << "\n\n";  // conv1's .weight
+
+    // Let’s try a random 32x32 input:
+    auto input = torch::randn({1, 1, 32, 32});
+    auto out = net->forward(input);
+    std::cout << out << "\n\n";
+
+    // Zero the gradient buffers of all parameters and backprops with random gradients:
+    net->zero_grad();
+    out.backward(torch::randn({1, 10}));
+
+    std::cout << "Loss Function\n\n";
+
+    auto output = net->forward(input);
+    auto target = torch::randn(10);  // a dummy target, for example
+    target = target.view({1, -1});  // make it the same shape as output
+    torch::nn::MSELoss criterion;
+    auto loss = criterion(output, target);
+    std::cout << loss << "\n\n";
+
+    // For illustration, let us follow a few steps backward:
+    std::cout << "loss.grad_fn:\n" << loss.grad_fn() << '\n';  // MSELoss
+
+    std::cout << "Backprop\n\n";
+
+    // Now we shall call loss.backward(), and have a look at conv1’s bias gradients before and after the backward:
+    net->zero_grad();  // zeroes the gradient buffers of all parameters
+    std::cout << "conv1.bias.grad before backward:\n" << net->conv1->bias.grad() << '\n';
+    loss.backward();
+    std::cout << "conv1.bias.grad after backward:\n" << net->conv1->bias.grad() << "\n\n";
+
+    std::cout << "Update the weights\n\n";
+
+    // create your optimizer
+    auto learning_rate = 0.01;
+    auto optimizer = torch::optim::SGD(net->parameters(), torch::optim::SGDOptions(learning_rate));
+    // in your training loop:
+    optimizer.zero_grad();   // zero the gradient buffers
+    output = net->forward(input);
+    loss = criterion(output, target);
+    loss.backward();
+    optimizer.step();    // Does the update
+}

tutorials/popular/blitz/neural_networks/src/nnet.cpp

@@ -0,0 +1,36 @@
+// Copyright 2020-present pytorch-cpp Authors
+#include "nnet.h"
+#include <torch/torch.h>
+
+NetImpl::NetImpl() :
+    conv1(torch::nn::Conv2dOptions(1, 6, 3)),
+    conv2(torch::nn::Conv2dOptions(6, 16, 3)),
+    fc1(torch::nn::LinearOptions(16 * 6 * 6, 120)),
+    fc2(torch::nn::LinearOptions(120, 84)),
+    fc3(torch::nn::LinearOptions(84, 10)) {
+    register_module("conv1", conv1);
+    register_module("conv2", conv2);
+    register_module("fc1", fc1);
+    register_module("fc2", fc2);
+    register_module("fc3", fc3);
+}
+
+int NetImpl::num_flat_features(torch::Tensor x) {
+    auto sz = x.sizes().slice(1);  // all dimensions except the batch dimension
+    int num_features = 1;
+    for (auto s : sz) {
+        num_features *= s;
+    }
+    return num_features;
+}
+
+torch::Tensor NetImpl::forward(torch::Tensor x) {
+    // Max pooling over a (2, 2) window
+    auto out = torch::nn::MaxPool2d(torch::nn::MaxPool2dOptions({2, 2}))->forward(torch::relu(conv1->forward(x)));
+    // If the size is a square you can only specify a single number
+    out = torch::nn::MaxPool2d(torch::nn::MaxPool2dOptions(2))->forward(torch::relu(conv2->forward(out)));
+    out = out.view({-1, num_flat_features(out)});
+    out = torch::relu(fc1->forward(out));
+    out = torch::relu(fc2->forward(out));
+    return fc3->forward(out);
+}

tutorials/popular/blitz/tensors/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
+
+project(tensors VERSION 1.0.0 LANGUAGES CXX)
+
+if(NOT Torch_FOUND)
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../../cmake")
+    find_package(Torch REQUIRED PATHS "${CMAKE_CURRENT_SOURCE_DIR}/../../../../libtorch")
+endif()
+
+set(EXECUTABLE_NAME tensors)
+
+add_executable(${EXECUTABLE_NAME})
+target_sources(${EXECUTABLE_NAME} PRIVATE main.cpp)
+
+target_link_libraries(${EXECUTABLE_NAME} ${TORCH_LIBRARIES})
+
+set_target_properties(${EXECUTABLE_NAME} PROPERTIES
+  CXX_STANDARD 14
+  CXX_STANDARD_REQUIRED YES
+)
+
+if(MSVC)
+    set_target_properties(${EXECUTABLE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_CURRENT_BINARY_DIR})
+    set_target_properties(${EXECUTABLE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_CURRENT_BINARY_DIR})
+    include(copy_torch_dlls)
+    copy_torch_dlls(${EXECUTABLE_NAME})
+endif(MSVC)