GluLayer.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.common;
using MyCaffe.param;
 
namespace MyCaffe.layers.tft
{
    public class GluLayer<T> : Layer<T>
    {
        Layer<T> m_ip1Layer;
        Layer<T> m_ip2Layer;
        Layer<T> m_modLayer;
        Blob<T> m_blobIp1;
        Blob<T> m_blobIp2;
        Blob<T> m_blobMod;
        Blob<T> m_blobBtm;
        BlobCollection<T> m_colTop = new BlobCollection<T>();
        BlobCollection<T> m_colBtm = new BlobCollection<T>();
 
        public GluLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.GLU;
 
            m_blobIp1 = new Blob<T>(cuda, log);
            m_blobIp1.Name = p.name + ".ip1";
            m_blobIp2 = new Blob<T>(cuda, log);
            m_blobIp2.Name = p.name + ".ip2";
            m_blobMod = new Blob<T>(cuda, log);
            m_blobMod.Name = p.name + ".mod";
            m_blobBtm = new Blob<T>(cuda, log);
            m_blobBtm.Name = p.name + ".btm";
        }
 
        protected override void dispose()
        {
            dispose(ref m_blobIp1);
            dispose(ref m_blobIp2);
            dispose(ref m_blobMod);
            dispose(ref m_blobBtm);
 
            dispose(ref m_ip1Layer);
            dispose(ref m_ip2Layer);
            dispose(ref m_modLayer);
        }
 
        protected override void setup_internal_blobs(BlobCollection<T> col)
        {
            if (col.Count > 0)
                return;
 
            col.Add(m_blobIp1);
            col.Add(m_blobIp2);
            col.Add(m_blobMod);
            col.Add(m_blobBtm);
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return 1; }
        }
 
        public override int ExactNumTopBlobs
        {
            get { return 1; }
        }
 
        private void addBtmTop(Blob<T> btm, Blob<T> top)
        {
            m_colBtm.Clear();
            m_colBtm.Add(btm);
            m_colTop.Clear();
            m_colTop.Add(top);
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_blobBtm.ReshapeLike(colBottom[0]);
 
            if (m_ip1Layer == null)
            {
                LayerParameter ip1 = new LayerParameter(LayerParameter.LayerType.INNERPRODUCT, m_param.name + ".fc1");
                ip1.inner_product_param.num_output = (uint)m_param.glu_param.input_dim;
                ip1.inner_product_param.axis = m_param.glu_param.axis;
                ip1.inner_product_param.bias_term = m_param.glu_param.bias_term;
                ip1.inner_product_param.enable_noise = m_param.glu_param.enable_noise;
                ip1.inner_product_param.sigma_init = m_param.glu_param.sigma_init;
                ip1.inner_product_param.bias_filler = m_param.glu_param.bias_filler;
                ip1.inner_product_param.weight_filler = m_param.glu_param.weight_filler;
 
                m_ip1Layer = Layer<T>.Create(m_cuda, m_log, convertLayerParam(ip1, m_param), null);
 
                addBtmTop(colBottom[0], m_blobIp1);
                m_ip1Layer.Setup(m_colBtm, m_colTop);
                blobs.Add(m_ip1Layer.blobs);
            }
 
            if (m_modLayer == null)
            {
                if (m_param.glu_param.modulation == param.tft.GluParameter.MODULATION.SIGMOID)
                {
                    LayerParameter mod = new LayerParameter(LayerParameter.LayerType.SIGMOID, m_param.name + ".mod");
                    mod.sigmoid_param.engine = EngineParameter.Engine.DEFAULT;
 
                    m_modLayer = Layer<T>.Create(m_cuda, m_log, convertLayerParam(mod, m_param), null);
 
                    addBtmTop(m_blobIp1, m_blobMod);
                    m_modLayer.Setup(m_colBtm, m_colTop);
                }
                else
                {
                    m_log.FAIL("Unknown modulation type '" + m_param.glu_param.modulation.ToString() + "'");
                }
            }
 
            if (m_ip2Layer == null)
            {
                LayerParameter ip2 = new LayerParameter(LayerParameter.LayerType.INNERPRODUCT, m_param.name + ".fc2");
                ip2.inner_product_param.num_output = (uint)m_param.glu_param.input_dim;
                ip2.inner_product_param.axis = m_param.glu_param.axis;
                ip2.inner_product_param.bias_term = m_param.glu_param.bias_term;
                ip2.inner_product_param.enable_noise = m_param.glu_param.enable_noise;
                ip2.inner_product_param.sigma_init = m_param.glu_param.sigma_init;
                ip2.inner_product_param.bias_filler = m_param.glu_param.bias_filler;
                ip2.inner_product_param.weight_filler = m_param.glu_param.weight_filler;
 
                m_ip2Layer = Layer<T>.Create(m_cuda, m_log, convertLayerParam(ip2, m_param), null);
 
                addBtmTop(colBottom[0], m_blobIp2);
                m_ip2Layer.Setup(m_colBtm, m_colTop);
                blobs.Add(m_ip2Layer.blobs);
 
                colTop[0].ReshapeLike(m_blobIp2);
            }
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_blobBtm.ReshapeLike(colBottom[0]);
 
            addBtmTop(colBottom[0], m_blobIp1);
            m_ip1Layer.Reshape(m_colBtm, m_colTop);
 
            addBtmTop(m_blobIp1, m_blobMod);
            m_modLayer.Reshape(m_colBtm, m_colTop);
 
            addBtmTop(colBottom[0], m_blobIp2);
            m_ip2Layer.Reshape(m_colBtm, m_colTop);
 
            colTop[0].ReshapeLike(m_blobIp2);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_blobBtm.CopyFrom(colBottom[0]);
 
            addBtmTop(colBottom[0], m_blobIp1);
            m_ip1Layer.Forward(m_colBtm, m_colTop); // x1 = fc1(x)
 
            addBtmTop(m_blobIp1, m_blobMod);
            m_modLayer.Forward(m_colBtm, m_colTop);  // sig = sigmoid(x1)
 
            addBtmTop(colBottom[0], m_blobIp2);
            m_ip2Layer.Forward(m_colBtm, m_colTop);   // x2 = fc2(x)
 
            m_cuda.mul(colTop[0].count(), m_blobIp2.gpu_data, m_blobMod.gpu_data, colTop[0].mutable_gpu_data);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            // sig grad = y grad * x2
            m_cuda.mul(colTop[0].count(), colTop[0].gpu_diff, m_blobIp2.gpu_data, m_blobMod.mutable_gpu_diff);
 
            // x2 grad = y grad * sig
            m_cuda.mul(colTop[0].count(), colTop[0].gpu_diff, m_blobMod.gpu_data, m_blobIp2.mutable_gpu_diff);
 
            addBtmTop(m_blobBtm, m_blobIp2);
            m_ip2Layer.Backward(m_colTop, rgbPropagateDown, m_colBtm);
 
            addBtmTop(m_blobIp1, m_blobMod);
            m_modLayer.Backward(m_colTop, rgbPropagateDown, m_colBtm);
 
            addBtmTop(colBottom[0], m_blobIp1);
            m_ip1Layer.Backward(m_colTop, rgbPropagateDown, m_colBtm);
 
            // Add gradients from x1 and x2
            m_cuda.add(colBottom[0].count(), m_blobBtm.gpu_diff, colBottom[0].gpu_diff, colBottom[0].mutable_gpu_diff);
        }
    }
}