dnn_layer_dense.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
{

class layer_dense: public layer
{
private:
public:
    layer_dense(const arma::uword n_rows):layer()
    {
        N_cols_right     = 1;
        N_rows_right     = n_rows;
        N_channels_right = 1;
        N_right          = N_rows_right;
        type             = "Dense";
        id               = type+"("+std::to_string(N_left)+","+std::to_string(N_right)+")";
    }


    void init(void)
    {
        layer::init();
        W.set_size(N_right, N_left,1);
        B.set_size(N_right, 1);
        id        = type+"("+std::to_string(N_left)+","+std::to_string(N_right)+")";
        train_par = true;

        // Init W and B
        init_weights(W,N_left,N_right,INIT_W_ALG::XAVIER,INIT_W_DIST::NORMAL);
        B.zeros();
    }

    void prop(void)
    {
        Y1 = W.slice(0)*(left->get_Y1());
        if(add_bias) Y1+= B;
    }

    void prop_mb(void)
    {
        Y =  W.slice(0)*(*(left->get_Y_ptr()));
        if(add_bias) Y.each_col()+=B;
    }

    void backprop(void)
    {
        Dleft  = (W.slice(0).t())*(*(right->get_Dleft_ptr()));
    }

    void update(void)
    {
        if(train_par==true)
        {
            const DNN_Dtype nrm = (DNN_Dtype) 1.0/N_batch;
            arma::Cube<DNN_Dtype> a(arma::size(W));
            a.slice(0)=(*(right->get_Dleft_ptr())*(*(left->get_Y_ptr())).t())*nrm;

            if(add_bias)
            {
                opt_alg->apply(W,B,a,sum(*(right->get_Dleft_ptr()),1)*nrm);
            }
            else
            {
                arma::Mat<DNN_Dtype> m={1.0};
                opt_alg->apply(W,m,a,m);
            }
        }
    }

    arma::uword get_nrof_params(void)
    {
        return N_left*N_right+N_right;
    }

    void disp(void)
    {
        layer::disp();
        std::cout << "Opt algorithm:        " << opt_alg->get_algorithm() << std::endl;
        std::cout << "Nr of inputs:         " << get_nrof_inputs() << std::endl;
        std::cout << "Nr of outputs:        " << get_nrof_outputs() << std::endl;
    }

    arma::Mat<DNN_Dtype> weights2img(const arma::uword R, const arma::uword C)
    {
        const arma::uword Nimg  = W.slice(0).n_elem/(R*C);
        const arma::uword PR = static_cast<arma::uword>(floor(sqrt(Nimg)));
        const arma::uword PC = static_cast<arma::uword>(ceil(Nimg/(1.0*PR)));
        arma::Mat<DNN_Dtype> ZZ(PR*R,PC*C,arma::fill::zeros);

        arma::Col<DNN_Dtype> Iv=arma::vectorise(W.slice(0).t());

        arma::uword r=0,c=0;
        DNN_Dtype *iptr=Iv.memptr();
        for(arma::uword m=0; m<Nimg; m++)
        {
            const arma::Mat<DNN_Dtype> Z(iptr,R,C);
            iptr+=R*C;
            ZZ(r,c,arma::size(R,C)) = Z+B(m);
            c+=C;
            if(c >= PC*C)
            {
                r+=R;
                c=0;
            }
        }
        return ZZ;
    }

}; // End class layer_dense
} // End namespace dnn