Normalization1Layer.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.beta
{
    public class Normalization1Layer<T> : Layer<T>
    {
        Blob<T> m_blobSquared;
 
        public Normalization1Layer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.NORMALIZATION1;
            m_blobSquared = new Blob<T>(cuda, log);
            m_blobSquared.Name = "squared";
        }
 
        protected override void dispose()
        {
            m_blobSquared.Dispose();
            base.dispose();
        }
 
        protected override void setup_internal_blobs(BlobCollection<T> col)
        {
            if (col.Count > 0)
                return;
 
            col.Add(m_blobSquared);
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return 1; }
        }
 
        public override int ExactNumTopBlobs
        {
            get { return 1; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            colTop[0].ReshapeLike(colBottom[0]);
            m_blobSquared.ReshapeLike(colBottom[0]);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            long hBottomData = colBottom[0].gpu_data;
            long hTopData = colTop[0].mutable_gpu_data;
            long hSquaredData = m_blobSquared.mutable_gpu_data;
            double dfNormSqr;
            int n = colBottom[0].num;
            int d = colBottom[0].count() / n;
 
            m_cuda.powx(n * d, hBottomData, 2.0, hSquaredData);
 
            for (int i = 0; i < n; i++)
            {
                dfNormSqr = m_cuda.asum_double(d, hSquaredData, i * d);
                dfNormSqr = Math.Pow(dfNormSqr, -0.5);
                m_cuda.scale(d, convert(dfNormSqr), hBottomData, hTopData, i * d, i * d);
            }
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            long hTopDiff = colTop[0].gpu_diff;
            long hTopData = colTop[0].gpu_data;
            long hBottomData = colBottom[0].gpu_data;
            long hBottomDiff = colBottom[0].mutable_gpu_diff;
            int n = colTop[0].num;
            int d = colTop[0].count() / n;
            T a;
 
            for (int i = 0; i < n; i++)
            {
                a = m_cuda.dot(d, hTopData, hTopDiff, i * d, i * d);
                m_cuda.scale(d, a, hTopData, hBottomDiff, i * d, i * d);
                m_cuda.sub(d, hTopDiff, hBottomDiff, hBottomDiff, i * d, i * d, i * d);
                a = m_cuda.dot(d, hBottomData, hBottomData, i * d, i * d);
                double dfA = Math.Pow(convertD(a), -0.5);
                m_cuda.scale(d, convert(dfA), hBottomDiff, hBottomDiff, i * d, i * d);
            }
        }
    }
}