KernelParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
using MyCaffe.common;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class KernelParameter : EngineParameter 
    {
        List<uint> m_rgPad = new List<uint>();
        List<uint> m_rgStride = new List<uint>();
        List<uint> m_rgKernelSize = new List<uint>();
        List<uint> m_rgDilation = new List<uint>();
        uint? m_nPadH = null;
        uint? m_nPadW = null;
        uint? m_nStrideH = null;
        uint? m_nStrideW = null;
        uint? m_nKernelH = null;
        uint? m_nKernelW = null;
 
 
        public KernelParameter()
        {
        }
 
        [Description("Specifies pad given as a single value for equal dimensions in all spatial dimensions, or once per spatial dimension.")]
        public List<uint> pad
        {
            get { return m_rgPad; }
            set { m_rgPad = value; }
        }
 
        [Description("Specifies stride given as a single value for equal dimensions in all spatial dimensions, or once per spatial dimension.")]
        public List<uint> stride
        {
            get { return m_rgStride; }
            set { m_rgStride = value; }
        }
 
        [Description("Specifies kernel size given as a single value for equal dimensions in all spatial dimensions, or once per spatial dimension.")]
        public List<uint> kernel_size
        {
            get { return m_rgKernelSize; }
            set { m_rgKernelSize = value; }
        }
 
        [Description("Specifies dilation given as a single value for equal dimensions in all spatial dimensions, or once per spatial dimension.  When specified, this is used to dilate the kernel, (implicitly) zero-filling the resulting holes. (Kernel dilation is sometimes referred to by its use in the algorithm 'a trous from Holschneider et al. 1987.)")]
        public List<uint> dilation
        {
            get { return m_rgDilation; }
            set { m_rgDilation = value; }
        }
 
        [Description("Specifies padding height (2D only).  'pad_h' and 'pad_w' are used -or- 'pad' is used, but not both.")]
        public uint? pad_h
        {
            get { return m_nPadH; }
            set { m_nPadH = value; }
        }
 
        [Description("Specifies padding width (2D only).  'pad_h' and 'pad_w' are used -or- 'pad' is used, but not both.")]
        public uint? pad_w
        {
            get { return m_nPadW; }
            set { m_nPadW = value; }
        }
 
        [Description("Specifies stride height (2D only).  'stride_h' and 'stride_w' are used -or- 'stride' is used, but not both.")]
        public uint? stride_h
        {
            get { return m_nStrideH; }
            set { m_nStrideH = value; }
        }
 
        [Description("Specifies stride width (2D only).  'stride_h' and 'stride_w' are used -or- 'stride' is used, but not both.")]
        public uint? stride_w
        {
            get { return m_nStrideW; }
            set { m_nStrideW = value; }
        }
 
        [Description("Specifies kernel size height (2D only).  'kernel_h' and 'kernel_w' are used -or- 'kernel_size' is used, but not both.")]
        public uint? kernel_h
        {
            get { return m_nKernelH; }
            set { m_nKernelH = value; }
        }
 
        [Description("Specifies kernel size width (2D only).  'kernel_h' and 'kernel_w' are used -or- 'kernel_size' is used, but not both.")]
        public uint? kernel_w
        {
            get { return m_nKernelW; }
            set { m_nKernelW = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            KernelParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            base.Copy(src);
 
            if (src is KernelParameter)
            {
                KernelParameter p = (KernelParameter)src;
                m_rgPad = Utility.Clone<uint>(p.m_rgPad);
                m_rgStride = Utility.Clone<uint>(p.m_rgStride);
                m_rgKernelSize = Utility.Clone<uint>(p.m_rgKernelSize);
                m_rgDilation = Utility.Clone<uint>(p.m_rgDilation);
                m_nPadH = p.m_nPadH;
                m_nPadW = p.m_nPadW;
                m_nStrideH = p.m_nStrideH;
                m_nStrideW = p.m_nStrideW;
                m_nKernelH = p.m_nKernelH;
                m_nKernelW = p.m_nKernelW;
            }
        }
 
        public override LayerParameterBase Clone()
        {
            KernelParameter p = new KernelParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProto rpBase = base.ToProto("engine");
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(rpBase.Children);
            rgChildren.Add<uint>("kernel_size", m_rgKernelSize);
            rgChildren.Add<uint>("stride", m_rgStride);
            rgChildren.Add<uint>("pad", m_rgPad);
 
            if (m_rgDilation.Count > 0)
                rgChildren.Add<uint>("dilation", m_rgDilation);
 
            rgChildren.Add("kernel_h", m_nKernelH);
            rgChildren.Add("kernel_w", m_nKernelW);
            rgChildren.Add("stride_h", m_nStrideH);
            rgChildren.Add("stride_w", m_nStrideW);
            rgChildren.Add("pad_h", m_nPadH);
            rgChildren.Add("pad_w", m_nPadW);
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new KernelParameter FromProto(RawProto rp)
        {
            KernelParameter p = new KernelParameter();
 
            ((EngineParameter)p).Copy(EngineParameter.FromProto(rp));
 
            p.m_rgPad = rp.FindArray<uint>("pad");
            p.m_rgStride = rp.FindArray<uint>("stride");
            p.m_rgKernelSize = rp.FindArray<uint>("kernel_size");
            p.m_rgDilation = rp.FindArray<uint>("dilation");
            p.m_nPadH = (uint?)rp.FindValue("pad_h", typeof(uint));
            p.m_nPadW = (uint?)rp.FindValue("pad_w", typeof(uint));
            p.m_nStrideH = (uint?)rp.FindValue("stride_h", typeof(uint));
            p.m_nStrideW = (uint?)rp.FindValue("stride_w", typeof(uint));
            p.m_nKernelH = (uint?)rp.FindValue("kernel_h", typeof(uint));
            p.m_nKernelW = (uint?)rp.FindValue("kernel_w", typeof(uint));
 
            return p;
        }
    }
}