CropLayer.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 CropLayer<T> : Layer<T>
    {
        Blob<T> m_blobOffsets;
        Blob<T> m_blobSrcStrides;
        Blob<T> m_blobDstStrides;
 
        public CropLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.CONCAT;
 
            m_blobOffsets = new common.Blob<T>(m_cuda, m_log);
            m_blobOffsets.Name = m_param.name + "offsets";
            m_blobSrcStrides = new common.Blob<T>(m_cuda, m_log);
            m_blobSrcStrides.Name = m_param.name + "src strides";
            m_blobDstStrides = new common.Blob<T>(m_cuda, m_log);
            m_blobDstStrides.Name = m_param.name + "dst strides";
        }
 
        protected override void dispose()
        {
            m_blobOffsets.Dispose();
            m_blobSrcStrides.Dispose();
            m_blobDstStrides.Dispose();
            base.dispose();
        }
 
        protected override void setup_internal_blobs(BlobCollection<T> col)
        {
            if (col.Count > 0)
                return;
 
            col.Add(m_blobOffsets);
            col.Add(m_blobSrcStrides);
            col.Add(m_blobDstStrides);
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return 2; }
        }
 
        public override int ExactNumTopBlobs
        {
            get { return 1; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_log.CHECK_EQ(colBottom.Count, 2, "Wrong number of bottom blobs, expected 2.");
            int nInputDim = colBottom[0].num_axes;
            int nStartAxis = colBottom[0].CanonicalAxisIndex(m_param.crop_param.axis);
            m_log.CHECK_LT(nStartAxis, nInputDim, "The crop axis is bigger than the input dim.");
 
            if (m_param.crop_param.offset.Count > 1)
            {
                // The number of crop values specified must be equal to the number of
                // dimensions following axis.
                m_log.CHECK_EQ(nStartAxis + m_param.crop_param.offset.Count, nInputDim, "The number of offset values specified must be equal to the number of dimensions following axis.");
            }
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            int nInputDim = colBottom[0].num_axes;
            int nStartAxis = colBottom[0].CanonicalAxisIndex(m_param.crop_param.axis);
 
            // Initialize offsets to 0 and the new shape to the current shape of the data.
            List<int> rgNewShape = Utility.Clone<int>(colBottom[0].shape());
            List<int> rgOffsetsShape = new List<int>() { nInputDim };
 
            m_blobOffsets.Reshape(rgOffsetsShape);
            float[] rgOffsetData = convertF(m_blobOffsets.mutable_cpu_data);
 
            // Determine crop offsets and the new shape post-crop.
            for (int i = 0; i < nInputDim; i++)
            {
                int nCropOffset = 0;
                int nNewSize = colBottom[0].shape(i);
 
                if (i >= nStartAxis)
                {
                    nNewSize = colBottom[1].shape(i);
                    if (m_param.crop_param.offset.Count == 1)
                    {
                        // If only one offset is given, all crops have the same offset.
                        nCropOffset = (int)m_param.crop_param.offset[0];
                    }
                    else if (m_param.crop_param.offset.Count > 1)
                    {
                        // For several offsets, the number of offsets must be equual to the
                        // number of dimensions to crop, that is dimensions after the axis.
                        nCropOffset = (int)m_param.crop_param.offset[i - nStartAxis]; 
                    }
 
                    // Check that the crop and offset are within the dimension's bounds.
                    m_log.CHECK_GE(colBottom[0].shape(i) - nCropOffset, colBottom[1].shape(i), "The crop for dimension " + i.ToString() + " is out-of-bounds with size " + colBottom[0].shape(i).ToString() + " and offset " + nCropOffset.ToString());
                }
 
                rgNewShape[i] = nNewSize;
                rgOffsetData[i] = nCropOffset;
            }
 
            m_blobOffsets.mutable_cpu_data = convert(rgOffsetData);
 
            colTop[0].Reshape(rgNewShape);
            
            // Compute strides
            m_blobSrcStrides.Reshape(rgOffsetsShape);
            m_blobDstStrides.Reshape(rgOffsetsShape);
 
            float[] rgSrcStrides = convertF(m_blobSrcStrides.mutable_cpu_data);
            float[] rgDstStrides = convertF(m_blobDstStrides.mutable_cpu_data);
 
            for (int i = 0; i < nInputDim; i++)
            {
                rgSrcStrides[i] = colBottom[0].count(i + 1, nInputDim);
                rgDstStrides[i] = colTop[0].count(i + 1, nInputDim);
            }
 
            m_blobSrcStrides.mutable_cpu_data = convert(rgSrcStrides);
            m_blobDstStrides.mutable_cpu_data = convert(rgDstStrides);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            List<int> rgIndices = Utility.Create<int>(colTop[0].num_axes, 0);
            long hBottomData = colBottom[0].gpu_data;
            long hTopData = colTop[0].mutable_gpu_data;
            int nCount = colTop[0].count();
 
            m_cuda.crop_fwd(nCount, colBottom[0].num_axes, m_blobSrcStrides.gpu_data, m_blobDstStrides.gpu_data, m_blobOffsets.gpu_data, hBottomData, hTopData);
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (rgbPropagateDown[0])
            {
                colBottom[0].SetDiff(0);
 
                long hTopDiff = colTop[0].gpu_diff;
                long hBottomDiff = colBottom[0].mutable_gpu_diff;
                int nCount = colTop[0].count();
 
                m_cuda.crop_bwd(nCount, colBottom[0].num_axes, m_blobSrcStrides.gpu_data, m_blobDstStrides.gpu_data, m_blobOffsets.gpu_data, hBottomDiff, hTopDiff);
            }
        }
    }
}