SmoothL1LossLayer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.common;
using MyCaffe.param;
 
namespace MyCaffe.layers.ssd
{
    public class SmoothL1LossLayer<T> : LossLayer<T>
    {
        Blob<T> m_blobDiff;
        Blob<T> m_blobErrors;
        bool m_bHasWeights;
 
        public SmoothL1LossLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.SMOOTHL1_LOSS;
 
            m_blobDiff = new Blob<T>(cuda, log, false);
            m_blobDiff.Name = m_param.name + " diff";
            m_blobErrors = new Blob<T>(cuda, log, false);
            m_blobErrors.Name = m_param.name + " errors";
 
            m_bHasWeights = false;
        }
 
        protected override void dispose()
        {
            if (m_blobDiff != null)
            {
                m_blobDiff.Dispose();
                m_blobDiff = null;
            }
 
            if (m_blobErrors != null)
            {
                m_blobErrors.Dispose();
                m_blobErrors = null;
            }
 
            base.dispose();
        }
 
        protected override void setup_internal_blobs(BlobCollection<T> col)
        {
            if (col.Count > 0)
                return;
 
            col.Add(m_blobDiff);
            col.Add(m_blobErrors);
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return -1; }
        }
 
        public override int MinBottomBlobs
        {
            get { return 2; }
        }
 
        public override int MaxBottomBlobs
        {
            get { return 3; }
        }
 
        public override bool AllowForceBackward(int nBottomIdx)
        {
            return true;
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.LayerSetUp(colBottom, colTop);
 
            if (colBottom.Count == 3)
                m_bHasWeights = true;
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.Reshape(colBottom, colTop);
 
            m_log.CHECK_EQ(colBottom[0].channels, colBottom[1].channels, "The bottom(0) and bottom(1) must have the same channels.");
            m_log.CHECK_EQ(colBottom[0].height, colBottom[1].height, "The bottom(0) and bottom(1) must have the same height.");
            m_log.CHECK_EQ(colBottom[0].width, colBottom[1].width, "The bottom(0) and bottom(1) must have the same width.");
 
            if (m_bHasWeights)
            {
                m_log.CHECK_EQ(colBottom[0].channels, colBottom[2].channels, "The bottom(0) and bottom(2) must have the same channels.");
                m_log.CHECK_EQ(colBottom[0].height, colBottom[2].height, "The bottom(0) and bottom(2) must have the same height.");
                m_log.CHECK_EQ(colBottom[0].width, colBottom[2].width, "The bottom(0) and bottom(2) must have the same width.");
            }
 
            m_blobDiff.ReshapeLike(colBottom[0]);
            m_blobErrors.ReshapeLike(colBottom[0]);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nCount = colBottom[0].count();
 
            // d := b0 - b1
            m_cuda.sub(nCount, colBottom[0].gpu_data, colBottom[1].gpu_data, m_blobDiff.mutable_gpu_data);
 
            // d := w * (b0 - b1)
            if (m_bHasWeights)
                m_cuda.mul(nCount, colBottom[2].gpu_data, m_blobDiff.gpu_data, m_blobDiff.mutable_gpu_data);
 
            m_cuda.smoothl1_fwd(nCount, m_blobDiff.gpu_data, m_blobErrors.mutable_gpu_data);
 
            double dfLoss = Utility.ConvertVal<T>(m_blobErrors.asum_data());
            colTop[0].SetData(dfLoss / colBottom[0].num, 0);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            int nCount = m_blobDiff.count();
 
            m_cuda.smoothl1_bwd(nCount, m_blobDiff.gpu_data, m_blobDiff.mutable_gpu_data);
 
            for (int i = 0; i < 2; i++)
            {
                if (rgbPropagateDown[i])
                {
                    double dfSign = (i == 0) ? 1 : -1;
                    double dfAlpha = Utility.ConvertVal<T>(colTop[0].GetDiff(0));
 
                    dfAlpha = dfSign * dfAlpha / colBottom[i].num;
                    m_cuda.axpby(colBottom[i].count(), dfAlpha, m_blobDiff.gpu_data, 0.0, colBottom[i].mutable_gpu_diff);
                }
            }
        }
    }
}