EuclideanLossLayer.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
{
    public class EuclideanLossLayer<T> : LossLayer<T>
    {
        Blob<T> m_blobDiff;
 
        public EuclideanLossLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.EUCLIDEAN_LOSS;
            m_blobDiff = new Blob<T>(cuda, log);
            m_blobDiff.Name = m_param.name + " diff";
        }
 
        protected override void dispose()
        {
            m_blobDiff.Dispose();
            base.dispose();
        }
 
        public override bool AllowForceBackward(int nBottomIdx)
        {
            return true;
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.LayerSetUp(colBottom, colTop);
 
            // Setup the convert to half flags used by the Layer just before calling forward and backward.
            m_bUseHalfSize = m_param.use_halfsize;
            m_bConvertTopOnBwd = false;
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.Reshape(colBottom, colTop);
 
            m_log.CHECK_EQ(colBottom[0].count(1), colBottom[1].count(1), "Inputs must have the same dimension.");
            m_blobDiff.ReshapeLike(colBottom[0], colBottom[0].HalfSize);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nCount = colBottom[0].count();
            long hData = m_blobDiff.gpu_data;
 
            m_cuda.sub(nCount, colBottom[0].gpu_data, colBottom[1].gpu_data, hData);
 
            if (m_blobDiff.HalfSize)
                hData = convert_to_full(nCount, hData);
 
            T fDot = m_cuda.dot(nCount, hData, hData);
            double dfLoss = convertD(fDot) / colBottom[0].num / 2.0;
 
            colTop[0].SetData(dfLoss, 0);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            for (int i = 0; i < 2; i++)
            {
                if (rgbPropagateDown[i])
                {
                    double dfSign = (i == 0) ? 1 : -1;
                    double dfTopDiff = convertD(colTop[0].GetDiff(0));
                    double dfAlpha = dfSign * dfTopDiff / colBottom[i].num;
                    int nCount = colBottom[i].count();
 
                    m_cuda.axpby(nCount, convert(dfAlpha), m_blobDiff.gpu_data, m_tZero, colBottom[i].mutable_gpu_diff);
                }
            }
        }
    }
}