UnPoolingParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
 
namespace MyCaffe.param.beta
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class UnPoolingParameter : PoolingParameter 
    {
        List<uint> m_rgUnpool = new List<uint>();
        uint? m_nUnPoolH = null;
        uint? m_nUnPoolW = null;
 
        public UnPoolingParameter()
        {
        }
 
        public new string useCaffeReason()
        {
            return "Not supported by cuDNN.";
        }
 
        public new bool useCudnn()
        {
            return false;
        }
 
        [Description("Specifies unpool size override given as a single value for equal dimensions in all spatial dimensions, or once per spatial dimension.")]
        public List<uint> unpool_size
        {
            get { return m_rgUnpool; }
            set { m_rgUnpool = value; }
        }
 
        [Description("Specifies unpooling height override (2D only).  'unpool_h' and 'unpool_w' are used -or- 'unpool_size' is used, but not both.")]
        public uint? unpool_h
        {
            get { return m_nUnPoolH; }
            set { m_nUnPoolH = value; }
        }
 
        [Description("Specifies unpooling width override (2D only).  'unpool_h' and 'unpool_w' are used -or- 'unpool_size' is used, but not both.")]
        public uint? unpool_w
        {
            get { return m_nUnPoolW; }
            set { m_nUnPoolW = value; }
        }
 
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            UnPoolingParameter p = FromProto(proto) as UnPoolingParameter;
 
            if (p == null)
                throw new Exception("Expected UnPoolingParameter type!");
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            base.Copy(src);
 
            if (src is UnPoolingParameter)
            {
                UnPoolingParameter p = (UnPoolingParameter)src;
 
                m_rgUnpool = Utility.Clone<uint>(p.m_rgUnpool);
                m_nUnPoolH = p.m_nUnPoolH;
                m_nUnPoolW = p.m_nUnPoolW;
            }
        }
 
        public override LayerParameterBase Clone()
        {
            UnPoolingParameter p = new UnPoolingParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            dilation.Clear();
            RawProto rpBase = base.ToProto("pooling");
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(rpBase.Children);
            rgChildren.Add<uint>("unpool_size", m_rgUnpool);
            rgChildren.Add("unpool_h", m_nUnPoolH);
            rgChildren.Add("unpool_w", m_nUnPoolW);
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new UnPoolingParameter FromProto(RawProto rp)
        {
            UnPoolingParameter p = new UnPoolingParameter();           
 
            ((PoolingParameter)p).Copy(PoolingParameter.FromProto(rp));
 
            p.m_rgUnpool = rp.FindArray<uint>("unpool_size");
            p.m_nUnPoolH = (uint?)rp.FindValue("unpool_h", typeof(uint));
            p.m_nUnPoolW = (uint?)rp.FindValue("unpool_w", typeof(uint));
 
            return p;
        }
    }
}