dnn_layer_pool.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_pool: public layer
{
protected:
    arma::uword N_block;               
    arma::uword N_stride;              
//    arma::uword N_pad;                 ///< Padding
//    arma::Mat<DNN_Dtype> C;            ///< Input expanded by im2col
    arma::Mat<DNN_Dtype> mask;         
public:
//    layer_pool(const arma::uword n_block, const arma::uword n_stride, const arma::uword n_pad):layer()

    layer_pool(const arma::uword n_block):layer()
    {
        N_block       = n_block;
        N_stride      = N_block;//n_stride;
//        N_pad         = n_pad;
        type          = "Pool";
        id            = type;
    }

    virtual void init(void)
    {
        layer::init();

        N_channels_right = left->get_nrof_channels();
        N_cols_right     = (left->get_nrof_cols()-N_block)/N_stride + 1;
        N_rows_right     = (left->get_nrof_rows()-N_block)/N_stride + 1;
        N_right          = N_cols_right*N_rows_right*N_channels_right;

//        C.     set_size(N_block*N_block*N_channels_right,N_rows_right*N_cols_right);
    }

    virtual void upd_buf_size(arma::uword nmb)
    {
        layer::upd_buf_size(nmb);
        mask.zeros(N_left,nmb);
    }

    virtual void prop(void) =0;
    virtual void prop_mb(void) =0;
    virtual void backprop(void) =0;

    virtual void disp(void)
    {
        layer::disp();
        std::cout << "Pool Rate:            " << N_block << std::endl;
        std::cout << "Stride:               " << N_stride << std::endl;
//        std::cout << "Padding:              " << N_pad << std::endl;
        std::cout << "Nr of outputs:        " << get_nrof_outputs() << " ["<< N_rows_right << ","<<N_cols_right<<","<< N_channels_right<<"]"<< std::endl;
    }

    void upsamp2(const arma::Mat<DNN_Dtype>& Src, arma::Mat<DNN_Dtype>& Dst,arma::uword N)
    {
        const arma::uword Rin  = Src.n_rows;
        const arma::uword Cin  = Src.n_cols;

        DNN_Dtype * Dst_ptr=Dst.memptr();

        for (arma::uword c=0 ; c<Cin ; c++ )
        {
            for (arma::uword k=0 ; k<N ; k++ )
            {
                for (arma::uword r=0 ; r<Rin ; r++ )
                {
                    const DNN_Dtype px = Src.at(r,c);
                    for (arma::uword n=0 ; n<N ; n++ )
                    {
                        *(Dst_ptr++)=px;
                    }
                }
            }
        }
    }

    void upsamp2(const arma::Cube<DNN_Dtype>& Src,arma::Cube<DNN_Dtype>& Dst, const arma::uword N)
    {
        for (arma::uword l=0 ; l<Src.n_slices ; l++ )
        {
            upsamp2(Src.slice(l),Dst.slice(l),N);
        }
    }

}; // End class layer_pool

class pool_max: public layer_pool
{
public:
//    pool_max(const arma::uword n_block,const arma::uword n_stride,const arma::uword n_pad):layer_pool(n_block,n_stride,n_pad)

    pool_max(const arma::uword n_block):layer_pool(n_block)
    {
        N_block = n_block;
        N_stride      = N_block;//n_stride;
//        N_pad         = n_pad;
        type          = "MAXpool";
        id            = type+"("+std::to_string(N_block)+","+std::to_string(N_block)+")";
    }

    void prop(void)
    {
        arma::Mat<DNN_Dtype> Dst(N_rows_right, N_cols_right, arma::fill::zeros);
        DNN_Dtype* Y_ptr;
        Y_ptr = Y1.memptr();
        arma::Cube<DNN_Dtype> Src(left->get_Y1_memptr(), N_rows_left, N_cols_left, N_channels_left, false, true);
        for (arma::uword l = 0; l < N_channels_left; l++)
        {
            for (arma::uword c = 0; c <= N_cols_left - N_block; c += N_block)
            {
                for (arma::uword r = 0; r <= N_rows_left - N_block; r += N_block)
                {
                    DNN_Dtype mx = Src.at(r,c,l);
                    for (arma::uword ir = 0; ir < N_block; ir++)
                    {
                        for (arma::uword ic = 0; ic < N_block; ic++)
                        {
                            DNN_Dtype px = Src.at(r + ir, c + ic, l);
                            if (px >= mx)
                            {
                                mx = px;
                            }
                        }
                    }
                    *Y_ptr++ = mx;
                }
            }
        }
    }

