FillerParameter.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 FillerParameter : BaseParameter, ICloneable 
    {
        string m_strType;
        double m_fVal;   // The value in constant filler.
        double m_fMin;   // The min value in uniform filler.
        double m_fMax;   // The max value in uniform filler.
        double m_fMean;  // The mean value in Gaussian filler.
        double m_fStd;   // The std value in Gaussian filler.
 
        // The expected number of non-zero output weights for a given input in
        // Guassian filler -- the default -1 means don't perform sparsification.
        int m_nSparse = -1;
 
        // Normalize the filler variance by fan_in, fan_out, or their average.
        // Applies to 'xavier' and 'msra' fillers.
 
        public enum FillerType
        {
            CONSTANT,
            SEQUENCE,
            UNIFORM,
            GAUSSIAN,
            XAVIER,
            MSRA,
            POSITIVEUNITBALL,
            BILINEAR
        }
 
        public enum VarianceNorm
        {
            FAN_IN = 0,
            FAN_OUT = 1,
            AVERAGE = 2
        }
        VarianceNorm m_varianceNorm = VarianceNorm.FAN_IN;
 
        public FillerParameter(string strType = "gaussian", double dfVal = 0.0, double dfMean = 0.0, double dfStd = 1.0)
        {
            m_strType = strType;
            m_fVal = dfVal;
            m_fMin = 0;
            m_fMax = 1;
            m_fMean = dfMean;
            m_fStd = dfStd;
        }
 
        [Description("Specifies the type of filler to use.")]
        [Browsable(false)]
        public string type
        {
            get { return m_strType; }
            set { m_strType = value; }
        }
 
#pragma warning disable 1591
 
        [DisplayName("type")]
        [Description("Specifies the type of filler type to use.")]
        public FillerType FillerTypeMethod 
        {
            get
            {
                switch (m_strType)
                {
                    case "constant":
                        return FillerType.CONSTANT;
 
                    case "sequence":
                        return FillerType.SEQUENCE;
 
                    case "uniform":
                        return FillerType.UNIFORM;
 
                    case "gaussian":
                        return FillerType.GAUSSIAN;
 
                    case "xavier":
                        return FillerType.XAVIER;
 
                    case "msra":
                        return FillerType.MSRA;
 
                    case "positive_unitball":
                        return FillerType.POSITIVEUNITBALL;
 
                    case "bilinear":
                        return FillerType.BILINEAR;
 
                    default:
                        throw new Exception("Unknown filler type '" + m_strType + "'");
                }
            }
 
            set { m_strType = FillerParameter.GetFillerName(value); }
        }
 
#pragma warning restore 1591
 
        public static string GetFillerName(FillerType type)
        {
            switch (type)
            {
                case FillerType.CONSTANT:
                    return "constant";
 
                case FillerType.SEQUENCE:
                    return "sequence";
 
                case FillerType.UNIFORM:
                    return "uniform";
 
                case FillerType.GAUSSIAN:
                    return "gaussian";
 
                case FillerType.XAVIER:
                    return "xavier";
 
                case FillerType.MSRA:
                    return "msra";
 
                case FillerType.POSITIVEUNITBALL:
                    return "positive_unitball";
 
                case FillerType.BILINEAR:
                    return "bilinear";
 
                default:
                    throw new Exception("Unknown filler type '" + type.ToString() + "'");
            }
        }
 
        [Description("Specifies the value used by 'constant' filler.")]
        public double value
        {
            get { return m_fVal; }
            set { m_fVal = value; }
        }
 
        [Description("Specifies the minimum value to use with the 'uniform' filler.")]
        public double min
        {
            get { return m_fMin; }
            set { m_fMin = value; }
        }
 
        [Description("Specifies the maximum value to use with the 'uniform' filler.")]
        public double max
        {
            get { return m_fMax; }
            set { m_fMax = value; }
        }
 
        [Description("Specifies the mean value to use with the 'gaussian' filler.")]
        public double mean
        {
            get { return m_fMean; }
            set { m_fMean = value; }
        }
 
        [Description("Specifies the standard deviation value to use with the 'gaussian' filler.")]
        public double std
        {
            get { return m_fStd; }
            set { m_fStd = value; }
        }
 
        [Description("Specifies the sparcity value to use with the 'guassian' filler.")]
        public int sparse
        {
            get { return m_nSparse; }
            set { m_nSparse = value; }
        }
 
        [Description("Specifies the variance normalization method to use with the 'xavier' and 'mrsa' fillers.")]
        public VarianceNorm variance_norm
        {
            get { return m_varianceNorm; }
            set { m_varianceNorm = value; }
        }
 
        public FillerParameter Clone()
        {
            FillerParameter p = new FillerParameter();
 
            p.m_strType = m_strType;
            p.m_fVal = m_fVal;
            p.m_fMin = m_fMin;
            p.m_fMax = m_fMax;
            p.m_fMean = m_fMean;
            p.m_fStd = m_fStd;
            p.m_nSparse = m_nSparse;
            p.m_varianceNorm = m_varianceNorm;
 
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add(new RawProto("type", "\"" + type + "\""));
 
            if (type.ToLower() == "constant")
                rgChildren.Add(new RawProto("value", value.ToString()));
 
            if (type.ToLower() == "uniform")
            {
                rgChildren.Add(new RawProto("min", min.ToString()));
                rgChildren.Add(new RawProto("max", max.ToString()));
            }
 
            if (type.ToLower() == "gaussian")
            {
                rgChildren.Add(new RawProto("mean", mean.ToString()));
                rgChildren.Add(new RawProto("std", std.ToString()));
 
                if (sparse != -1)
                    rgChildren.Add(new RawProto("sparse", sparse.ToString()));
            }
 
            if (type.ToLower() == "xavier" ||
                type.ToLower() == "mrsa")
                rgChildren.Add(new RawProto("variance_norm", variance_norm.ToString()));
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static FillerParameter FromProto(RawProto rp)
        {
            string strVal;
 
            if ((strVal = rp.FindValue("type")) == null)
                throw new Exception("Could not find 'type'");
 
            FillerParameter p = new FillerParameter(strVal);
 
            if ((strVal = rp.FindValue("value")) != null)
                p.value = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("min")) != null)
                p.min = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("max")) != null)
                p.max = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("mean")) != null)
                p.mean = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("std")) != null)
                p.std = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("sparse")) != null)
                p.sparse = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("variance_norm")) != null)
            {
                switch (strVal)
                {
                    case "FAN_IN":
                        p.variance_norm = VarianceNorm.FAN_IN;
                        break;
 
                    case "FAN_OUT":
                        p.variance_norm = VarianceNorm.FAN_OUT;
                        break;
 
                    case "AVERAGE":
                        p.variance_norm = VarianceNorm.AVERAGE;
                        break;
                        
                    default:
                        throw new Exception("Unknown 'variance_norm' value: " + strVal);
                }
            }
 
            return p;
        }
 
        object ICloneable.Clone()
        {
            return Clone();
        }
    }
}