dnn_layer_cost.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_cost: public layer
{
protected:
    const arma::Mat<DNN_Dtype>*  data_labels;
    arma::Mat<DNN_Dtype>   T;
    arma::Mat<DNN_Dtype>   T1;
    arma::uword data_len;
    arma::uword data_ix;
public:
    layer_cost(void):layer()
    {
        type     = "Output";
        id       = type;
    }

    virtual void init(void)
    {
        layer::init();
        N_cols_right     = left->get_nrof_cols();
        N_rows_right     = left->get_nrof_rows();
        N_channels_right = left->get_nrof_channels();
        N_right          = N_cols_right*N_rows_right*N_channels_right;

        data_len = 0;
        data_ix  = 0;
    }

    virtual void upd_buf_size(arma::uword nmb)
    {
        N_batch = nmb;
        Y.    zeros(N_right, nmb);
        Y1.   zeros(N_right, 1);
        T.    zeros(N_right, nmb);
        T1.   zeros(N_right, 1);
        Dleft.zeros(N_left, nmb);
    }

    virtual arma::Mat<DNN_Dtype> get_T_1(void)
    {
        return T1;
    }

    virtual void set_data(const arma::Mat<DNN_Dtype>* data)
    {
        data_labels = data;
        data_len    = data->n_cols;
        data_ix     = 0;
    }

    virtual void reset_batch_ctr(void)
    {
        data_ix = 0;
    }

    virtual void prop(void)
    {
        arma::Mat<DNN_Dtype> X_1 = left->get_Y1();
        Y1 = X_1;
        T1 = data_labels->col(data_ix);
        data_ix++;
        if(data_ix >= data_len)
            data_ix = 0; // Wrap data
    }

    virtual void prop_mb(void)
    {
        Y = *(left->get_Y_ptr());
        if( (data_ix+N_batch)>=data_len )
        {
            // We are at the end, wrap data
            for (arma::uword k=0 ; k<N_batch ; k++ )
            {
                T.col(k) = data_labels->col(data_ix++);
                if(data_ix >= data_len)
                    data_ix = 0; // Wrap data
            }
        }
        else
        {
            T = data_labels->cols(data_ix,data_ix+N_batch-1);
            data_ix+=N_batch;
        }
    }

    virtual void backprop(void)=0;
    virtual DNN_Dtype get_cost(void) =0;

    virtual DNN_Dtype get_acc(void)
    {
        arma::uword res=0;
        for(arma::uword n=0; n<N_batch; n++)
        {
            arma::uword A=Y.col(n).index_max();
            arma::uword B=T.col(n).index_max();
            if(A==B)
            {
                res++;
            }
        }
        return res/DNN_Dtype(N_batch);
    }

    virtual void disp(void)
    {
        layer::disp();
        std::cout << "Nr of classes:        " << get_nrof_outputs() << std::endl;
    }

}; // End class layer_cost


class cost_MSE: public layer_cost
{
public:
    cost_MSE(void):layer_cost()
    {
        id = type+" MSE";
    }

    void backprop(void)
    {
        Dleft  = Y-T;
    }

    DNN_Dtype get_cost(void)
    {
        return (DNN_Dtype)0.5*arma::accu((Y-T)%(Y-T))/DNN_Dtype(N_batch);
    }

    void disp(void)
    {
        layer_cost::disp();
        std::cout << "Loss function:        MSE" << std::endl;
    }

}; // End class cost_MSE

class cost_MSE_sigmoid: public layer_cost
{
public:
    cost_MSE_sigmoid(void):layer_cost()
    {
        id = type+" MSE sigm";
    }

    void prop(void)
    {
        arma::Mat<DNN_Dtype> X_1 = left->get_Y1();
        Y1 = sigmoid(X_1);
        T1 = data_labels->col(data_ix);
        data_ix++;
        if(data_ix >= data_len)
            data_ix = 0; // Wrap data
    }

    void prop_mb(void)
    {
        Y = sigmoid(*(left->get_Y_ptr()));

        if( (data_ix+N_batch)>=data_len )
        {
            // We are at the end, wrap data
            for (arma::uword k=0 ; k<N_batch ; k++ )
            {
                T.col(k) = data_labels->col(data_ix++);
                if(data_ix >= data_len)
                    data_ix = 0; // Wrap data
            }
        }
        else
        {
            T = data_labels->cols(data_ix,data_ix+N_batch-1);
            data_ix+=N_batch;
        }
    }

    void backprop(void)
    {
        Dleft  = sigmoid(*(left->get_Y_ptr()))%(1-sigmoid(*(left->get_Y_ptr())))%(Y-T);
    }

    DNN_Dtype get_cost(void)
    {
        return (DNN_Dtype)0.5*arma::accu((Y-T)%(Y-T))/DNN_Dtype(N_batch);
    }

