NumericTransformationLayer.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.common;
using MyCaffe.param;
 
namespace MyCaffe.layers.tft
{
    public class NumericTransformationLayer<T> : Layer<T>
    {
        List<Layer<T>> m_rgIpLayers = new List<Layer<T>>();
        BlobCollection<T> m_rgBtm = new BlobCollection<T>();
        BlobCollection<T> m_rgIpBtm = new BlobCollection<T>();
        BlobCollection<T> m_rgIpTop = new BlobCollection<T>();
 
        public NumericTransformationLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.NUMERIC_TRANS;
        }
 
        protected override void dispose()
        {
            if (m_rgIpLayers != null)
            {
                foreach (Layer<T> layer in m_rgIpLayers)
                {
                    layer.Dispose();
                }
                m_rgIpLayers = null;
            }
 
            if (m_rgBtm != null)
            {
                m_rgBtm.Dispose();
                m_rgBtm = null;
            }
        }
 
        protected override void setup_internal_blobs(BlobCollection<T> col)
        {
            if (col.Count > 0)
                return;
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return 1; }
        }
 
        public override int ExactNumTopBlobs
        {
            get { return (int)m_param.numeric_trans_param.num_input; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nOffset = (colBottom[0].num_axes == 2) ? 1 : 2;
            int nDim = colBottom[0].count(0, nOffset);
            int nNumInput = (int)m_param.numeric_trans_param.num_input;
            int nCount = colBottom[0].count(nOffset);
            int nSpatialDim = nCount / nNumInput;
            List<int> rgShape = new List<int>() { nDim, nSpatialDim };
            Blob<T> blobBtm = null;
 
            m_rgIpBtm.Clear();
            m_rgIpBtm.Add(blobBtm);
            m_rgIpTop.Clear();
            m_rgIpTop.Add(colTop[0]);
 
            for (int i = 0; i < nNumInput; i++)
            {
                blobBtm = new Blob<T>(m_cuda, m_log);
                blobBtm.Reshape(rgShape);
                m_rgBtm.Add(blobBtm);
 
                m_rgIpBtm[0] = m_rgBtm[i];
                m_rgIpTop[0] = colTop[i];
 
                LayerParameter p = new LayerParameter(LayerParameter.LayerType.INNERPRODUCT, m_param.name + ".ip" + i.ToString());
                p.inner_product_param.num_output = m_param.numeric_trans_param.state_size;
                p.inner_product_param.axis = 1;
 
                Layer<T> ip_layer = Layer<T>.Create(m_cuda, m_log, convertLayerParam(p, m_param), null);
                m_rgIpLayers.Add(ip_layer);
 
                ip_layer.LayerSetUp(m_rgIpBtm, m_rgIpTop);
                blobs.Add(ip_layer.blobs);
            }
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            for (int i = 0; i < m_param.numeric_trans_param.num_input; i++)
            {
                m_rgIpBtm[0] = m_rgBtm[i];
                m_rgIpTop[0] = colTop[i];
                m_rgIpLayers[i].Reshape(m_rgIpBtm, m_rgIpTop);
            }
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            for (int i = 0; i < m_param.numeric_trans_param.num_input; i++)
            {
                int nCount = m_rgBtm[i].count();
                m_cuda.channel_copy(nCount, nCount, 1, (int)m_param.numeric_trans_param.num_input, 1, i, colBottom[0].gpu_data, m_rgBtm[i].mutable_gpu_data, DIR.FWD);
 
                m_rgIpBtm[0] = m_rgBtm[i];
                m_rgIpTop[0] = colTop[i];
                m_rgIpLayers[i].Forward(m_rgIpBtm, m_rgIpTop);
            }
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            for (int i = 0; i < m_param.numeric_trans_param.num_input; i++)
            {
                m_rgIpBtm[0] = m_rgBtm[i];
                m_rgIpTop[0] = colTop[i];
                m_rgIpLayers[i].Backward(m_rgIpTop, rgbPropagateDown, m_rgIpBtm);
 
                // data fields do not have gradients so no gradients are output.
                //int nCount = m_rgIpBtm[0].count();
                //m_cuda.channel_copy(nCount, nCount, 1, (int)m_param.numeric_trans_param.num_input, 1, i, colBottom[0].mutable_gpu_diff, m_rgIpBtm[0].gpu_diff, DIR.BWD);
            }
        }
    }
}