DataSequenceLayer.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.beta
{
    public class DataSequenceLayer<T> : Layer<T>
    {
        int m_nK;
        int m_nCacheSize;
        bool m_bOutputLabels = false;
        Blob<T> m_blobLabeledDataCache = null;
        int m_nLabelStart = 0;
        int m_nLabelCount = 0;
        bool m_bBalanceMatches = false;
        long m_hCacheCursors = 0;
        long m_hWorkDataHost = 0;
 
        public DataSequenceLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_param = p;
            m_type = LayerParameter.LayerType.DATA_SEQUENCE;
            m_nK = m_param.data_sequence_param.k;
            m_nCacheSize = m_param.data_sequence_param.cache_size;
            m_bOutputLabels = m_param.data_sequence_param.output_labels;
            m_nLabelCount = m_param.data_sequence_param.label_count;
            m_nLabelStart = m_param.data_sequence_param.label_start;
            m_bBalanceMatches = m_param.data_sequence_param.balance_matches;
        }
 
        protected override void dispose()
        {
            if (m_blobLabeledDataCache != null)
            {
                m_blobLabeledDataCache.Dispose();
                m_blobLabeledDataCache = null;
            }
 
            if (m_hCacheCursors != 0)
            {
                m_cuda.FreeHostBuffer(m_hCacheCursors);
                m_hCacheCursors = 0;
                m_nLabelCount = 0;
            }
 
            if (m_hWorkDataHost != 0)
            {
                m_cuda.FreeHostBuffer(m_hWorkDataHost);
                m_hWorkDataHost = 0;
            }
 
            base.dispose();
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return 2; } // data, label
        }
 
        public override int MinTopBlobs
        {
            get { return m_nK + 2 + ((m_bOutputLabels) ? 1 : 0); } // anchor, positive (if k > 0), negative * (1 + m_nK)
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            // Disable back-propagation for all outputs of this layer.
            for (int i = 0; i < colBottom.Count; i++)
            {
                m_param.propagate_down.Add(false);
            }
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            colTop[0].ReshapeLike(colBottom[0]);
            colTop[1].ReshapeLike(colBottom[0]);
 
            for (int k = 0; k < m_nK; k++)
            {
                colTop[2 + k].ReshapeLike(colBottom[0]);
            }
 
            if (m_bOutputLabels)
            {
                int nLabelDim = 2 + m_nK;
                colTop[2 + m_nK].Reshape(colBottom[0].num, nLabelDim, 1, 1);
            }
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            Blob<T> data = colBottom[0];
            Blob<T> labels = colBottom[1];
 
            if (m_blobLabeledDataCache == null)
            {
                List<int> rgLabels = new List<int>();
 
                // Use dynamic label discovery - requires that all labels of the dataset are in the first batch.
                if (m_nLabelCount == 0)
                {
                    float[] rgfLabels = convertF(labels.update_cpu_data());
 
                    foreach (float fLabel in rgfLabels)
                    {
                        int nLabel = (int)fLabel;
                        if (!rgLabels.Contains(nLabel))
                            rgLabels.Add(nLabel);
                    }
 
                    rgLabels.Sort();
 
                    m_nLabelCount = rgLabels.Count;
                    m_nLabelStart = rgLabels.Min();
                }
                else
                {
                    for (int i = 0; i < m_nLabelCount; i++)
                    {
                        rgLabels.Add(m_nLabelStart + i);
                    }
                }
 
                int nNum = rgLabels.Count * m_nCacheSize;
                m_blobLabeledDataCache = new Blob<T>(m_cuda, m_log, nNum, colBottom[0].channels, colBottom[0].height, colBottom[0].width);
                m_blobLabeledDataCache.SetData(0);
                m_hCacheCursors = m_cuda.AllocHostBuffer(rgLabels.Count * 2);
                m_hWorkDataHost = m_cuda.AllocHostBuffer(labels.count());                
            }
 
            m_log.CHECK_EQ(data.num, labels.count(), "The label counts do not match the batch size!");
 
            m_cuda.copy_batch(data.count(), data.num, data.count(1), data.gpu_data, labels.gpu_data, m_blobLabeledDataCache.count(), m_blobLabeledDataCache.mutable_gpu_data, m_blobLabeledDataCache.mutable_gpu_diff, m_nLabelStart, m_nLabelCount, m_nCacheSize, m_hCacheCursors, m_hWorkDataHost);
 
            int nK = m_nK;
            List<long> rgTop = new List<long>();
            List<int> rgTopCount = new List<int>();
 
            for (int i = 0; i < colTop.Count; i++)
            {
                rgTop.Add(colTop[i].mutable_gpu_data);
                rgTopCount.Add(colTop[i].count());
            }
 
            m_cuda.copy_sequence(nK, data.num, data.count(1), data.gpu_data, labels.gpu_data, m_blobLabeledDataCache.count(), m_blobLabeledDataCache.gpu_data, m_nLabelStart, m_nLabelCount, m_nCacheSize, m_hCacheCursors, m_bOutputLabels, rgTop, rgTopCount, m_hWorkDataHost, m_bBalanceMatches);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (rgbPropagateDown[0])
                throw new NotImplementedException();
        }
    }
}