DataSequenceParameter.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 DataSequenceParameter : LayerParameterBase 
    {
        int m_nK = 0;
        bool m_bBalanceMatches = true;
        int m_nCacheSize = 256;
        bool m_bOutputLabels = true;
        int m_nLabelCount = 0;
        int m_nLabelStart = 0;
 
        public DataSequenceParameter()
        {
        }
 
        [Description("Specifies the cache size used for each labeled image cache, which should be at least 4 x the batch size used (default = 256).")]
        public int cache_size
        {
            get { return m_nCacheSize; }
            set { m_nCacheSize = value; }
        }
 
        [Description("Specifies the 'k' number of negatively matched labled images (default = 0, maximum = 10).  When specifying 0, the output is just the anchor and a negatively matched image.")]
        public int k
        {
            get { return m_nK; }
            set { m_nK = value; }
        }
 
        [Description("Specifies to balance the matching image between negative and positive matches. This setting only applies when k=0 (default = true).")]
        public bool balance_matches
        {
            get { return m_bBalanceMatches; }
            set { m_bBalanceMatches = value; }
        }
 
        [Description("Specifies whether or not to output the labels in an additional top output where labels are organized in the same batch order and listed by tuplet order (e.g. when k = 0, balance_matches = true; anchor, positive, anchor, negative; when k = 1, anchor, positive, negative, etc")]
        public bool output_labels
        {
            get { return m_bOutputLabels; }
            set { m_bOutputLabels = value; }
        }
 
        [Description("Specifies the number of labels in the data set, or 0 to use dynamic label discovery (requires large enough batch sizes to cover all labels within first batch) - (default = 0).")]
        public int label_count
        {
            get { return m_nLabelCount; }
            set { m_nLabelCount = value; }
        }
 
        [Description("Specifies the first label in the label set (default = 0).")]
        public int label_start
        {
            get { return m_nLabelStart; }
            set { m_nLabelStart = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            DataSequenceParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            DataSequenceParameter p = (DataSequenceParameter)src;
            m_nCacheSize = p.m_nCacheSize;
            m_nK = p.m_nK;
            m_bOutputLabels = p.m_bOutputLabels;
            m_nLabelStart = p.m_nLabelStart;
            m_nLabelCount = p.m_nLabelCount;
            m_bBalanceMatches = p.m_bBalanceMatches;
        }
 
        public override LayerParameterBase Clone()
        {
            DataSequenceParameter p = new DataSequenceParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("cache_size", cache_size.ToString());
            rgChildren.Add("k", k.ToString());
            rgChildren.Add("output_labels", output_labels.ToString());
            rgChildren.Add("label_count", label_count.ToString());
            rgChildren.Add("label_start", label_start.ToString());
            rgChildren.Add("balance_matches", balance_matches.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static DataSequenceParameter FromProto(RawProto rp)
        {
            string strVal;
            DataSequenceParameter p = new DataSequenceParameter();
 
            if ((strVal = rp.FindValue("cache_size")) != null)
                p.cache_size = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("k")) != null)
                p.k = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("output_labels")) != null)
                p.output_labels = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("label_count")) != null)
                p.label_count = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("label_start")) != null)
                p.label_start = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("balance_matches")) != null)
                p.balance_matches = bool.Parse(strVal);
 
            return p;
        }
    }
}