FilterLayer.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
{
    public class FilterLayer<T> : Layer<T>
    {
        bool m_bFirstShape;
        List<int> m_rgIndicesToForward = new List<int>();
 
        public FilterLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.FILTER;
        }
 
        public override int MinBottomBlobs
        {
            get { return 2; }
        }
 
        public override int MinTopBlobs
        {
            get { return 1; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_log.CHECK_EQ(colTop.Count, colBottom.Count - 1, "The top size must be equal to the bottom size - 1.");
            m_bFirstShape = true;
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            // bottom[0...k-1] are the blobs to filter
            // bottom[last] is the 'selector_blob'
            int nSelectorIdx = colBottom.Count - 1;
            for (int i = 1; i < colBottom[nSelectorIdx].num_axes; i++)
            {
                m_log.CHECK_EQ(colBottom[nSelectorIdx].shape(i), 1, "Selector blob dimensions must be singletons (1), except the first");
            }
 
            for (int i = 0; i < colBottom.Count - 1; i++)
            {
                m_log.CHECK_EQ(colBottom[nSelectorIdx].shape(0), colBottom[i].shape(0), "Each bottom should have the same 0th dimension as the selector blob.");
            }
 
            T[] rgBottomDataSelector = colBottom[nSelectorIdx].update_cpu_data();
            m_rgIndicesToForward = new List<int>();
 
            // look for non-zero elements in bottom[0].  Items of each bottom that
            // have the same index as the items in bottom[0] with value == non-zero
            // will be forwarded.
            if (typeof(T) == typeof(double))
            {
                double[] rgBottomDataSelectorD = (double[])Convert.ChangeType(rgBottomDataSelector, typeof(double[]));
 
                for (int i = 0; i < colBottom[nSelectorIdx].shape(0); i++)
                {
                    if (rgBottomDataSelectorD[i] != 0.0)
                        m_rgIndicesToForward.Add(i);
                }
            }
            else
            {
                float[] rgBottomDataSelectorF = (float[])Convert.ChangeType(rgBottomDataSelector, typeof(float[]));
 
                for (int i = 0; i < colBottom[nSelectorIdx].shape(0); i++)
                {
                    if (rgBottomDataSelectorF[i] != 0.0)
                        m_rgIndicesToForward.Add(i);
                }
            }
 
            // only filtered items will be forwarded
            int nNewTopsNum = m_rgIndicesToForward.Count;
 
            // init
            if (m_bFirstShape)
            {
                nNewTopsNum = colBottom[0].shape(0);
                m_bFirstShape = false;
            }
 
            for (int t = 0; t < colTop.Count; t++)
            {
                int nNumAxes = colBottom[t].num_axes;
                List<int> rgShape = new List<int>();
                rgShape.Add(nNewTopsNum);
 
                for (int ts = 1; ts < nNumAxes; ts++)
                {
                    rgShape.Add(colBottom[t].shape(ts));
                }
 
                colTop[t].Reshape(rgShape);
            }
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nNewTopsNum = m_rgIndicesToForward.Count;
 
            // forward all filtered items for all bottoms but the Selector (bottom[last])
            for (int t = 0; t < colTop.Count; t++)
            {
                long hBottomData = colBottom[t].gpu_data;
                long hTopData = colTop[t].mutable_gpu_data;
                int nDim = colBottom[t].count() / colBottom[t].shape(0);
 
                for (int n = 0; n < nNewTopsNum; n++)
                {
                    int nDataOffsetTop = n * nDim;
                    int nDataOffsetBottom = m_rgIndicesToForward[n] * nDim;
                    m_cuda.copy(nDim, hBottomData, hTopData, nDataOffsetBottom, nDataOffsetTop);
                }
            }
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (rgbPropagateDown[colBottom.Count - 1])
                m_log.FAIL("Layer cannot backpropagate to filter index inputs.");
 
            for (int i = 0; i < colTop.Count; i++)
            {
                // bottom[last] is the selector and never needs backpropagation
                // so we can iterate over top vecotr because top.size() == bottom.size() - 1
 
                if (rgbPropagateDown[i])
                {
                    int nDim = colTop[i].count() / colTop[i].shape(0);
                    int nNextToBackwardOffset = 0;
                    int nBatchOffset = 0;
                    int nDataOffsetBottom = 0;
                    int nDataOffsetTop = 0;
 
                    for (int n = 0; n < colBottom[i].shape(0); n++)
                    {
                        if (nNextToBackwardOffset >= m_rgIndicesToForward.Count)
                        {
                            // we already visited all items that have been forwarded, so
                            // just set to zero remaining ones.
                            nDataOffsetBottom = n * nDim;
                            m_cuda.set(nDim, colBottom[i].mutable_gpu_diff, m_tZero, -1, nDataOffsetBottom);
                        }
                        else
                        {
                            nBatchOffset = m_rgIndicesToForward[nNextToBackwardOffset];
                            nDataOffsetBottom = n * nDim;
 
                            if (n != nBatchOffset) // this data has not been forwarded
                            {
                                m_cuda.set(nDim, colBottom[i].mutable_gpu_diff, m_tZero, -1, nDataOffsetBottom);
                            }
                            else // this data has been forwarded
                            {
                                nDataOffsetTop = nNextToBackwardOffset * nDim;
                                nNextToBackwardOffset++;    // point to next forwarded item index
                                m_cuda.copy(nDim, colTop[i].mutable_gpu_diff, colBottom[i].mutable_gpu_diff, nDataOffsetTop, nDataOffsetBottom);
                            }
                        }
                    }
                }
            }    
        }
    }
}