dnn_misc.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
namespace dnn
{


std::string version_info(void)
{
    return std::to_string(DNN_VERSION_MAJOR)+"."+std::to_string(DNN_VERSION_MINOR)+"."+std::to_string(DNN_VERSION_PATCH);
}

template<typename T>
void pol2cart(const T phi,const T r, T& x, T& y)
{
    x = r*cos(phi);
    y = r*sin(phi);
}
template<typename T>
void pol2cart(const arma::Mat<T> phi,const arma::Mat<T> r, arma::Mat<T>& x, arma::Mat<T>& y)
{
    x = r%cos(phi);
    y = r%sin(phi);
}

template<typename T>
void cart2pol(const T x, const T y, T& phi, T& r)
{
    phi = atan2(y,x);
    r = sqrt(x*x+y*y);
}

template<typename T>
void cart2pol(const arma::Mat<T> x, const arma::Mat<T> y, arma::Mat<T>& phi, arma::Mat<T>& r)
{
    phi = atan2(y,x);
    r   = sqrt(x%x+y%y);
}


arma_inline arma::Mat<DNN_Dtype> row2col(const arma::Mat<DNN_Dtype>& A)
{
    arma::Mat<DNN_Dtype> B=arma::vectorise(A,1);
    return B.t();
}

arma_inline arma::Mat<DNN_Dtype> col2col(const arma::Mat<DNN_Dtype>& A)
{
    return arma::vectorise(A);
}

arma_inline arma::Mat<DNN_Dtype> mat2mat(const arma::Mat<DNN_Dtype>& A, const arma::uword rows,const arma::uword cols)
{
    arma::Mat<DNN_Dtype> B(A.memptr(), rows, cols);
    return B;
}

arma_inline arma::Cube<DNN_Dtype> mat2cube(const arma::Mat<DNN_Dtype>& A, const arma::uword rows,const arma::uword cols, const arma::uword slices)
{
    arma::Cube<DNN_Dtype> B(A.memptr(), rows, cols, slices);
    return B;
}

arma_inline arma::Mat<DNN_Dtype> cube2mat(arma::Cube<DNN_Dtype>& A,const arma::uword rows,const arma::uword cols)
{
    arma::Mat<DNN_Dtype> B(A.memptr(),rows,cols);
    return B;
}


void gen_spiral(arma::Mat<DNN_Dtype> &X,arma::Mat<DNN_Dtype> &T, arma::uword N, arma::uword K,
                const double ph_var = 0.1, const double r_min = 0.1,
                const double ph_max = 7)
{
    X.zeros(2,N);
    T.zeros(K,N);
    arma::uvec Tk = arma::randi<arma::uvec>(N,arma::distr_param(1,(int)K));
    for(arma::uword n=0; n<N; n++)
    {
        double x=0,y=0;
        double r  = r_min+ arma::randu()*(1-r_min);
        double ph = r*ph_max+ ph_var*arma::randn()+ Tk(n)*2.0*arma::datum::pi/K;
        pol2cart(ph,r,x,y);
        T(Tk(n)-1,n) = static_cast<DNN_Dtype>(1.0);
        X(0,n) = static_cast<DNN_Dtype>(x);
        X(1,n) = static_cast<DNN_Dtype>(y);
    }
}

#ifdef SIGPACK_H
void scat_plot(arma::Mat<DNN_Dtype>& _X,arma::Mat<DNN_Dtype>& _T,int f1,int f2)
{
    sp::gplot gp0;
    std::ostringstream tmp_s;
    double xmin,xmax,ymin,ymax;
    xmin = _X.row(f1).min();
    xmax = _X.row(f1).max();
    ymin = _X.row(f2).min();
    ymax = _X.row(f2).max();

    gp0.window("Plot", 10, 10, 600, 600);
    gp0.xlim(xmin,xmax);
    gp0.ylim(ymin,ymax);

    for(arma::uword c = 0; c<_T.n_rows; c++)
    {
        arma::Mat<DNN_Dtype> XC = _X.cols(arma::find(_T.row(c)>0.9));
        arma::Row<DNN_Dtype> x = XC.row(f1);
        arma::Row<DNN_Dtype> y = XC.row(f2);
        gp0.plot_add(x,y," ","points ");
    }
    gp0.plot_show();
}
#endif // SIGPACK_H

uint32_t swap_endian(uint32_t i)
{
    uint32_t rev_i = 0;
    rev_i += (i & 0xff) << 24;
    rev_i += ((i >> 8) & 0xff) << 16;
    rev_i += ((i >> 16) & 0xff) << 8;
    rev_i += ((i >> 24) & 0xff);
    return rev_i;
}

bool read_idx3(std::string fname, arma::Cube<DNN_Dtype>& img, const double frac=1.0)
{
    uint32_t magic_number = 0;
    uint32_t number_of_images = 0;
    uint32_t number_of_rows = 0;
    uint32_t number_of_cols = 0;

    std::ifstream ifs;
    ifs.open(fname.c_str(), std::ios::binary);
    if (!ifs.good())
    {
        std::cout << "Could not open " << fname << std::endl;
        return false;
    }
    else
    {
        // Read Header IDX3
        ifs.seekg(0, std::ios::beg);
        ifs.read(reinterpret_cast<char*>(&magic_number), sizeof(magic_number));
        magic_number = swap_endian(magic_number);
        ifs.read(reinterpret_cast< char*>(&number_of_images), sizeof(number_of_images));
        number_of_images = swap_endian(number_of_images);
        ifs.read(reinterpret_cast<char*>(&number_of_rows), sizeof(number_of_rows));
        number_of_rows = swap_endian(number_of_rows);
        ifs.read(reinterpret_cast<char*>(&number_of_cols), sizeof(number_of_cols));
        number_of_cols = swap_endian(number_of_cols);

        arma::uword red_nr = static_cast<arma::uword>(floor(frac*number_of_images));
        // Create cube of images
        img.set_size(number_of_rows, number_of_cols, red_nr);

        // Fill with data
        for (arma::uword i = 0; i < red_nr; ++i)
        {
            for (arma::uword r = 0; r < number_of_rows; ++r)
            {
                for (arma::uword c = 0; c < number_of_cols; ++c)
                {
                    unsigned char tmp = 0;
                    ifs.read((char*)&tmp, sizeof(tmp));
                    img(r, c, i) = (DNN_Dtype)tmp;
                }
            }
        }
    }
    ifs.close();
    return true;
}

bool read_idx1(std::string fname, arma::ivec& label, const double frac=1.0)
{
    std::ifstream ifs;
    ifs.open(fname.c_str(), std::ifstream::binary);
    if (!ifs.good())
    {
        std::cout << "Could not open " << fname << std::endl;
        return false;
    }
    else
    {
        uint32_t magic_number = 0;
        uint32_t number_of_items = 0;

        // Read Header IDX1
        ifs.read(reinterpret_cast<char*>(&magic_number), 4);
        magic_number = swap_endian(magic_number);
        ifs.read(reinterpret_cast<char*>(&number_of_items),4);
        number_of_items = swap_endian(number_of_items);


        arma::uword red_nr = static_cast<arma::uword>(floor(frac*number_of_items));
        // Create vec of labels
        label.set_size(red_nr);
        for (arma::uword i = 0; i < red_nr; ++i)
        {
            unsigned char tmp = 0;
            ifs.read((char*)&tmp, sizeof(tmp));
            label(i) = (unsigned int)tmp;
        }
    }
    ifs.close();
    return true;
}

void read_MNIST(std::string fname_X, std::string fname_T, arma::Mat<DNN_Dtype>& X, arma::Mat<DNN_Dtype>& T,double frac=1.0)
{
    arma::Cube<DNN_Dtype> img;
    arma::ivec label;

    read_idx3(fname_X, img,frac);
    read_idx1(fname_T, label,frac);

    X.set_size(label.n_elem,img.n_elem_slice);
    X.zeros();
    T.set_size(label.n_elem,10);
    T.zeros();
    for(arma::uword n=0; n<label.n_elem; n++)
    {
        T(n,label(n)) = 1; // Map 0..9 to matrix
        arma::Mat<DNN_Dtype> xx = arma::vectorise(img.slice(n)).t();
        X.row(n) = xx/255;
    }
    //    cout << "Size= " << arma::size(img) << endl;
    arma::inplace_trans(X);
    arma::inplace_trans(T);
}

void progress_bar(const std::string str, double p)
{
    const int length = 20;
    const int update = 100/length;
    if(int(p*100)%update==0)
    {
        std::cout << str << " [";
        int pos = static_cast<int>(length * p);
        for (int i = 0; i < length; ++i)
        {
            if (i < pos)
                std::cout << "=";
            else if (i == pos)
                std::cout << ">";
            else
                std::cout << " ";
        }
        std::cout << "] " << int(p*100)+update << " %\r";
        std::cout.flush();
    }
}

void progress_bar(const std::string str, arma::uword num, arma::uword maxnum)
{
    progress_bar(str,double(num)/maxnum);
}

void remove_progress_bar(void)
{
// Erase line
#ifdef _WIN32
    std::cout << "\r                                                                \r";
#else
    std::cout << "\33[2K";
#endif
}
} // End namespace dnn