ScalarLayer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.common;
using MyCaffe.layers;
using MyCaffe.param;
using MyCaffe.param.nt;
 
namespace MyCaffe.layers.nt
{
    public class ScalarLayer<T> : NeuronLayer<T>
    {
        public ScalarLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.SCALAR;
        }
 
        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;
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nCount = colTop[0].count();
            long hBottomData = colBottom[0].gpu_data;
            long hTopData = colTop[0].mutable_gpu_data;
 
            m_cuda.copy(nCount, hBottomData, hTopData);
 
            switch (m_param.scalar_param.operation)
            {
                case ScalarParameter.ScalarOp.MUL:
                    if (m_param.scalar_param.value != 1.0)
                        m_cuda.mul_scalar(nCount, m_param.scalar_param.value, hTopData);
                    break;
 
                case ScalarParameter.ScalarOp.ADD:
                    if (m_param.scalar_param.value != 0.0)
                        m_cuda.add_scalar(nCount, m_param.scalar_param.value, hTopData);
                    break;
 
                default:
                    throw new Exception("Unknown scalar operation '" + m_param.scalar_param.operation.ToString());
            }
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (!rgbPropagateDown[0])
                return;
 
            int nCount = colTop[0].count();
            long hTopDiff = colTop[0].gpu_diff;
            long hBottomDiff = colBottom[0].mutable_gpu_diff;
 
            m_cuda.copy(nCount, hTopDiff, hBottomDiff);
 
            if (!m_param.scalar_param.passthrough_gradient)
            {
                switch (m_param.scalar_param.operation)
                {
                    case ScalarParameter.ScalarOp.MUL:
                        m_cuda.mul_scalar(nCount, 1.0 / m_param.scalar_param.value, hBottomDiff);
                        break;
 
                    case ScalarParameter.ScalarOp.ADD:
                        m_cuda.add_scalar(nCount, -m_param.scalar_param.value, hBottomDiff);
                        break;
 
                    default:
                        throw new Exception("Unknown scalar operation '" + m_param.scalar_param.operation.ToString());
                }
            }
        }
    }
}