PowerLayer.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 PowerLayer<T> : NeuronLayer<T>
    {
        double m_dfPower;
        double m_dfScale;
        double m_dfShift;
        double m_dfDiffScale;
 
        public PowerLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.POWER;
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            base.LayerSetUp(colBottom, colTop);
 
            m_dfPower = m_param.power_param.power;
            m_dfScale = m_param.power_param.scale;
            m_dfShift = m_param.power_param.shift;
            m_dfDiffScale = m_dfPower * m_dfScale;
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            // Special case where we can ignore the input: scale or power are 0.
            if (m_dfDiffScale == 0)
            {
                colTop[0].SetData((m_dfPower == 0) ? 1.0 : Math.Pow(m_dfShift, m_dfPower));
                return;
            }
 
            int nCount = colBottom[0].count();
            long hTopData = colTop[0].mutable_gpu_data;
            long hBottomData = colBottom[0].gpu_data;
 
            m_cuda.copy(nCount, hBottomData, hTopData);
 
            if (m_dfScale != 1.0)
                m_cuda.scal(nCount, convert(m_dfScale), hTopData);
 
            if (m_dfShift != 0)
                m_cuda.add_scalar(nCount, convert(m_dfShift), hTopData);
 
            if (m_dfPower != 1.0)
                m_cuda.powx(nCount, hTopData, convert(m_dfPower), hTopData);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (!rgbPropagateDown[0])
                return;
 
            int nCount = colBottom[0].count();
            long hTopDiff = colTop[0].gpu_diff;
            long hBottomDiff = colBottom[0].mutable_gpu_diff;
 
            if (m_dfDiffScale == 0 || m_dfPower == 1)
            {
                colBottom[0].SetDiff(m_dfDiffScale);
            }
            else
            {
                long hBottomData = colBottom[0].gpu_data;
 
                // Compute dx/dy = scale * power * (shift + scale * x)^(power - 1)
                //               = diff_scale * y / (shift + scale * x)
                if (m_dfPower == 2)
                {
                    // Special case for y = (shift + scale * x)^2
                    //           -> dy/dx = 2 * scale * (shift + scale * x)
                    //                    = diff_scale * shift + diff_scale * scale * x 
                    m_cuda.axpby(nCount, convert(m_dfDiffScale * m_dfScale), hBottomData, m_tZero, hBottomDiff);
 
                    if (m_dfShift != 0)
                        m_cuda.add_scalar(nCount, convert(m_dfDiffScale * m_dfShift), hBottomDiff);
                }
                else if (m_dfShift == 0)
                {
                    // Special case for y = (scale * x)^power
                    //           -> dy/dx = scale * power * (scale * x)^(power - 1)
                    //                    = scale * power * (scale * x)^{power} * (scale * x)^(-1)
                    //                    = power * y / x 
                    long hTopData = colTop[0].gpu_data;
                    m_cuda.div(nCount, hTopData, hBottomData, hBottomDiff);
                    m_cuda.scal(nCount, convert(m_dfPower), hBottomDiff);
                }
                else
                {
                    m_cuda.copy(nCount, hBottomData, hBottomDiff);
 
                    if (m_dfScale != 1.0)
                        m_cuda.scal(nCount, convert(m_dfScale), hBottomDiff);
 
                    if (m_dfShift != 0.0)
                        m_cuda.add_scalar(nCount, convert(m_dfShift), hBottomDiff);
 
                    long hTopData = colTop[0].gpu_data;
                    m_cuda.div(nCount, hTopData, hBottomDiff, hBottomDiff);
 
                    if (m_dfDiffScale != 1.0)
                        m_cuda.scal(nCount, convert(m_dfDiffScale), hBottomDiff);
                }
            }
 
            m_cuda.mul(nCount, hTopDiff, hBottomDiff, hBottomDiff);
        }
    }
}