MVNParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class MVNParameter : LayerParameterBase
    {
        bool m_bNormalizeVariance = true;
        bool m_bAcrossChannels = false;
        double m_dfEps = 1e-9;
 
        public MVNParameter()
        {
        }
 
        [Description("Specifies whether or not to normalize the variance.")]
        public bool normalize_variance
        {
            get { return m_bNormalizeVariance; }
            set { m_bNormalizeVariance = value; }
        }
 
        [Description("Specifies whether or not to normalize accross channels.")]
        public bool across_channels
        {
            get { return m_bAcrossChannels; }
            set { m_bAcrossChannels = value; }
        }
 
        [Description("Specifies a small value to avoid divide by zero.")]
        [Browsable(false)]
        public double eps
        {
            get { return m_dfEps; }
            set { m_dfEps = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            MVNParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            MVNParameter p = (MVNParameter)src;
            m_bNormalizeVariance = p.m_bNormalizeVariance;
            m_bAcrossChannels = p.m_bAcrossChannels;
            m_dfEps = p.m_dfEps;
        }
 
        public override LayerParameterBase Clone()
        {
            MVNParameter p = new MVNParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            if (normalize_variance != true)
                rgChildren.Add("normalize_variance", normalize_variance.ToString());
 
            if (across_channels != false)
                rgChildren.Add("across_channels", across_channels.ToString());
 
            if (eps != 1e-9)
                rgChildren.Add("eps", eps.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static MVNParameter FromProto(RawProto rp)
        {
            string strVal;
            MVNParameter p = new MVNParameter();
 
            if ((strVal = rp.FindValue("normalize_variance")) != null)
                p.normalize_variance = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("across_channels")) != null)
                p.across_channels = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("eps")) != null)
                p.eps = ParseDouble(strVal);
 
            return p;
        }
    }
}