DecodeParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using System.ComponentModel;
 
namespace MyCaffe.param.beta
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class DecodeParameter : LayerParameterBase 
    {
        bool m_bEnableCentroidUpdate = true;
        int m_nCentroidOutputIteration = 300;
        bool m_bOutputCentroids = false;
        List<int> m_rgIgnoreLabels = new List<int>();
        TARGET m_target = TARGET.CENTROID;
        int m_nCacheSize = 100;
        int m_nK = 5;
        double m_dfPreGenAlpha = 1.1;
        int m_nPreGenerateTargetCount = 0;
 
        public enum TARGET
        {
            PREGEN,
            CENTROID,
            KNN
        }
 
        public DecodeParameter()
        {
        }
 
        [Description("Specifies the pregen margin.")]
        public double pregen_alpha
        {
            get { return m_dfPreGenAlpha; }
            set { m_dfPreGenAlpha = value; }
        }
 
        [Description("Specifies the pre-generate target count, only used when 'target' = PREGEN.")]
        public int pregen_label_count
        {
            get { return m_nPreGenerateTargetCount; }
            set { m_nPreGenerateTargetCount = value; }
        }
 
        [Description("Specifies whether or not to update the centroids.  For example in some cases a fixed centroid may be desired, such as in the case when initializing centroids with a PREGEN value.")]
        public bool enable_centroid_update
        {
            get { return m_bEnableCentroidUpdate; }
            set { m_bEnableCentroidUpdate = value; }
        }
 
        [Description("Specifies the iteration where calculated centroids are output for each label, before this value, the centroids should not be used for their calculation is not complete (default = 300).")]
        public int centroid_output_iteration
        {
            get { return m_nCentroidOutputIteration; }
            set { m_nCentroidOutputIteration = value; }
        }
 
        [Description("Optionally, specifies to output the centroids in top[1] (default = false).")]
        public bool output_centroids
        {
            get { return m_bOutputCentroids; }
            set { m_bOutputCentroids = value; }
        }
 
        [Description("Optionally, specifies one or more labels to ignore. (default = none, which then expects all labels).")]
        public List<int> ignore_labels
        {
            get { return m_rgIgnoreLabels; }
            set { m_rgIgnoreLabels = value; }
        }
 
        [Description("Optionally, specifies the target type to use (default = CENTROID).")]
        public TARGET target
        {
            get { return m_target; }
            set { m_target = value; }
        }
 
        [Description("Specifies the size of the cache (in number of batches) used when calculating the CENTROID and KNN values (default = 300).")]
        public int cache_size
        {
            get { return m_nCacheSize; }
            set { m_nCacheSize = value; }
        }
 
        [Description("Optionally, specifies the K value to use with the KNN target (default = 5).")]
        public int k
        {
            get { return m_nK; }
            set { m_nK = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            DecodeParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            DecodeParameter p = (DecodeParameter)src;
            m_nCentroidOutputIteration = p.m_nCentroidOutputIteration;
            m_nCacheSize = p.m_nCacheSize;
            m_bOutputCentroids = p.m_bOutputCentroids;
            m_dfPreGenAlpha = p.m_dfPreGenAlpha;
            m_nPreGenerateTargetCount = p.m_nPreGenerateTargetCount;
            m_bEnableCentroidUpdate = p.m_bEnableCentroidUpdate;
 
            if (p.m_rgIgnoreLabels != null)
                m_rgIgnoreLabels = Utility.Clone<int>(p.m_rgIgnoreLabels);
 
            m_target = p.m_target;
            m_nK = p.m_nK;
        }
 
        public override LayerParameterBase Clone()
        {
            DecodeParameter p = new DecodeParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("centroid_output_iteration", centroid_output_iteration.ToString());
            rgChildren.Add("enable_centroid_update", enable_centroid_update.ToString());
            rgChildren.Add("cache_size", cache_size.ToString());
            rgChildren.Add("output_centroids", output_centroids.ToString());
            rgChildren.Add("target", target.ToString());
            rgChildren.Add("pregen_alpha", pregen_alpha.ToString());
            rgChildren.Add("pregen_label_count", pregen_label_count.ToString());
            rgChildren.Add("k", k.ToString());
 
            foreach (int nLabel in ignore_labels)
            {
                rgChildren.Add("ignore_label", nLabel.ToString());
            }
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static DecodeParameter FromProto(RawProto rp)
        {
            string strVal;
            DecodeParameter p = new DecodeParameter();
 
            if ((strVal = rp.FindValue("centroid_output_iteration")) != null)
                p.centroid_output_iteration = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("enable_centroid_update")) != null)
                p.enable_centroid_update = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("cache_size")) != null)
                p.cache_size = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("output_centroids")) != null)
                p.output_centroids = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("pregen_alpha")) != null)
                p.pregen_alpha = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("pregen_label_count")) != null)
                p.pregen_label_count = int.Parse(strVal);
 
            p.ignore_labels = new List<int>();
            RawProtoCollection rpIgnore = rp.FindChildren("ignore_label");
            foreach (RawProto rplabel in rpIgnore)
            {
                int nLabel = int.Parse(rplabel.Value);
                if (!p.ignore_labels.Contains(nLabel))
                    p.ignore_labels.Add(nLabel);
            }
 
            if ((strVal = rp.FindValue("target")) != null)
            {
                if (strVal == TARGET.KNN.ToString())
                    p.target = TARGET.KNN;
                else if (strVal == TARGET.PREGEN.ToString())
                    p.target = TARGET.PREGEN;
                else
                    p.target = TARGET.CENTROID;
            }
 
            if ((strVal = rp.FindValue("k")) != null)
                p.k = int.Parse(strVal);
 
            return p;
        }
    }
}