LossParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using System.ComponentModel;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class LossParameter : LayerParameterBase 
    {
        int? m_nIgnoreLabel = null;
        NormalizationMode? m_normalization = NormalizationMode.VALID;
        bool m_bNormalize = false;
 
        public enum NormalizationMode
        {
            FULL = 0,
 
            VALID = 1,
 
            BATCH_SIZE = 2,
 
            NONE = 3
        }
 
        public LossParameter(NormalizationMode norm = NormalizationMode.VALID)
        {
            m_normalization = norm;
        }
 
        [Description("Ignore instances with the given label, when specified.")]
        public int? ignore_label
        {
            get { return m_nIgnoreLabel; }
            set { m_nIgnoreLabel = value; }
        }
 
        [Description("Specifies the normalization mode to use (default = VALID).")]
        public NormalizationMode? normalization
        {
            get { return m_normalization; }
            set { m_normalization = value; }
        }
 
        [Description("DEPRECIATED - use 'normalization == BATCH_SIZE' instead.")]
        [Browsable(false)]
        public bool normalize
        {
            get { return m_bNormalize; }
            set { m_bNormalize = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            LossParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            LossParameter p = (LossParameter)src;
            
            m_nIgnoreLabel = p.m_nIgnoreLabel;
            m_normalization = p.m_normalization;
            m_bNormalize = p.m_bNormalize;
        }
 
        public override LayerParameterBase Clone()
        {
            LossParameter p = new LossParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            if (ignore_label.HasValue)
                rgChildren.Add("ignore_label", ignore_label);
 
            rgChildren.Add("normalization", normalization.ToString());
 
            if (normalization == NormalizationMode.NONE && normalize != false)
                rgChildren.Add("normalize", normalize.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static LossParameter FromProto(RawProto rp)
        {
            string strVal;
            LossParameter p = new LossParameter();
 
            p.ignore_label = (int?)rp.FindValue("ignore_label", typeof(int));
 
            if ((strVal = rp.FindValue("normalization")) != null)
            {
                switch (strVal)
                {
                    case "FULL":
                        p.normalization = NormalizationMode.FULL;
                        break;
 
                    case "VALID":
                        p.normalization = NormalizationMode.VALID;
                        break;
 
                    case "BATCH_SIZE":
                        p.normalization = NormalizationMode.BATCH_SIZE;
                        break;
 
                    case "NONE":
                        p.normalization = NormalizationMode.NONE;
                        break;
 
                    default:
                        throw new Exception("Unknown 'normalization' value: " + strVal);
                }
            }
 
            if ((strVal = rp.FindValue("normalize")) != null)
                p.normalize = bool.Parse(strVal);
 
            return p;
        }
    }
}