CategoricalTransformationLayer.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.tft
{
    public class CategoricalTransformationLayer<T> : Layer<T>
    {
        List<Layer<T>> m_rgEmbLayers = new List<Layer<T>>();
        BlobCollection<T> m_rgBtm = new BlobCollection<T>();
        BlobCollection<T> m_rgEmbBtm = new BlobCollection<T>();
        BlobCollection<T> m_rgEmbTop = new BlobCollection<T>();
 
        public CategoricalTransformationLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.CATEGORICAL_TRANS;
        }
 
        protected override void dispose()
        {
        }
 
        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.categorical_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 = m_param.categorical_trans_param.cardinalities.Count;
            int nCount  = colBottom[0].count(nOffset);
            int nSpatialDim = nCount / nNumInput;
            List<int> rgShape = new List<int>() { nDim, nSpatialDim };
            Blob<T> blobBtm = null;
 
            m_log.CHECK_EQ(m_param.categorical_trans_param.num_input, m_param.categorical_trans_param.cardinalities.Count, "The num_input must match the number of cardinalities!");
 
            m_rgEmbBtm.Clear();
            m_rgEmbBtm.Add(blobBtm);
            m_rgEmbTop.Clear();
            m_rgEmbTop.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_rgEmbBtm[0] = m_rgBtm[i];
                m_rgEmbTop[0] = colTop[i];
 
                int nCardinality = m_param.categorical_trans_param.cardinalities[i];
                LayerParameter p = new LayerParameter(LayerParameter.LayerType.EMBED, m_param.name + ".emb" + i.ToString());
                p.embed_param.num_output = m_param.categorical_trans_param.state_size;
                p.embed_param.input_dim = (uint)nCardinality;
                p.embed_param.bias_term = false;
 
                Layer<T> emb_layer = Layer<T>.Create(m_cuda, m_log, convertLayerParam(p, m_param), null);
                m_rgEmbLayers.Add(emb_layer);
 
                emb_layer.LayerSetUp(m_rgEmbBtm, m_rgEmbTop);
                blobs.Add(emb_layer.blobs);
            }
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nNumInput = m_param.categorical_trans_param.cardinalities.Count;
            for (int i = 0; i < nNumInput; i++)
            {
                m_rgEmbBtm[0] = m_rgBtm[i];
                m_rgEmbTop[0] = colTop[i];
                m_rgEmbLayers[i].Reshape(m_rgEmbBtm, m_rgEmbTop);
            }
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nNumInput = m_param.categorical_trans_param.cardinalities.Count;
            for (int i = 0; i < nNumInput; i++)
            {
                int nCount = m_rgBtm[i].count();
                m_cuda.channel_copy(nCount, nCount, 1, nNumInput, 1, i, colBottom[0].gpu_data, m_rgBtm[i].mutable_gpu_data, DIR.FWD);
 
                m_rgEmbBtm[0] = m_rgBtm[i];
                m_rgEmbTop[0] = colTop[i];
                m_rgEmbLayers[i].Forward(m_rgEmbBtm, m_rgEmbTop);
            }
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            int nNumInput = m_param.categorical_trans_param.cardinalities.Count;
            for (int i = 0; i < nNumInput; i++)
            {
                m_rgEmbBtm[0] = m_rgBtm[i];
                m_rgEmbTop[0] = colTop[i];
                m_rgEmbLayers[i].Backward(m_rgEmbTop, rgbPropagateDown, m_rgEmbBtm);
 
                // data fields do not have gradients so no gradients are output.
                //int nCount = m_rgEmbBtm[0].count();
                //m_cuda.channel_copy(nCount, nCount, 1, nNumInput, 1, i, colBottom[0].mutable_gpu_diff, m_rgEmbBtm[0].gpu_diff, DIR.BWD);
            }
        }
    }
}