UnPoolingLayer1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.common;
using MyCaffe.param;
using MyCaffe.basecode;
using System.Drawing;
using MyCaffe.param.beta;
 
namespace MyCaffe.layers.beta
{
    public class UnPoolingLayer1<T> : Layer<T>
    {
        int m_nKernelH;
        int m_nKernelW;
        int m_nStrideH;
        int m_nStrideW;
        int m_nPadH;
        int m_nPadW;
        int m_nChannels;
        int m_nHeight;
        int m_nWidth;
        int m_nUnPooledHeight;
        int m_nUnPooledWidth;
        bool m_bGlobalPooling;
 
        public UnPoolingLayer1(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.UNPOOLING1;
        }
 
 
        protected override void dispose()
        {
            base.dispose();
        }
 
        public override int MinBottomBlobs
        {
            get { return 1; }
        }
 
        public override int MaxBottomBlobs
        {
            get { return (m_param.unpooling_param.pool == PoolingParameter.PoolingMethod.MAX) ? 2 : 1; }
        }
 
        public override int ExactNumTopBlobs
        {
            get { return 1; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            UnPoolingParameter p = m_param.unpooling_param;
 
            if (p.global_pooling)
            {
                m_log.CHECK(!(p.kernel_size.Count > 0 || p.kernel_h.HasValue || p.kernel_w.HasValue), "With global pooling = true, Filter size cannot be specified.");
            }
            else
            {
                m_log.CHECK(!(p.kernel_size.Count > 0) != !(p.kernel_h.HasValue && p.kernel_w.HasValue), "Filter size is kernel_size OR kernel_h and kernel_w; not both.");
                m_log.CHECK(p.kernel_size.Count > 0 || (p.kernel_h.HasValue && p.kernel_w.HasValue), "For non-square filters, both kernel_h and kernel_w are required.");
            }
 
            m_log.CHECK(((p.pad.Count > 0) && p.pad_h.HasValue && p.pad_w.HasValue) || (!p.pad_h.HasValue && !p.pad_w.HasValue), "Pad is pad or pad_h and pad_w are required.");
            m_log.CHECK(((p.stride.Count > 0) && p.stride_h.HasValue && p.stride_w.HasValue) || (!p.stride_h.HasValue && !p.stride_w.HasValue), "Stride is stride or stride_h and stride_w are required.");
            m_bGlobalPooling = p.global_pooling;
 
 
            //---- Kernel Size ----
 
            if (m_bGlobalPooling)
            {
                m_nKernelH = colBottom[0].height;
                m_nKernelW = colBottom[0].width;
            }
            else
            {
                if (p.kernel_size.Count > 0)
                {
                    m_nKernelH = (int)p.kernel_size[0];
                    m_nKernelW = (int)p.kernel_size[0];
                }
                else
                {
                    m_nKernelH = (int)p.kernel_h.Value;
                    m_nKernelW = (int)p.kernel_w.Value;
                }
            }
 
            m_log.CHECK_GT(m_nKernelH, 0, "Filter dimensions cannot be zero.");
            m_log.CHECK_GT(m_nKernelW, 0, "Filter dimensions cannot be zero.");
 
 
            //---- Pad ----
 
            if (p.pad.Count > 0)
            {
                m_nPadH = (int)p.pad[0];
                m_nPadW = (int)p.pad[0];
            }
            else
            {
                m_nPadH = (p.pad_h.HasValue) ? (int)p.pad_h.Value : 0;
                m_nPadW = (p.pad_w.HasValue) ? (int)p.pad_w.Value : 0;
            }
 
 
            //---- Stride ----
 
            if (p.stride.Count > 0)
            {
                m_nStrideH = (int)p.stride[0];
                m_nStrideW = (int)p.stride[0];
            }
            else
            {
                m_nStrideH = (p.stride_h.HasValue) ? (int)p.stride_h.Value : 1;
                m_nStrideW = (p.stride_w.HasValue) ? (int)p.stride_w.Value : 1;
            }
 
            if (m_bGlobalPooling)
                m_log.CHECK(m_nPadH == 0 && m_nPadW == 0 && m_nStrideH == 1 && m_nStrideW == 1, "With global pooling = true, only pad = 0 and stride = 1 allowed.");
 
            if (m_nPadH != 0 || m_nPadW != 0)
            {
                m_log.CHECK(m_param.unpooling_param.pool == PoolingParameter.PoolingMethod.AVE ||
                            m_param.unpooling_param.pool == PoolingParameter.PoolingMethod.MAX, "Padding implemented for AVE and MAX pooling only.");
                m_log.CHECK_LT(m_nPadH, m_nKernelH, "The pad_h must be <= kernel_h.");
                m_log.CHECK_LT(m_nPadW, m_nKernelW, "The pad_w must be <= kernel_w.");
            }
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_log.CHECK_EQ(4, colBottom[0].num_axes, "Input must have 4 axes, corresponding to (num, channels, height, width)");
 
            m_nChannels = colBottom[0].channels;
            m_nHeight = colBottom[0].height;
            m_nWidth = colBottom[0].width;
 
            if (m_bGlobalPooling)
            {
                m_nKernelH = colBottom[0].height;
                m_nKernelW = colBottom[0].width;
            }
 
            // Given the original pooling calculation:
            // (int)Math.Ceiling((double)((nOriginalHeight + 2 * m_nPadH - m_nKernelH) / (double)m_nStrideH)) + 1;
            // we do not know whether or not the ceiling kicks in for at the unpooling
            // stage, we do not know the original height.  For this reason, the unpooled 
            // height will always be >= the original height.
            // Using the sizing method from HyeonwooNoh at
            // https://github.com/HyeonwooNoh/caffe/blob/master/src/caffe/layers/unpooling_layer.cpp
            m_nUnPooledHeight = Math.Max((m_nHeight - 1) * m_nStrideH + m_nKernelH - 2 * m_nPadH,
                                          m_nHeight * m_nStrideH - m_nPadH + 1);
            m_nUnPooledWidth = Math.Max((m_nWidth - 1) * m_nStrideW + m_nKernelW - 2 * m_nPadW,
                                          m_nWidth * m_nStrideW - m_nPadW + 1);
 
            if (m_nUnPooledHeight <= 0)
            {
                m_nUnPooledHeight = 1;
                m_log.WriteLine("WARNING: unpooling height was 0, setting to 1.");
            }
 
            if (m_nUnPooledWidth <= 0)
            {
                m_nUnPooledWidth = 1;
                m_log.WriteLine("WARNING: unpooling width was 0, setting to 1.");
            }
 
            colTop[0].Reshape(colBottom[0].num, m_nChannels, m_nUnPooledHeight, m_nUnPooledWidth);
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            // Init the top blob to be all zeros since only special places
            // wouldn't be zero then.
            colTop[0].SetData(0);
 
            T[] bottom_data = colBottom[0].update_cpu_data();
            T[] mask = null;
            
            if (colBottom.Count > 1)
                mask = colBottom[1].update_cpu_data();
 
            T[] top_data = colTop[0].mutable_cpu_data;
            int nBottomDataOffset = 0;
            int nTopDataOffset = 0;
            int nMaskOffset = 0;
 
            switch (m_param.unpooling_param.pool)
            {
                case PoolingParameter.PoolingMethod.MAX:
                    // Currently only the CPU version is supported
                    for (int n = 0; n < colBottom[0].num; n++)
                    {
                        for (int c = 0; c < m_nChannels; c++)
                        {
                            for (int ph = 0; ph < m_nHeight; ph++)
                            {
                                for (int pw = 0; pw < m_nWidth; pw++)
                                {
                                    int nIdx = ph * m_nWidth + pw;
                                    int nTopIdx = nIdx;
 
#warning TODO: Bug - nMaskOffset + nIdx exceed length on last row of mask.
                                    if (mask != null && nMaskOffset + nIdx < mask.Length)
                                        nTopIdx = (int)Convert.ChangeType(mask[nMaskOffset + nIdx], typeof(int));
 
#warning TODO: Bug - nTopDataOffset + nTopIdx exceed length on last row of data.
                                    if (nTopDataOffset + nTopIdx < top_data.Length)
                                        top_data[nTopDataOffset + nTopIdx] = bottom_data[nBottomDataOffset + nIdx];
                                }
                            }
 
                            // switch to the next channel.
                            nTopDataOffset += colTop[0].offset(0, 1);
                            nBottomDataOffset += colBottom[0].offset(0, 1);
                            nMaskOffset += colBottom[0].offset(0, 1);
                        }
                    }
                    colTop[0].mutable_cpu_data = top_data;
                    break;
 
                case PoolingParameter.PoolingMethod.AVE:
                    throw new NotImplementedException("Unpooling is only supported on the MAX type of pooling.");
 
                case PoolingParameter.PoolingMethod.STOCHASTIC:
                    throw new NotImplementedException("Unpooling is only supported on the MAX type of pooling.");
            }
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            throw new NotImplementedException("UnPooling does not support the backward operation.");
        }
    }
}