MeanErrorLossLayer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.common;
using MyCaffe.param;
using MyCaffe.param.beta;
 
namespace MyCaffe.layers.beta
{
    public class MeanErrorLossLayer<T> : LossLayer<T>
    {
        int m_nAxis = 1;
        MEAN_ERROR m_meanType = MEAN_ERROR.MAE;
        Blob<T> m_blobWork;
 
        public MeanErrorLossLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.MEAN_ERROR_LOSS;
            m_nAxis = p.mean_error_loss_param.axis;
            m_meanType = p.mean_error_loss_param.mean_error_type;
 
            m_blobWork = new Blob<T>(cuda, log);
        }
 
        protected override void dispose()
        {
            if (m_blobWork != null)
            {
                m_blobWork.Dispose();
                m_blobWork = null;
            }
 
            base.dispose();
        }
 
        public override int ExactNumTopBlobs
        {
            get { return -1; }
        }
 
        public override int MinTopBlobs
        {
            get { return 1; }
        }
 
        public override int MaxTopBlobs
        {
            get { return 1; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.LayerSetUp(colBottom, colTop);
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.Reshape(colBottom, colTop);
 
            m_blobWork.ReshapeLike(colBottom[0]);
 
            if (m_nOuterNum == 0)
                m_nOuterNum = (int)colBottom[0].count(0, m_nAxis);
 
            if (m_nInnerNum == 0)
                m_nInnerNum = colBottom[0].count(m_nAxis);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            long hPredicted = colBottom[0].gpu_data;
            long hTarget = colBottom[1].gpu_data;
            int nCount = colBottom[0].count();
 
            double dfLoss = 0;
 
            m_log.CHECK_EQ(nCount, colBottom[1].count(), "The bottom(0) predicted and bottom(1) target must have the same shapes!");
 
            switch (m_meanType)
            {
                case MEAN_ERROR.MSE:
                    m_cuda.sub(nCount, hTarget, hPredicted, colBottom[0].mutable_gpu_diff);
                    m_cuda.powx(nCount, colBottom[0].gpu_diff, 2.0, colBottom[0].mutable_gpu_diff);
                    dfLoss = m_cuda.asum_double(nCount, colBottom[0].gpu_diff);
                    break;
 
                case MEAN_ERROR.MAE:
                    m_cuda.sub(nCount, hTarget, hPredicted, colBottom[0].mutable_gpu_diff);
                    m_cuda.abs(nCount, colBottom[0].gpu_diff, colBottom[0].mutable_gpu_diff);
                    dfLoss = m_cuda.asum_double(nCount, colBottom[0].gpu_diff);
                    break;
            }
 
            double dfNormalizer = get_normalizer(m_normalization, -1);
            colTop[0].SetData(dfLoss / dfNormalizer, 0);
 
            // Clear scratch memory to prevent with interfering with backward pass (see #602)
            colBottom[0].SetDiff(0);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (!rgbPropagateDown[0])
                return;
 
            long hPredicted = colBottom[0].gpu_data;
            long hTarget = colBottom[1].gpu_data;
            long hBottomDiff = colBottom[0].mutable_gpu_diff;
            int nCount = colBottom[0].count();
 
            m_cuda.mean_error_loss_bwd(nCount, hPredicted, hTarget, hBottomDiff, m_meanType);
 
            double dfTopDiff = convertD(colTop[0].GetDiff(0));
            double dfNormalizer = get_normalizer(m_normalization, -1);
            double dfLossWeight = dfTopDiff / dfNormalizer;
 
            m_cuda.scal(nCount, dfLossWeight, hBottomDiff);
 
            if (colBottom.Count > 1)
            {
                long hBottomDiff2 = colBottom[1].mutable_gpu_diff;
                m_cuda.scale(nCount, -1, hBottomDiff, hBottomDiff2);
            }
        }
    }
}