GrnParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
using static MyCaffe.param.tft.GluParameter;
 
namespace MyCaffe.param.tft
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class GrnParameter : LayerParameterBase
    {
        int m_nInputDim;
        int m_nHiddenDim;
        int m_nOutputDim;
        float m_fDropoutRatio = 0.05f;
        int? m_nContextDim = null;
        bool m_bBatchFirst = true;
        FillerParameter m_fillerParam_weights = new FillerParameter("xavier");
        FillerParameter m_fillerParam_bias = new FillerParameter("constant", 0.1);
        int m_nAxis = 1;
        ACTIVATION m_activaiton = ACTIVATION.ELU;
 
        public enum ACTIVATION
        {
            ELU,
 
            RELU
        }
 
        public GrnParameter()
        {
        }
 
        [Description("Specifies the activation type to use (default=ELU)")]
        public ACTIVATION activation
        {
            get { return m_activaiton; }
            set { m_activaiton = value; }
        }
 
        [Description("Specifies the input dimension.")]
        public int input_dim
        {
            get { return m_nInputDim; }
            set { m_nInputDim = value; }
        }
 
        [Description("Specifies the hidden dimension.")]
        public int hidden_dim
        {
            get { return m_nHiddenDim; }
            set { m_nHiddenDim = value; }
        }
 
        [Description("Specifies the output dimension.")]
        public int output_dim
        {
            get { return m_nOutputDim; }
            set { m_nOutputDim = value; }
        }
 
        [Description("Specifies the context dimension, or null to ignore.")]
        public int? context_dim
        {
            get { return m_nContextDim; }
            set { m_nContextDim = value; }
        }
 
        [Description("Specifies the dropout ratio (default = 0.05 or 5%).")]
        public float dropout_ratio
        {
            get { return m_fDropoutRatio; }
            set { m_fDropoutRatio = value; }
        }
 
        [Description("Specifies the batch_first setting.")]
        public bool batch_first
        {
            get { return m_bBatchFirst; }
            set { m_bBatchFirst = value; }
        }
 
        [Category("Fillers")]
        [Description("The filler for the weights.")]
        public FillerParameter weight_filler
        {
            get { return m_fillerParam_weights; }
            set { m_fillerParam_weights = value; }
        }
 
        [Category("Fillers")]
        [Description("The filler for the bias.")]
        public FillerParameter bias_filler
        {
            get { return m_fillerParam_bias; }
            set { m_fillerParam_bias = value; }
        }
 
        [Description("Specifies the first axis to be lumped into a single inner product computation; all preceding axes are retained in the output.")]
        public int axis
        {
            get { return m_nAxis; }
            set { m_nAxis = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            GrnParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            GrnParameter p = (GrnParameter)src;
 
            m_nInputDim = p.input_dim;
            m_nHiddenDim = p.hidden_dim;
            m_nOutputDim = p.output_dim;
            m_nContextDim = p.context_dim;
            m_fDropoutRatio = p.dropout_ratio;
            m_bBatchFirst = p.batch_first;
            m_nAxis = p.m_nAxis;
            m_activaiton = p.activation;
 
            if (p.m_fillerParam_bias != null)
                m_fillerParam_bias = p.m_fillerParam_bias.Clone();
 
            if (p.m_fillerParam_weights != null)
                m_fillerParam_weights = p.m_fillerParam_weights.Clone();
        }
 
        public override LayerParameterBase Clone()
        {
            GrnParameter p = new GrnParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("input_dim", input_dim.ToString());
            rgChildren.Add("hidden_dim", hidden_dim.ToString());
            rgChildren.Add("output_dim", output_dim.ToString());
            if (context_dim.HasValue)
                rgChildren.Add("context_dim", context_dim.Value.ToString());
            rgChildren.Add("dropout_ratio", dropout_ratio.ToString());
            rgChildren.Add("batch_first", batch_first.ToString());
 
            if (weight_filler != null)
                rgChildren.Add(weight_filler.ToProto("weight_filler"));
 
            if (bias_filler != null)
                rgChildren.Add(bias_filler.ToProto("bias_filler"));
 
            rgChildren.Add("axis", axis.ToString());
            rgChildren.Add("activation", activation.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static GrnParameter FromProto(RawProto rp)
        {
            string strVal;
            GrnParameter p = new GrnParameter();
 
            if ((strVal = rp.FindValue("input_dim")) != null)
                p.input_dim = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("hidden_dim")) != null)
                p.hidden_dim = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("output_dim")) != null)
                p.output_dim = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("context_dim")) != null)
                p.context_dim = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("dropout_ratio")) != null)
                p.dropout_ratio = float.Parse(strVal);
 
            if ((strVal = rp.FindValue("batch_first")) != null)
                p.batch_first = bool.Parse(strVal);
 
            RawProto rpWeightFiller = rp.FindChild("weight_filler");
            if (rpWeightFiller != null)
                p.weight_filler = FillerParameter.FromProto(rpWeightFiller);
 
            RawProto rpBiasFiller = rp.FindChild("bias_filler");
            if (rpBiasFiller != null)
                p.bias_filler = FillerParameter.FromProto(rpBiasFiller);
 
            if ((strVal = rp.FindValue("axis")) != null)
                p.axis = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("activation")) != null)
            {
                if (strVal == ACTIVATION.RELU.ToString())
                    p.activation = ACTIVATION.RELU;
                else
                    p.activation = ACTIVATION.ELU;
            }
 
            return p;
        }
    }
}