    void disp(void)
    {
        layer_cost::disp();
        std::cout << "Loss function:        MSE" << std::endl;
    }

}; // End class cost_MSE_sigmoid


class cost_CE: public layer_cost
{
public:
    cost_CE(void):layer_cost()
    {
        id = type+" CE cost";
    }

    void prop(void)
    {
        arma::Mat<DNN_Dtype> X_1 = left->get_Y1();
        Y1 = X_1;
        T1 = data_labels->col(data_ix);
        data_ix++;
        if(data_ix == data_len)
            data_ix = 0; // Wrap data
    }

    void prop_mb(void)
    {
        Y = *(left->get_Y_ptr());
        if( (data_ix+N_batch)>=data_len )
        {
            // We are at the end, wrap data
            for (arma::uword k=0 ; k<N_batch ; k++ )
            {
                T.col(k) = data_labels->col(data_ix++);
                if(data_ix >= data_len)
                    data_ix = 0; // Wrap data
            }
        }
        else
        {
            T = data_labels->cols(data_ix,data_ix+N_batch-1);
            data_ix+=N_batch;
        }
    }

    void backprop(void)
    {
        Dleft  = Y-T;
    }

    DNN_Dtype get_cost(void)
    {
        return -arma::sum(arma::sum(T%arma::trunc_log(Y),0))/DNN_Dtype(N_batch);
    }

    void disp(void)
    {
        layer_cost::disp();
        std::cout << "Loss function:        CE with softmax activation" << std::endl;
    }
}; // End class cost_CE


class cost_CE_sigmoid: public layer_cost
{
public:
    cost_CE_sigmoid(void):layer_cost()
    {
        id = type+" CE sigm";
    }

    void prop(void)
    {
        arma::Mat<DNN_Dtype> X_1 = left->get_Y1();
        Y1 = sigmoid(X_1);
        T1 = data_labels->col(data_ix);
        data_ix++;
        if(data_ix == data_len)
            data_ix = 0; // Wrap data
    }

    void prop_mb(void)
    {
        Y = sigmoid(*(left->get_Y_ptr()));

        if( (data_ix+N_batch)>=data_len )
        {
            // We are at the end, wrap data
            for (arma::uword k=0 ; k<N_batch ; k++ )
            {
                T.col(k) = data_labels->col(data_ix++);
                if(data_ix >= data_len)
                    data_ix = 0; // Wrap data
            }
        }
        else
        {
            T = data_labels->cols(data_ix,data_ix+N_batch-1);
            data_ix+=N_batch;
        }
    }

    void backprop(void)
    {
        Dleft  = Y-T;
    }

    DNN_Dtype get_cost(void)
    {
        DNN_Dtype cost=0;
        for (arma::uword c=0 ; c<T.n_cols ; c++ )
        {
            for (arma::uword r=0 ; r<T.n_rows ; r++ )
            {
                if(T(r,c))
                    cost+= -arma::trunc_log(Y.at(r,c));
                else
                    cost+= -arma::trunc_log(1-Y.at(r,c));
            }
        }
        cost/=DNN_Dtype(N_batch);
        return cost;
    }

    void disp(void)
    {
        layer_cost::disp();
        std::cout << "Loss function:        CE with sigmoid activation" << std::endl;
    }

}; // End class cost_CE_sigmoid


class cost_CE_softmax: public layer_cost
{
public:
    cost_CE_softmax(void):layer_cost()
    {
        id = type+" CE softmax";
    }

    void prop(void)
    {
        arma::Mat<DNN_Dtype> X_1 = left->get_Y1();
        Y1 = softmax(X_1);
        T1 = data_labels->col(data_ix);
        data_ix++;
        if(data_ix == data_len)
            data_ix = 0; // Wrap data
    }

    void prop_mb(void)
    {
        Y = softmax(*(left->get_Y_ptr()));
        if( (data_ix+N_batch)>=data_len )
        {
            // We are at the end, wrap data
            for (arma::uword k=0 ; k<N_batch ; k++ )
            {
                T.col(k) = data_labels->col(data_ix++);
                if(data_ix >= data_len)
                    data_ix = 0; // Wrap data
            }
        }
        else
        {
            T = data_labels->cols(data_ix,data_ix+N_batch-1);
            data_ix+=N_batch;
        }
    }

    void backprop(void)
    {
        Dleft  = Y-T;
    }

    DNN_Dtype get_cost(void)
    {
        return -arma::sum(arma::sum(T%arma::trunc_log(Y),0))/DNN_Dtype(N_batch);
    }

    void disp(void)
    {
        layer_cost::disp();
        std::cout << "Loss function:        CE with softmax activation" << std::endl;
    }
}; // End class cost_CE_softmax
} // End namespace dnn