HingeLossLayer.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 HingeLossLayer<T> : LossLayer<T>
    {
        public HingeLossLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.HINGE_LOSS;
        }
 
        protected override void dispose()
        {
            base.dispose();
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            long hBottomData = colBottom[0].gpu_data;
            long hBottomDiff = colBottom[0].mutable_gpu_diff;
            int nNum = colBottom[0].num;
            int nCount = colBottom[0].count();
            int nDim = nCount / nNum;
 
            m_cuda.copy(nCount, hBottomData, hBottomDiff);
 
            T[] rgBottomDiff = colBottom[0].mutable_cpu_diff;
            T[] rgLabel = colBottom[1].update_cpu_data();
 
            if (typeof(T) == typeof(double))
            {
                double[] rgBottomDiffD = (double[])Convert.ChangeType(rgBottomDiff, typeof(double[]));
                double[] rgLabelD = (double[])Convert.ChangeType(rgLabel, typeof(double[]));
 
                for (int i = 0; i < nNum; i++)
                {
                    rgBottomDiffD[i * nDim + (int)rgLabelD[i]] *= -1;
                }
                for (int i = 0; i < nNum; i++)
                {
                    for (int j = 0; j < nDim; j++)
                    {
                        int nIdx = i * nDim + j;
                        double dfDiff = rgBottomDiffD[nIdx];
                        rgBottomDiffD[nIdx] = Math.Max(0.0, 1.0 + dfDiff);
                    }
                }
            }
            else
            {
                float[] rgBottomDiffF = (float[])Convert.ChangeType(rgBottomDiff, typeof(float[]));
                float[] rgLabelF = (float[])Convert.ChangeType(rgLabel, typeof(float[]));
 
                for (int i = 0; i < nNum; i++)
                {
                    rgBottomDiffF[i * nDim + (int)rgLabelF[i]] *= -1;
                }
                for (int i = 0; i < nNum; i++)
                {
                    for (int j = 0; j < nDim; j++)
                    {
                        int nIdx = i * nDim + j;
                        float fDiff = rgBottomDiffF[nIdx];
                        rgBottomDiffF[nIdx] = Math.Max(0.0f, 1.0f + fDiff);
                    }
                }
            }
 
            colBottom[0].mutable_cpu_diff = rgBottomDiff;
 
            double dfLoss = 0;
            switch (m_param.hinge_loss_param.norm)
            {
                case HingeLossParameter.Norm.L1:
                    dfLoss = convertD(m_cuda.asum(nCount, hBottomDiff)) / nNum;
                    break;
 
                case HingeLossParameter.Norm.L2:
                    dfLoss = convertD(m_cuda.dot(nCount, hBottomDiff, hBottomDiff)) / nNum;
                    break;
 
                default:
                    m_log.FAIL("Unknown norm in HingeLoss!");
                    break;
            }
 
            colTop[0].SetData(dfLoss, 0);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (rgbPropagateDown[1])
                m_log.FAIL(type.ToString() + " Layer cannot backpropagate to label inputs.");
 
            if (rgbPropagateDown[0])
            {
                long hBottomDiff = colBottom[0].mutable_gpu_diff;
                int nNum = colBottom[0].num;
                int nCount = colBottom[0].count();
                int nDim = nCount / nNum;
 
                T[] rgBottomDiff = colBottom[0].mutable_cpu_diff;
                T[] rgLabel = colBottom[1].update_cpu_data();
 
                if (typeof(T) == typeof(double))
                {
                    double[] rgBottomDiffD = (double[])Convert.ChangeType(rgBottomDiff, typeof(double[]));
                    double[] rgLabelD = (double[])Convert.ChangeType(rgLabel, typeof(double[]));
 
                    for (int i = 0; i < nNum; i++)
                    {
                        rgBottomDiffD[i * nDim + (int)rgLabelD[i]] *= -1;
                    }
                }
                else
                {
                    float[] rgBottomDiffF = (float[])Convert.ChangeType(rgBottomDiff, typeof(float[]));
                    float[] rgLabelF = (float[])Convert.ChangeType(rgLabel, typeof(float[]));
 
                    for (int i = 0; i < nNum; i++)
                    {
                        rgBottomDiffF[i * nDim + (int)rgLabelF[i]] *= -1;
                    }
                }
 
                colBottom[0].mutable_cpu_diff = rgBottomDiff;
 
                double dfLossWeight = convertD(colTop[0].GetDiff(0));
                switch (m_param.hinge_loss_param.norm)
                {
                    case HingeLossParameter.Norm.L1:
                        m_cuda.sign(nCount, hBottomDiff, hBottomDiff);
                        m_cuda.scal(nCount, dfLossWeight / nNum, hBottomDiff);
                        break;
 
                    case HingeLossParameter.Norm.L2:
                        m_cuda.scal(nCount, dfLossWeight * 2 / nNum, hBottomDiff);
                        break;
 
                    default:
                        m_log.FAIL("Unknown norm in HingeLoss!");
                        break;
                }
            }
        }
    }
}