XShinnosuke_cpp: Deep Learning Framework

Xshinnosuke_cpp is the cpp version of xshinnosuke.

As xshinnosuke_cpp choose Eigen as matrix backend and Eigen only supports for Array and Matrix, in other words, the data in Eigen is less than 3 dimensions, so xshinnosuke_cpp just supports operations for 2-dimension datas, such as Linear(Linear in Pytorch or Dense in Keras), relu, sigmoid, batch normalization, etc.

For more functional or Layers details, such as Conv2D, max_pool2d, embedding, lstm, etc. Please refer to xshinnosuke.

Here are some features of XShinnosuke:

1. Based on Eigen and native to C++.

2. Without any other 3rd-party deep learning library.

3. Keras and Pytorch style API, easy to start.

4. Sequential in Keras and Pytorch, Model in Keras and Module in Pytorch, all of them are supported in xshinnosuke_cpp.

5. Training and inference supports for both dynamic graph and static graph.

6. Autograd is supported .

Getting started

Dynamic Graph

#pragma once
#include<iostream>
#include "../layers/linear.h"
#include "../models.h"
#include "../nn/functional.h"
#include "../utils/data.h"
#include<ctime>
#include<vector>
using namespace std;

// define the network
class myNet : public Module {
// your diy network must be inherited from Module
public:
    // declare layers
    myNet(int n_classes) {
        this->fc1 = new Linear(10);
        this->relu1 = new ReLU();
        this->fc2 = new Linear(5);
        this->relu2 = new ReLU();
        this->fc3 = new Linear(n_classes);

    };
    // free the pointers
    ~myNet() {
        delete this->fc1;
        delete this->relu1;
        delete this->fc2;
        delete this->relu2;
        delete this->fc3;
        this->fc1 = NULL;
        this->relu1 = NULL;
        this->fc2 = NULL;
        this->relu2 = NULL;
        this->fc3 = NULL;
    }
    // design forward flow
    Variable* forward(Variable* x) {
        Variable* out;
        out = (*(this->fc1))(x);
        out = (*(this->relu1))(out);
        out = (*(this->fc2))(out);
        out = (*(this->relu2))(out);
        out = (*(this->fc3))(out);
        // use funcational -> sigmoid
        out = sigmoid(out);
        return out;
    }

    Layer* fc1;
    Layer* relu1;
    Layer* fc2;
    Layer* relu2;
    Layer* fc3;
};

void run_dynamic() {
    // random generate training datas
    // generate training input datas
    Eigen::MatrixXf x = Eigen::MatrixXf::Random(100, 10);
    Eigen::MatrixXf y = Eigen::MatrixXf::Zero(100, 1);
    for (int i = 0; i < 10; ++i) {
        for (int j = 0; j < 1; ++j) {
            float n = (rand() % 10) / 10;
            if (n >= 0.5) {
                y(i, j) = 1;
            }
        }
    }
    // batch_size
    int BATCH_SIZE = 20;
    // xshinnosuke_cpp provides DataLoader for batch training/inference
    Dataset train_set = Dataset(x, y);
    DataLoader train_loader = DataLoader(train_set, BATCH_SIZE);
    // instantiate your diy network
    myNet net = myNet(1);
     // declare criterion
    Objective* criterion = new BinaryCrossEntropy();
    // declare optimizer, notice pass network's parameters to optimizer
    Optimizer* optimizer = new SGD(net.parameters());

    clock_t startTime, endTime;
    startTime = clock();
    int EPOCH = 10;
    // define training flow
    for (int epoch = 0; epoch < EPOCH; ++epoch) {
        for (auto it = train_loader.begin(); it != train_loader.end(); ++it) {
            Variable *inputs = (*it).first, *target = (*it).second;
            // at every epoch zero_grad's optimizer's trainable_variables' grad.
            optimizer->zero_grad();
            // forward
            Variable* out = net(inputs);
            // calculate loss
            Variable* loss = (*criterion)(out, target);
            float acc = criterion->calc_acc(out, target);
            cout << "iter: " << epoch << " loss: " << loss->item() << " acc: " <<
                acc << endl;
            // backward
            loss->backward();
            // update parameters
            optimizer->step();
        }
    }
    endTime = clock();
    cout << "The run time is: " <<
        (double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;

Static Graph

#pragma once
#include "../layers/base.h"
#include "../layers/linear.h"
#include "../layers/activators.h"
#include "../models.h"
#include "../utils/shape.h"
#include<ctime>

void run_static() {
    int n_classes = 1;
    Eigen::MatrixXf x = Eigen::MatrixXf::Random(100, 10);
    Eigen::MatrixXf y = Eigen::MatrixXf::Zero(100, 1);
    for (int i = 0; i < 10; ++i) {
        for (int j = 0; j < 1; ++j) {
            float n = (rand() % 10) / 10;
            if (n >= 0.5) {
                y(i, j) = 1;
            }
        }
    }
    Sequential model = Sequential();
    // The first layer in Sequential must be specify input_shape(no need specify batch_size).
    model.add(new Linear(10, "null", false, "random", "zeros", Shape({ 10 })));
    model.add(new ReLU());
    model.add(new Linear(5));
    model.add(new ReLU());
    model.add(new Linear(n_classes));
    model.add(new Sigmoid());
    model.compile("sgd", "bce");
    clock_t startTime, endTime;
    startTime = clock();
    int BATCH_SIZE = 20;
    int EPOCH = 10;
    model.fit(&x, &y, BATCH_SIZE, EPOCH);
    endTime = clock();
    cout << "The run time is: " <<
        (double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
}

Installation

• First download Eigen.

• git clone https://github.com/eLeVeNnN/xshinnosuke_cpp.git

• Include Eigen to xshinnosuke_cpp projects

Demo

run demo.cpp