ExpLayer.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 ExpLayer<T> : NeuronLayer<T>
    {
        double m_dfInnerScale;
        double m_dfOuterScale;
 
        public ExpLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.EXP;
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.LayerSetUp(colBottom, colTop);
 
            double dfBase = m_param.exp_param.base_val;
 
            if (dfBase != -1)
                m_log.CHECK_GT(dfBase, 0, "base_val must be strictly positive.");
 
            // If base == -1, interpret the base as e and set log_base = 1 exactly.
            // Otehrwise, calculate its log explicitly.
            double dfLogBase = (dfBase == -1) ? 1 : Math.Log(dfBase);
 
            m_log.CHECK(!double.IsNaN(dfLogBase), "NaN result: log(base) == log(" + dfBase.ToString() + ") = " + dfLogBase.ToString());
            m_log.CHECK(!double.IsInfinity(dfLogBase), "Inf result: log(base) == log(" + dfBase.ToString() + ") = " + dfLogBase.ToString());
 
            double dfInputScale = m_param.exp_param.scale;
            double dfInputShift = m_param.exp_param.shift;
 
            m_dfInnerScale = dfLogBase * dfInputScale;
            m_dfOuterScale = (dfInputShift == 0) ? 1 : ((dfBase != -1) ? Math.Pow(dfBase, dfInputShift) : Math.Exp(dfInputShift));
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nCount = colBottom[0].count();
            long hBottomData = colBottom[0].gpu_data;
            long hTopData = colTop[0].mutable_gpu_data;
 
            if (m_dfInnerScale == 1)
            {
                m_cuda.exp(nCount, hBottomData, hTopData);
            }
            else
            {
                m_cuda.scale(nCount, convert(m_dfInnerScale), hBottomData, hTopData);
                m_cuda.exp(nCount, hTopData, hTopData);
            }
 
            if (m_dfOuterScale != 1)
                m_cuda.scal(nCount, convert(m_dfOuterScale), hTopData);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (!rgbPropagateDown[0])
                return;
 
            int nCount = colBottom[0].count();
            long hTopData = colTop[0].gpu_data;
            long hTopDiff = colTop[0].gpu_diff;
            long hBottomDiff = colBottom[0].mutable_gpu_diff;
 
            m_cuda.mul(nCount, hTopData, hTopDiff, hBottomDiff);
 
            if (m_dfInnerScale != 1)
                m_cuda.scal(nCount, convert(m_dfInnerScale), hBottomDiff);
        }
    }
}