BatchNormParameter.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 BatchNormParameter : EngineParameter
    {
        bool? m_bUseGlobalStats = null;
        double m_dfMovingAverageFraction = 0.999;
        double m_dfEps = 1e-5;
        bool m_bScaleBias = false;
        FillerParameter m_scaleFiller = null;
        FillerParameter m_biasFiller = null;
 
        public BatchNormParameter()
        {
        }
 
        public string useCaffeReason()
        {
            if (engine == Engine.CAFFE)
                return "The engine setting is set on CAFFE.";
 
            return "";
        }
 
        public bool useCudnn()
        {
            if (engine != EngineParameter.Engine.CAFFE)
                return true;
 
            return false;
        }
 
        [Description("Specifies to use the scale and bias terms, otherwise the scale = 1 and bias = 0 which performs an identity operation.")]
        public bool scale_bias
        {
            get { return m_bScaleBias; }
            set { m_bScaleBias = value; }
        }
 
        [Description("Specifies the scale filler used, when null 'constant(1)' is used.")]
        public FillerParameter scale_filler
        {
            get { return m_scaleFiller; }
            set { m_scaleFiller = value; }
        }
 
        [Description("Specifies the bias filler used, when null 'constant(0)' is used.")]
        public FillerParameter bias_filler
        {
            get { return m_biasFiller; }
            set { m_biasFiller = value; }
        }
 
        [Description("If false, accumulate global mean/variance values via a moving average. If true, use those accumulated values instead of computing mean/variance accross the batch.")]
        public bool? use_global_stats
        {
            get { return m_bUseGlobalStats; }
            set { m_bUseGlobalStats = value; }
        }
 
        [Description("Specifies how much the moving average decays each iteration.")]
        public double moving_average_fraction
        {
            get { return m_dfMovingAverageFraction; }
            set { m_dfMovingAverageFraction = value; }
        }
 
        [Description("Specifies a small value to add to the variance estimate so that we don't divide by zero.")]
        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());
            BatchNormParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            base.Copy(src);
 
            if (src is BatchNormParameter)
            {
                BatchNormParameter p = (BatchNormParameter)src;
                m_bUseGlobalStats = p.m_bUseGlobalStats;
                m_dfEps = p.m_dfEps;
                m_dfMovingAverageFraction = p.m_dfMovingAverageFraction;
                m_bScaleBias = p.m_bScaleBias;
                m_biasFiller = p.m_biasFiller;
 
                if (p.m_scaleFiller != null)
                    m_scaleFiller = p.m_scaleFiller.Clone();
                else
                    m_scaleFiller = null;
 
                if (p.m_biasFiller != null)
                    m_biasFiller = p.m_biasFiller.Clone();
                else
                    m_biasFiller = null;
            }
        }
 
        public override LayerParameterBase Clone()
        {
            BatchNormParameter p = new BatchNormParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProto rpBase = base.ToProto("engine");
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(rpBase.Children);
 
            if (use_global_stats.HasValue)
                rgChildren.Add("use_global_stats", use_global_stats.Value.ToString());
 
            if (moving_average_fraction != 0.999)
                rgChildren.Add("moving_average_fraction", moving_average_fraction.ToString());
 
            if (eps != 1e-5)
                rgChildren.Add("eps", eps.ToString());
 
            if (scale_bias)
            {
                rgChildren.Add("scale_bias", scale_bias.ToString());
 
                if (scale_filler != null)
                    rgChildren.Add(scale_filler.ToProto("scale_filler"));
 
                if (bias_filler != null)
                    rgChildren.Add(bias_filler.ToProto("bias_filler"));
            }
            
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new BatchNormParameter FromProto(RawProto rp)
        {
            string strVal;
            BatchNormParameter p = new BatchNormParameter();
 
            ((EngineParameter)p).Copy(EngineParameter.FromProto(rp));
 
            if ((strVal = rp.FindValue("use_global_stats")) != null)
                p.use_global_stats = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("moving_average_fraction")) != null)
                p.moving_average_fraction = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("eps")) != null)
                p.eps = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("scale_bias")) != null)
            {
                p.scale_bias = bool.Parse(strVal);
 
                RawProto rp1;
 
                if ((rp1 = rp.FindChild("scale_filler")) != null)
                    p.scale_filler = FillerParameter.FromProto(rp1);
 
                if ((rp1 = rp.FindChild("bias_filler")) != null)
                    p.bias_filler = FillerParameter.FromProto(rp1);
            }
 
            return p;
        }
    }
}