    void prop_mb(void)
    {
        arma::Mat<DNN_Dtype> Dst(N_rows_right, N_cols_right, arma::fill::zeros);
        arma::Mat<DNN_Dtype> mask_mat(N_rows_left,N_cols_left, arma::fill::zeros);
        mask.zeros();    // Init mask
        DNN_Dtype* Y_ptr;
        for (arma::uword n = 0; n < N_batch; n++)
        {
            Y_ptr = Y.colptr(n);
            arma::Cube<DNN_Dtype> Src(left->get_Y_colptr(n), N_rows_left,N_cols_left, N_channels_left,false,true);
            for (arma::uword l = 0; l < N_channels_left; l++)
            {
                for (arma::uword c = 0; c <= N_cols_left - N_block; c += N_block)
                {
                    for (arma::uword r = 0; r <= N_rows_left - N_block; r += N_block)
                    {
                        arma::uword r_offs=0, c_offs=0;
                        DNN_Dtype mx = Src.at(r,c,l);
                        for (arma::uword ir = 0; ir < N_block; ir++)
                        {
                            for (arma::uword ic = 0; ic < N_block; ic++)
                            {
                                DNN_Dtype px = Src.at(r+ir, c+ic, l);
                                if (px >= mx)
                                {
                                    mx = px;
                                    r_offs = ir;
                                    c_offs = ic;
                                }
                            }
                        }
                        *Y_ptr++ = mx;
                        mask.at(l*N_rows_left*N_cols_left +(c+c_offs)*N_rows_left+r+r_offs, n) = 1;
                    }
                }
            }
        }
    }

    void backprop(void)
    {
        arma::Cube<DNN_Dtype> ttt(N_rows_right*N_block,N_cols_right*N_block,N_channels_right);
        for (arma::uword n=0; n<N_batch; n++)
        {
            arma::Cube<DNN_Dtype> blob(right->get_Dleft_colptr(n),N_rows_right,N_cols_right,N_channels_right,false,true);
            upsamp2(blob,ttt,N_block);
            Dleft.col(n) = cube2mat(ttt,ttt.n_elem,1)%mask.col(n);
        }
    }

}; // End class pool_max

class pool_average: public layer_pool
{
public:
//    pool_average(const arma::uword n_block,const arma::uword n_stride,const arma::uword n_pad):layer_pool(n_block,n_stride,n_pad)
    pool_average(const arma::uword n_block):layer_pool(n_block)
    {
        N_block = n_block;
//        N_stride      = n_stride;
//        N_pad         = n_pad;
        type          = "AVGpool";
        id            = type+"("+std::to_string(N_block)+","+std::to_string(N_block)+")";
    }

    void prop(void)
    {
        arma::Mat<DNN_Dtype> Dst(N_rows_right,N_cols_right, arma::fill::zeros);
        arma::Mat<DNN_Dtype> X_1 = left->get_Y1();
        arma::Cube<DNN_Dtype> Src_cube(X_1.memptr(),N_rows_left,N_cols_left,N_channels_left);
        for (arma::uword l=0 ; l<Src_cube.n_slices; l++ )
        {
            arma::Mat<DNN_Dtype> Src_mat=Src_cube.slice(l);
            arma::Mat<DNN_Dtype> mask_mat(arma::size(Src_mat),arma::fill::zeros);
            for (arma::uword c=0 ; c<N_cols_left-N_block ; c+=N_block )
            {
                for (arma::uword r=0 ; r<N_rows_left-N_block ; r+=N_block )
                {
                    arma::Mat<DNN_Dtype> dd=Src_mat(r,c,arma::size(N_block,N_block));
                    Dst(r/N_block,c/N_block) = dd.max();
                }
            }
            Y1.rows(l*Dst.n_elem,(l+1)*Dst.n_elem-1) = mat2mat(Dst,Dst.n_elem,1);
        }
    }

    void prop_mb(void)
    {
        arma::Mat<DNN_Dtype> Dst(N_rows_right, N_cols_right, arma::fill::zeros);
        DNN_Dtype* Y_ptr;
        const DNN_Dtype nn=(DNN_Dtype)1.0/(N_block*N_block);
        for (arma::uword n = 0; n < N_batch; n++)
        {
            Y_ptr = Y.colptr(n);
            arma::Cube<DNN_Dtype> Src(left->get_Y_colptr(n), N_rows_left,N_cols_left, N_channels_left,false,true);
            for (arma::uword l = 0; l < N_channels_left; l++)
            {
                for (arma::uword c = 0; c <= N_cols_left - N_block; c += N_block)
                {
                    for (arma::uword r = 0; r <= N_rows_left - N_block; r += N_block)
                    {
                        DNN_Dtype av=0;
                        for (arma::uword ir = 0; ir < N_block; ir++)
                        {
                            for (arma::uword ic = 0; ic < N_block; ic++)
                            {
                                av += Src.at(r+ir, c+ic, l);
                            }
                        }
                        *Y_ptr++ = av*nn;
                    }
                }
            }
        }
    }

    void backprop(void)
    {
        arma::Cube<DNN_Dtype> ttt(N_rows_right*N_block,N_cols_right*N_block,N_channels_right);
        const DNN_Dtype nn = (DNN_Dtype)1.0/(N_block*N_block);
        for (arma::uword n=0; n<N_batch; n++)
        {
            arma::Cube<DNN_Dtype> blob(right->get_Dleft_colptr(n),N_rows_right,N_cols_right,N_channels_right,false,true);
            upsamp2(blob,ttt,N_block);
            Dleft.col(n) = cube2mat(ttt,ttt.n_elem,1)*nn;
        }
    }
}; // End class pool_average
} // End namespace dnn