dnn_net.h

Go to the documentation of this file.

// Copyright 2019 Claes Rolen (www.rolensystems.com)
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

#pragma once
#include <chrono>
using namespace std::chrono;
high_resolution_clock::time_point tic, toc;

namespace dnn
{

class net
{
private:
    std::vector<layer*> netlist;     
    arma::Mat<DNN_Dtype>* Xptr;      
    arma::Mat<DNN_Dtype>* Tptr;      
    arma::uword curEpoch;            
    arma::uword N_epoch;             
    arma::uword N_data;              
    arma::uword N_batch;             
    arma::uword N_iter;              
    arma::mat cost_val;              
    arma::mat accuracy;              
    PHASE phase;                     
public:
    net(void)
    {
        N_epoch    = 0;
        curEpoch   = 0;
        N_batch    = 1;
        N_data     = 0;
        N_iter     = 0;
        phase      = PHASE::TRAIN;
    };

    ~net() {};

    void data_set( arma::Mat<DNN_Dtype>& data,arma::Mat<DNN_Dtype>& label,arma::uword Nmb,arma::uword Nep=1)
    {
        N_batch   = Nmb;
        N_epoch   = Nep;
        curEpoch  = 0;
        Xptr      = &data;
        Tptr      = &label;
        N_data    = data.n_cols;
        N_iter    = static_cast<arma::uword>(floor(N_data/N_batch));

        std::cout << std::endl;
        std::cout << "Nr of data:       " << N_data << std::endl;
        std::cout << "Minibatch size:   " << N_batch << std::endl;
        std::cout << "Iterations/EPOCH: " << N_iter << std::endl;
        std::cout << "EPOCHs:           " << N_epoch << std::endl;

        ((layer_input*)netlist.front())->set_data(Xptr);
        ((layer_cost*)netlist.back())->set_data(Tptr);

        // Update buffer size and clear
        for(size_t l=0; l<netlist.size(); l++)
        {
            netlist.at(l)->upd_buf_size(N_batch);
        }

        // Clear statistics
        cost_val.set_size(N_iter,N_epoch);
        cost_val.zeros();
        accuracy.set_size(N_iter,N_epoch);
        accuracy.zeros();
    }

    void set_batch_len(arma::uword n)
    {
        N_batch = n;
    }

    arma::mat get_accuracy(void)
    {
        return accuracy;
    }

    arma::mat get_cost(void)
    {
        return cost_val;
    }

    void permute_data(arma::Mat<DNN_Dtype>* Xptr,arma::Mat<DNN_Dtype>* Tptr)
    {
        arma::Mat<DNN_Dtype> Xc(*Xptr);
        arma::Mat<DNN_Dtype> Tc(*Tptr);
        arma::uvec ix0 = arma::regspace<arma::uvec>(0,Xc.n_cols-1);
        arma::uvec ix  = arma::shuffle(ix0);

        for(arma::uword c = 0; c<Xptr->n_cols; c++)
        {
            (*Xptr).col(c) = Xc.col(ix(c));
            (*Tptr).col(c) = Tc.col(ix(c));
        }
    }

    void add_layer(layer& lay)
    {
        if(!netlist.empty())
        {
            lay.set_left(netlist.back());
            netlist.back()->set_right(&lay);
        }
        lay.set_ix(netlist.size());
        lay.init();
        netlist.push_back(&lay);
    }

    bool compile(void)
    {
        // Check in and outputs
        std::string first = netlist.front()->get_type();
        std::string last  = netlist.back()->get_type();
        if(first.compare("Input") || last.compare("Output"))
        {
            std::cout << "Net must have input and output!" << std::endl;
            return false;
        }

        // Check dimensions
        for(size_t l=1; l<netlist.size(); l++)
        {
            arma::uword n = netlist.at(l)->get_nrof_inputs();
            arma::uword m = netlist.at(l-1)->get_nrof_outputs();
            if(n != m)
            {
                std::cout << "Wrong dimensions: " << n << " " << m << std::endl;
                return false;
            }
        }
        return true;
    }

