blitz: Added cifar, training a classifier tutorial

Author: prabhuomkar

tutorials/popular/blitz/autograd/main.cpp

@@ -45,7 +45,7 @@ int main() {
     // Example of vector-Jacobian product:
     x = torch::randn(3, torch::TensorOptions().requires_grad(true));
     y = x * 2;
-    while (y.data().norm().item().toInt() < 1000) {
+    while (y.data().norm().item<int>() < 1000) {
         y = y * 2;
     }
     std::cout << "y:\n" << y << '\n';

tutorials/popular/blitz/tensors/main.cpp

@@ -63,5 +63,5 @@ int main() {
     // If you have a one element tensor, use .item() to get the value as a Python number
     x = torch::randn(1);
     std::cout << "x:\n" << x << '\n';
-    std::cout << "x.item():\n" << x.item().toFloat() << '\n';
+    std::cout << "x.item():\n" << x.item<float>() << '\n';
 }

tutorials/popular/blitz/training_a_classifier/CMakeLists.txt

@@ -10,7 +10,14 @@ endif()
 set(EXECUTABLE_NAME training-a-classifier)
 
 add_executable(${EXECUTABLE_NAME})
-target_sources(${EXECUTABLE_NAME} PRIVATE main.cpp)
+target_sources(${EXECUTABLE_NAME} PRIVATE src/main.cpp
+                                          src/nnet.cpp
+                                          src/cifar10.cpp
+                                          include/nnet.h
+                                          include/cifar10.h
+)
+
+target_include_directories(${EXECUTABLE_NAME} PRIVATE include)
 
 target_link_libraries(${EXECUTABLE_NAME} ${TORCH_LIBRARIES})
 

tutorials/popular/blitz/training_a_classifier/include/cifar10.h

@@ -0,0 +1,44 @@
+// Copyright 2020-present pytorch-cpp Authors
+#pragma once
+
+#include <torch/data/datasets/base.h>
+#include <torch/data/example.h>
+#include <torch/types.h>
+#include <cstddef>
+#include <fstream>
+#include <string>
+
+// CIFAR10 dataset
+// based on: https://github.com/pytorch/pytorch/blob/master/torch/csrc/api/include/torch/data/datasets/mnist.h.
+class CIFAR10 : public torch::data::datasets::Dataset<CIFAR10> {
+ public:
+    // The mode in which the dataset is loaded
+    enum Mode { kTrain, kTest };
+
+    // Loads the CIFAR10 dataset from the `root` path.
+    //
+    // The supplied `root` path should contain the *content* of the unzipped
+    // CIFAR10 dataset (binary version), available from http://www.cs.toronto.edu/~kriz/cifar.html.
+    explicit CIFAR10(const std::string& root, Mode mode = Mode::kTrain);
+
+    // Returns the `Example` at the given `index`.
+    torch::data::Example<> get(size_t index) override;
+
+    // Returns the size of the dataset.
+    torch::optional<size_t> size() const override;
+
+    // Returns true if this is the training subset of CIFAR10.
+    bool is_train() const noexcept;
+
+    // Returns all images stacked into a single tensor.
+    const torch::Tensor& images() const;
+
+    // Returns all targets stacked into a single tensor.
+    const torch::Tensor& targets() const;
+
+ private:
+    torch::Tensor images_;
+    torch::Tensor targets_;
+    Mode mode_;
+};
+

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

@@ -0,0 +1,20 @@
+// 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);
+
+ private:
+    torch::nn::Conv2d conv1;
+    torch::nn::MaxPool2d pool;
+    torch::nn::Conv2d conv2;
+    torch::nn::Linear fc1;
+    torch::nn::Linear fc2;
+    torch::nn::Linear fc3;
+};
+
+TORCH_MODULE(Net);

tutorials/popular/blitz/training_a_classifier/main.cpp

@@ -0,0 +1,98 @@
+// Copyright 2020-present pytorch-cpp Authors
+#include "cifar10.h"
+
+namespace {
+// CIFAR10 dataset description can be found at https://www.cs.toronto.edu/~kriz/cifar.html.
+constexpr uint32_t kTrainSize = 50000;
+constexpr uint32_t kTestSize = 10000;
+constexpr uint32_t kSizePerBatch = 10000;
+constexpr uint32_t kImageRows = 32;
+constexpr uint32_t kImageColumns = 32;
+constexpr uint32_t kBytesPerRow = 3073;
+constexpr uint32_t kBytesPerChannelPerRow = 1024;
+constexpr uint32_t kBytesPerBatchFile = kBytesPerRow * kSizePerBatch;
+
+const std::vector<std::string> kTrainDataBatchFiles = {
+    "data_batch_1.bin",
+    "data_batch_2.bin",
+    "data_batch_3.bin",
+    "data_batch_4.bin",
+    "data_batch_5.bin",
+};
+
+const std::vector<std::string> kTestDataBatchFiles = {
+    "test_batch.bin"
+};
+
+// Source: https://github.com/pytorch/pytorch/blob/master/torch/csrc/api/src/data/datasets/mnist.cpp.
+std::string join_paths(std::string head, const std::string& tail) {
+    if (head.back() != '/') {
+        head.push_back('/');
+    }
+    head += tail;
+    return head;
+}
+// Partially based on https://github.com/pytorch/pytorch/blob/master/torch/csrc/api/src/data/datasets/mnist.cpp.
+std::pair<torch::Tensor, torch::Tensor> read_data(const std::string& root, bool train) {
+    const auto& files = train ? kTrainDataBatchFiles : kTestDataBatchFiles;
+    const auto num_samples = train ? kTrainSize : kTestSize;
+
+    std::vector<char> data_buffer;
+    data_buffer.reserve(files.size() * kBytesPerBatchFile);
+
+    for (const auto& file : files) {
+        const auto path = join_paths(root, file);
+        std::ifstream data(path, std::ios::binary);
+        TORCH_CHECK(data, "Error opening data file at", path);
+
+        data_buffer.insert(data_buffer.end(), std::istreambuf_iterator<char>(data), {});
+    }
+
+    TORCH_CHECK(data_buffer.size() == files.size() * kBytesPerBatchFile, "Unexpected file sizes");
+
+    auto targets = torch::empty(num_samples, torch::kByte);
+    auto images = torch::empty({num_samples, 3, kImageRows, kImageColumns}, torch::kByte);
+
+    for (uint32_t i = 0; i != num_samples; ++i) {
+        // The first byte of each row is the target class index.
+        uint32_t start_index = i * kBytesPerRow;
+        targets[i] = data_buffer[start_index];
+
+        // The next bytes correspond to the rgb channel values in the following order:
+        // red (32 *32 = 1024 bytes) | green (1024 bytes) | blue (1024 bytes)
+        uint32_t image_start = start_index + 1;
+        uint32_t image_end = image_start + 3 * kBytesPerChannelPerRow;
+        std::copy(data_buffer.begin() + image_start, data_buffer.begin() + image_end,
+            reinterpret_cast<char*>(images[i].data_ptr()));
+    }
+
+    return {images.to(torch::kFloat32).div_(255), targets.to(torch::kInt64)};
+}
+}  // namespace
+
+CIFAR10::CIFAR10(const std::string& root, Mode mode) : mode_(mode) {
+    auto data = read_data(root, mode == Mode::kTrain);
+
+    images_ = std::move(data.first);
+    targets_ = std::move(data.second);
+}
+
+torch::data::Example<> CIFAR10::get(size_t index) {
+    return {images_[index], targets_[index]};
+}
+
+torch::optional<size_t> CIFAR10::size() const {
+    return images_.size(0);
+}
+
+bool CIFAR10::is_train() const noexcept {
+    return mode_ == Mode::kTrain;
+}
+
+const torch::Tensor& CIFAR10::images() const {
+    return images_;
+}
+
+const torch::Tensor& CIFAR10::targets() const {
+    return targets_;
+}

tutorials/popular/blitz/training_a_classifier/src/cifar10.cpp

@@ -0,0 +1,120 @@
+// Copyright 2020-present pytorch-cpp Authors
+#include <torch/torch.h>
+#include <iostream>
+#include <vector>
+#include <iomanip>
+#include "nnet.h"
+#include "cifar10.h"
+
+int main() {
+    std::cout << "Deep Learning with PyTorch: A 60 Minute Blitz\n\n";
+    std::cout << "Training a Classifier\n\n";
+
+    // Loading and normalizing CIFAR10
+    const std::string CIFAR_data_path = "../../../../../data/cifar10/";
+
+    auto train_dataset = CIFAR10(CIFAR_data_path)
+        .map(torch::data::transforms::Normalize<>({0.5, 0.5, 0.5}, {0.5, 0.5, 0.5}))
+        .map(torch::data::transforms::Stack<>());
+    auto train_loader = torch::data::make_data_loader<torch::data::samplers::RandomSampler>(
+        std::move(train_dataset), 4);
+
+    auto test_dataset = CIFAR10(CIFAR_data_path, CIFAR10::Mode::kTest)
+        .map(torch::data::transforms::Normalize<>({0.5, 0.5, 0.5}, {0.5, 0.5, 0.5}))
+        .map(torch::data::transforms::Stack<>());
+    auto test_loader = torch::data::make_data_loader<torch::data::samplers::SequentialSampler>(
+        std::move(test_dataset), 4);
+
+    std::string classes[10] = {"plane", "car", "bird", "cat",
+           "deer", "dog", "frog", "horse", "ship", "truck"};
+
+    // Define a Convolutional Neural Network
+    Net net = Net();
+    net->to(torch::kCPU);
+
+    // // Define a Loss function and optimizer
+    torch::nn::CrossEntropyLoss criterion;
+    torch::optim::SGD optimizer(net->parameters(), torch::optim::SGDOptions(0.001).momentum(0.9));
+
+    // Train the network
+    for (size_t epoch = 0; epoch < 2; ++epoch) {
+        double running_loss = 0.0;
+
+        int i = 0;
+        for (auto& batch : *train_loader) {
+            // get the inputs; data is a list of [inputs, labels]
+            auto inputs = batch.data.to(torch::kCPU);
+            auto labels = batch.target.to(torch::kCPU);
+
+            // zero the parameter gradients
+            optimizer.zero_grad();
+
+            // forward + backward + optimize
+            auto outputs = net->forward(inputs);
+            auto loss = criterion(outputs, labels);
+            loss.backward();
+            optimizer.step();
+
+            // print statistics
+            running_loss += loss.item<double>();
+            if (i % 2000 == 1999) {  // print every 2000 mini-batches
+                std::cout << "[" << epoch + 1 << ", " << i + 1 << "] loss: "
+                    << running_loss / 2000 << '\n';
+                running_loss = 0.0;
+            }
+            i++;
+        }
+    }
+    std::cout << "Finished Training\n\n";
+
+    std::string PATH = "./cifar_net.pth";
+    // torch::save(net, PATH);
+
+    // Test the network on the test data
+    net = Net();
+    torch::load(net, PATH);
+
+    int correct = 0;
+    int total = 0;
+    for (const auto& batch : *test_loader) {
+        auto images = batch.data.to(torch::kCPU);
+        auto labels = batch.target.to(torch::kCPU);
+
+        auto outputs = net->forward(images);
+
+        auto out_tuple = torch::max(outputs, 1);
+        auto predicted = std::get<1>(out_tuple);
+        total += labels.size(0);
+        correct += (predicted == labels).sum().item<int>();
+    }
+
+    std::cout << "Accuracy of the network on the 10000 test images: "
+        << (100 * correct / total) << "%\n\n";
+
+    float class_correct[10];
+    float class_total[10];
+
+    torch::NoGradGuard no_grad;
+
+    for (const auto& batch : *test_loader) {
+        auto images = batch.data.to(torch::kCPU);
+        auto labels = batch.target.to(torch::kCPU);
+
+        auto outputs = net->forward(images);
+
+        auto out_tuple = torch::max(outputs, 1);
+        auto predicted = std::get<1>(out_tuple);
+        auto c = (predicted == labels).squeeze();
+
+        for (int i = 0; i < 4; ++i) {
+            auto label = labels[i].item<int>();
+            class_correct[label] += c[i].item<float>();
+            class_total[label] += 1;
+        }
+    }
+
+    for (int i = 0; i < 10; ++i) {
+        std::cout << "Accuracy of " << classes[i] << " "
+            << 100 * class_correct[i] / class_total[i] << "%\n";
+    }
+}

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

@@ -0,0 +1,26 @@
+// Copyright 2020-present pytorch-cpp Authors
+#include "nnet.h"
+#include <torch/torch.h>
+
+NetImpl::NetImpl() :
+    conv1(torch::nn::Conv2dOptions(3, 6, 5)),
+    pool(torch::nn::MaxPool2dOptions({2, 2})),
+    conv2(torch::nn::Conv2dOptions(6, 16, 5)),
+    fc1(torch::nn::LinearOptions(16 * 5 * 5, 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);
+}
+
+torch::Tensor NetImpl::forward(torch::Tensor x) {
+    auto out = pool->forward(torch::relu(conv1->forward(x)));
+    out = pool->forward(torch::relu(conv2->forward(out)));
+    out = out.view({-1, 16 * 5 * 5});
+    out = torch::relu(fc1->forward(out));
+    out = torch::relu(fc2->forward(out));
+    return fc3->forward(out);
+}