LRNParameter.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 LRNParameter : EngineParameter 
    {
        uint m_nLocalSize = 5;
        double m_dfAlpha = 1e-4;     // caffe default = 1.0, cudnn default = 1e-4
        double m_dfBeta = 0.75;      // caffe default = 0.75, cudnn default = 0.75
        NormRegion m_normRegion = NormRegion.ACROSS_CHANNELS;
        double m_dfK = 2.0;          // caffe default = 1.0, cudnn default = 2.0
 
        public enum NormRegion
        {
            ACROSS_CHANNELS = 0,
            WITHIN_CHANNEL = 1
        }
 
        public LRNParameter()
            : base()
        {
        }
 
        public string useCaffeReason()
        {
            if (engine == Engine.CAFFE)
                return "The engine setting is set on CAFFE.";
 
            if (norm_region == NormRegion.WITHIN_CHANNEL)
                return "Currently using the normalization region 'WITHIN_CHANNEL' returns inconsistent errors from Caffe.";
 
            return "";
        }
 
        public bool useCudnn()
        {
            if (engine == EngineParameter.Engine.CAFFE ||
               norm_region == LRNParameter.NormRegion.WITHIN_CHANNEL)    // Currently CuDNN within channel Forward pass returns inconsistent results from Caffe.
                return false;
 
            return true;
        }
 
        [Description("Specifies the local size of the normalization window width.")]
        public uint local_size
        {
            get { return m_nLocalSize; }
            set { m_nLocalSize = value; }
        }
 
        [Description("Specifies the alpha value used for variance scaling in the normalization formula.  NOTE: cuDNN uses a default of alpha = 1e-4, whereas CAFFE uses a default of alpha = 1.0.")]
        public double alpha
        {
            get { return m_dfAlpha; }
            set { m_dfAlpha = value; }
        }
 
        [Description("Specifies the beta value used as the power parameter in the normalization formula.  NOTE: both cuDNN and CAFFE use a default of beta = 0.75.")]
        public double beta
        {
            get { return m_dfBeta; }
            set { m_dfBeta = value; }
        }
 
        [Description("Specifies the region over which to normalize.")]
        public NormRegion norm_region
        {
            get { return m_normRegion; }
            set { m_normRegion = value; }
        }
 
        [Description("Specifies the k value used by the normalization parameter.  NOTE: cuDNN uses a default of k = 2.0, whereas CAFFE uses a default of k = 2.0.")]
        public double k
        {
            get { return m_dfK; }
            set { m_dfK = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            LRNParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            base.Copy(src);
 
            if (src is LRNParameter)
            {
                LRNParameter p = (LRNParameter)src;
                m_nLocalSize = p.m_nLocalSize;
                m_dfAlpha = p.m_dfAlpha;
                m_dfBeta = p.m_dfBeta;
                m_normRegion = p.m_normRegion;
                m_dfK = p.m_dfK;
            }
        }
 
        public override LayerParameterBase Clone()
        {
            LRNParameter p = new LRNParameter();
            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("local_size", local_size.ToString());
            rgChildren.Add("alpha", alpha.ToString());
            rgChildren.Add("beta", beta.ToString());
            rgChildren.Add("norm_region", norm_region.ToString());
            rgChildren.Add("k", k.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static new LRNParameter FromProto(RawProto rp)
        {
            string strVal;
            LRNParameter p = new LRNParameter();
 
            ((EngineParameter)p).Copy(EngineParameter.FromProto(rp));
 
            if ((strVal = rp.FindValue("local_size")) != null)
                p.local_size = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("alpha")) != null)
                p.alpha = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("beta")) != null)
                p.beta = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("norm_region")) != null)
            {
                switch (strVal)
                {
                    case "ACROSS_CHANNELS":
                        p.norm_region = NormRegion.ACROSS_CHANNELS;
                        break;
 
                    case "WITHIN_CHANNEL":
                        p.norm_region = NormRegion.WITHIN_CHANNEL;
                        break;
 
                    default:
                        throw new Exception("Unknown 'norm_region' value: " + strVal);
                }
            }
 
            if ((strVal = rp.FindValue("k")) != null)
                p.k = ParseDouble(strVal);
 
            return p;
        }
    }
}