    void disp(void)
    {
        std::ios init(NULL);
        init.copyfmt(std::cout);

        std::cout << std::left << "\n "
           << std::setw(6)  << "Layer"
           << std::setw(23) << "TypeId"
           << std::setw(30) << "Optimizer"
           << std::setw(12) << "Shape"
           << std::setw(10) << "Params"
           << std::endl;

        // restore default formatting
        std::cout.copyfmt(init);

        std::cout << "================================================================================" << std::endl;
        for(auto it:netlist)
        {
              std::cout << *it << std::endl;
        }
        std::cout << "================================================================================" << std::endl;

    }

    void train(void)
    {
        // Shuffle the training data
        permute_data(Xptr,Tptr);

        // Change network state
        phase = PHASE::TRAIN;
        for(size_t l=0; l<netlist.size(); l++)
        {
            netlist.at(l)->set_phase(PHASE::TRAIN);
        }

        tic = high_resolution_clock::now();
        // Loop through the entire train dataset
        for (unsigned int n=0; n<N_iter; n++)
        {
            // Forward
            for(size_t l=0; l<netlist.size(); l++)
            {
                netlist.at(l)->prop_mb();
            }
            // Log statistcs
            cost_val.at(n,curEpoch) = ((layer_cost*)netlist.back())->get_cost();
            accuracy.at(n,curEpoch) = ((layer_cost*)netlist.back())->get_acc();

            // Backpropagate
            for(size_t l=netlist.size()-1; l>1; l--)
            {
                netlist.at(l)->backprop();
            }

            // Update
            for(size_t l=0; l<netlist.size(); l++)
            {
                netlist.at(l)->update();
            }
            progress_bar("Train",n,N_iter);
        }
        remove_progress_bar();

        toc = high_resolution_clock::now();
        curEpoch++;
    }

    void test(void)
    {
        // Change network state
        phase = PHASE::TEST;
        for(size_t l=0; l<netlist.size(); l++)
        {
            netlist.at(l)->set_phase(PHASE::TEST);
        }

        tic = high_resolution_clock::now();
        // Loop through the entire test dataset
        for (unsigned int n=0; n<N_iter; n++)
        {
            // Forward
            for(size_t l=0; l<netlist.size(); l++)
            {
                netlist.at(l)->prop_mb();
            }
            cost_val.at(n,curEpoch) = ((layer_cost*)netlist.back())->get_cost();
            accuracy.at(n,curEpoch) = ((layer_cost*)netlist.back())->get_acc();
            progress_bar("Test",n,N_iter);
        }
        remove_progress_bar();
        toc = high_resolution_clock::now();
        curEpoch++;
    }

    void show_stat(void)
    {
        std::ios init(NULL);
        init.copyfmt(std::cout);
        if(curEpoch==1)
        {
            std::cout << "---------------------------------------------------------" << std::endl;
            std::cout << std::left << " "
                   << std::setw(8)  << "EPOCH"
                   << std::setw(15) << "Cost"
                   << std::setw(15) << "Accuracy [%]"
                   << std::setw(15) << "Time [ms]"
                   << std::endl;
            // restore default formatting
            std::cout.copyfmt(init);
            std::cout << "---------------------------------------------------------" << std::endl;
        }
        std::cout << std::left << " "
               << std::setw(8)  << curEpoch
               << std::setw(15) << arma::mean(cost_val.col(curEpoch-1))          // Return the mean over all iterations
               << std::setw(15) << 100*arma::mean(accuracy.col(curEpoch-1))      // Return the mean over all iterations
               << std::setw(15) << duration_cast<milliseconds>(toc - tic).count()
               << std::endl;

        // restore default formatting
        std::cout.copyfmt(init);
    }

    arma::Mat<DNN_Dtype> predict(const arma::Mat<DNN_Dtype>& in)
    {
        for(size_t l=0; l<netlist.size(); l++)
        {
            netlist.at(l)->set_phase(PHASE::PRED);
        }

        ((layer_input*)netlist.front())->set_data(&in);
        ((layer_input*)netlist.front())->reset_batch_ctr();
        ((layer_cost*)netlist.back())->reset_batch_ctr();
        // Forward
        for(size_t l=0; l<netlist.size(); l++)
        {
            netlist.at(l)->prop();
        }
        return ((layer_cost*)netlist.back())->get_Y1();
    }
}; // End class net
} // End namespace dnn