DebugLayer.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 DebugLayer<T> : Layer<T>, IXDebugData<T>
    {
        BlobCollection<T> m_rgBatchData = new BlobCollection<T>();
        BlobCollection<T> m_rgBatchLabels = new BlobCollection<T>();
        int m_nCurrentBatchIdx = 0;
        int m_nLastBatchIdx = 0;
        int m_nMaxBatches;
        bool m_bBufferFull = false;
 
        public DebugLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.DEBUG;
            m_nMaxBatches = p.debug_param.max_stored_batches;
        }
 
        protected override void dispose()
        {
            m_rgBatchData.Dispose();
            m_rgBatchLabels.Dispose();
            base.dispose();
        }
 
        public BlobCollection<T> data
        {
            get { return m_rgBatchData; }
        }
 
        public BlobCollection<T> labels
        {
            get { return m_rgBatchLabels; }
        }
 
        public string name
        {
            get { return m_param.name; }
        }
 
        public long kernel_handle
        {
            get { return m_cuda.KernelHandle; }
        }
 
        public int load_count
        {
            get { return (m_bBufferFull) ? m_rgBatchData.Count : m_nCurrentBatchIdx; }
        }
 
        public override int MinBottomBlobs
        {
            get { return 2; }   // data (embeddings), label
        }
 
        public override int MinTopBlobs
        {
            get { return 1; }   // debug layer passes through the data, but not the label.
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_log.CHECK_GE(colBottom.Count, 2, "There should be at least two bottom items: data (embeddings) and labels.");
            m_log.CHECK_EQ(colTop.Count, colBottom.Count - 1, "The top count should equal the bottom count - 1");
 
            // Allocate the temp batch storage.
            for (int i = 0; i < m_nMaxBatches; i++)
            {
                Blob<T> data = new Blob<T>(m_cuda, m_log);
                data.ReshapeLike(colBottom[0]);
                m_rgBatchData.Add(data);
 
                Blob<T> label = new common.Blob<T>(m_cuda, m_log, false);
                label.ReshapeLike(colBottom[1]);
                m_rgBatchLabels.Add(label);
            }
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            if (!reshapeNeeded(colBottom, colTop))
                return;
 
            // Reshape the temp batch storage.
            for (int i = 0; i < m_nMaxBatches; i++)
            {
                m_rgBatchData[i].ReshapeLike(colBottom[0]);
                m_rgBatchLabels[i].ReshapeLike(colBottom[1]);
            }
 
            colTop[0].ReshapeLike(colBottom[0]);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            if (m_nCurrentBatchIdx == m_nMaxBatches)
            {
                m_nCurrentBatchIdx = 0;
                m_bBufferFull = true;
            }
 
            // Copy the data into the batch storage.
            m_cuda.copy(colBottom[0].count(), colBottom[0].gpu_data, m_rgBatchData[m_nCurrentBatchIdx].mutable_gpu_data);
            m_cuda.copy(colBottom[1].count(), colBottom[1].gpu_data, m_rgBatchLabels[m_nCurrentBatchIdx].mutable_gpu_data);
 
            m_nLastBatchIdx = m_nCurrentBatchIdx;
            m_nCurrentBatchIdx++;
 
            m_cuda.copy(colBottom[0].count(), colBottom[0].gpu_data, colTop[0].mutable_gpu_data);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            // Copy the diff into the batch storage.
            m_cuda.copy(colTop[0].count(), colTop[0].gpu_diff, m_rgBatchData[m_nLastBatchIdx].mutable_gpu_diff);
 
            m_cuda.copy(colTop[0].count(), colTop[0].gpu_diff, colBottom[0].mutable_gpu_diff);
        }
    }
}