CfcUnitParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
 
namespace MyCaffe.param.lnn
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class CfcUnitParameter : LayerParameterBase
    {
        bool m_bNoGate = false;
        bool m_bMinimal = false;
        int m_nInputSize = 0;
        int m_nHiddenSize = 0;
        int m_nBackboneUnits = 1;
        int m_nBackboneLayers = 1;
        float m_fBackboneDropout = 0.0f;
        ACTIVATION m_backboneActivation = ACTIVATION.SILU;
 
        public enum ACTIVATION
        {
            SILU,
            RELU,
            TANH,
            GELU,
            LECUN
        }
 
        public CfcUnitParameter()
        {
        }
 
        [Description("Specifies whether to use the gate or not (when true, the no gate mode is used to calculate the forward output).")]
        public bool no_gate
        {
            get { return m_bNoGate; }
            set { m_bNoGate = value; }
        }
 
        [Description("Specifies whether to use the minimal model or not (when true, the minimal mode is used to calculate the forward output).")]
        public bool minimal
        {
            get { return m_bMinimal; }
            set { m_bMinimal = value; }
        }
 
        [Description("Specifies the input size used to size the backbone units.")]
        public int input_size
        {
            get { return m_nInputSize; }
            set { m_nInputSize = value; }
        }
 
        [Description("Specifies the hidden size used to size the backbone units and other internal layers.")]
        public int hidden_size
        {
            get { return m_nHiddenSize; }
            set { m_nHiddenSize = value; }
        }
 
        [Description("Specifies the number of backbone units.")]
        public int backbone_units
        {
            get { return m_nBackboneUnits; }
            set { m_nBackboneUnits = value; }
        }
 
        [Description("Specifies the number of backbone layers.")]
        public int backbone_layers
        {
            get { return m_nBackboneLayers; }
            set { m_nBackboneLayers = value; }
        }
 
        [Description("Specifies the backbone dropout ratio.")]
        public float backbone_dropout_ratio
        {
            get { return m_fBackboneDropout; }
            set { m_fBackboneDropout = value; }
        }
 
        [Description("Specifies the backbone activation function.")]
        public ACTIVATION backbone_activation
        {
            get { return m_backboneActivation; }
            set { m_backboneActivation = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            CfcUnitParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            CfcUnitParameter p = (CfcUnitParameter)src;
 
            m_bNoGate = p.no_gate;
            m_bMinimal = p.minimal;
            m_nInputSize = p.input_size;
            m_nHiddenSize = p.hidden_size;
            m_nBackboneUnits = p.backbone_units;
            m_nBackboneLayers = p.backbone_layers;
            m_fBackboneDropout = p.backbone_dropout_ratio;
            m_backboneActivation = p.backbone_activation;
        }
 
        public override LayerParameterBase Clone()
        {
            CfcUnitParameter p = new CfcUnitParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("no_gate", no_gate.ToString());
            rgChildren.Add("minimal", minimal.ToString());
            rgChildren.Add("input_size", input_size.ToString());
            rgChildren.Add("hidden_size", hidden_size.ToString());
            rgChildren.Add("backbone_units", backbone_units.ToString());
            rgChildren.Add("backbone_layers", backbone_layers.ToString());
            rgChildren.Add("backbone_dropout_ratio", backbone_dropout_ratio.ToString());
            rgChildren.Add("backbone_activation", backbone_activation.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static CfcUnitParameter FromProto(RawProto rp)
        {
            string strVal;
            CfcUnitParameter p = new CfcUnitParameter();
 
            if ((strVal = rp.FindValue("no_gate")) != null)
                p.no_gate = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("minimal")) != null)
                p.minimal = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("input_size")) != null)
                p.input_size = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("hidden_size")) != null)
                p.hidden_size = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("backbone_units")) != null)
                p.backbone_units = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("backbone_layers")) != null)
                p.backbone_layers = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("backbone_dropout_ratio")) != null)
                p.backbone_dropout_ratio = BaseParameter.ParseFloat(strVal);
 
            if ((strVal = rp.FindValue("backbone_activation")) != null)
                p.backbone_activation = (ACTIVATION)Enum.Parse(typeof(ACTIVATION), strVal, true);
 
            return p;
        }
    }
}