DataTemporalParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
 
namespace MyCaffe.param.tft
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class DataTemporalParameter : LayerParameterBase
    {
        string m_strSource = null;
        uint m_nBatchSize;
        uint m_nNumHistoricalSteps;
        uint m_nNumFutureSteps;
        SOURCE_TYPE m_srcType = SOURCE_TYPE.PATH_NPY_FILE;
        Phase? m_forcedPhase = null;
        double m_dfMaxLoadPercent = 1;
        uint m_nChunkCount = 1024;
        int m_nDripRefreshRate = 0;
        uint? m_nSeed = null;
        bool m_bShuffleData = true;
        bool m_bOutputTargetHistorical = false;
        bool m_bEnableDebugOutput = false;
        string m_strDebugOutputPath = null;
 
        public enum SOURCE_TYPE
        {
            PATH_NPY_FILE,
            SQL_DB
        }
 
        public DataTemporalParameter()
        {
        }
 
        public bool enable_debug_output
        {
            get { return m_bEnableDebugOutput; }
            set { m_bEnableDebugOutput = value; }
        }
 
        public string debug_output_path
        {
            get { return m_strDebugOutputPath; }
            set { m_strDebugOutputPath = value; }
        }
 
        [Description("Optionally, specifies to output a top containing the target historical data.")]
        public bool output_target_historical
        {
            get { return m_bOutputTargetHistorical; }
            set { m_bOutputTargetHistorical = value; }
        }
 
        [Description("Optionally, specifies the phase to use when loading data.")]
        public Phase? forced_phase
        {
            get { return m_forcedPhase; }
            set { m_forcedPhase = value; }
        }
 
        [Description("Specifies to randomly select from the data (default = true).")]
        public bool shuffle_data
        {
            get { return m_bShuffleData; }
            set { m_bShuffleData = value; }
        }
 
        [Description("Specifies the number of items to load per cycle when background loading (default = 1024).")]
        public uint chunk_count
        {
            get { return m_nChunkCount; }
            set { m_nChunkCount = value; }
        }
 
        [Description("Specifies the random seed used to shuffle the data.  When not specified, the default seed is used.")]
        public uint? seed
        {
            get { return m_nSeed; }
            set { m_nSeed = value; }
        }
 
        [Description("Specifies the maximum percent of data rows to load (default = 1.0 = 100%).")]
        public double max_load_percent
        {
            get { return m_dfMaxLoadPercent; }
            set { m_dfMaxLoadPercent = value; }
        }
 
        [Description("Specifies rate the drip refresh occurs in seconds (default = 0, disabled).")]
        public int drip_refresh_rate_in_sec
        {
            get { return m_nDripRefreshRate; }
            set { m_nDripRefreshRate= value; }
        }
 
        [Description("Specifies the type of source data.")]
        public SOURCE_TYPE source_type
        {
            get { return m_srcType; }
            set { m_srcType = value; }
        }
 
        [Description("Specifies the data source.")]
        public string source
        {
            get { return m_strSource; }
            set { m_strSource = value; }
        }
 
        [Description("Specifies the batch size the data.")]
        public virtual uint batch_size
        {
            get { return m_nBatchSize; }
            set { m_nBatchSize = value; }
        }
 
        [Description("Specifies the number of historical steps.")]
        public uint num_historical_steps
        {
            get { return m_nNumHistoricalSteps; }
            set { m_nNumHistoricalSteps = value; }
        }
 
        [Description("Specifies the number of future steps.")]
        public uint num_future_steps
        {
            get { return m_nNumFutureSteps; }
            set { m_nNumFutureSteps = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            DataTemporalParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            DataTemporalParameter p = (DataTemporalParameter)src;
 
            m_srcType = p.source_type;
            m_strSource = p.source;
            m_nBatchSize = p.batch_size;
 
            m_nNumHistoricalSteps = p.num_historical_steps;
            m_nNumFutureSteps = p.num_future_steps;
 
            m_dfMaxLoadPercent = p.max_load_percent;
            m_nDripRefreshRate = p.drip_refresh_rate_in_sec;
            m_nSeed = p.seed;
            m_nChunkCount = p.chunk_count;
            m_bShuffleData = p.shuffle_data;
            m_forcedPhase = p.forced_phase;
            m_bOutputTargetHistorical = p.output_target_historical;
 
            m_bEnableDebugOutput = p.enable_debug_output;
            m_strDebugOutputPath = p.debug_output_path;
        }
 
        public override LayerParameterBase Clone()
        {
            DataTemporalParameter p = new DataTemporalParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("batch_size", batch_size.ToString());
            rgChildren.Add("source", source);
            rgChildren.Add("source_type", source_type.ToString());
 
            rgChildren.Add("num_historical_steps", num_historical_steps.ToString());
            rgChildren.Add("num_future_steps", num_future_steps.ToString());
 
            rgChildren.Add("max_load_percent", max_load_percent.ToString());
            rgChildren.Add("drip_refresh_rate_in_sec", drip_refresh_rate_in_sec.ToString());
            rgChildren.Add("chunk_count", chunk_count.ToString());
            rgChildren.Add("shuffle_data", shuffle_data.ToString());
            rgChildren.Add("output_target_historical", output_target_historical.ToString());
 
            rgChildren.Add("enable_debug_output", enable_debug_output.ToString());
            rgChildren.Add("debug_output_path", debug_output_path);
 
            if (seed.HasValue)
                rgChildren.Add("seed", seed.Value.ToString());
 
            if (forced_phase.HasValue)
                rgChildren.Add("forced_phase", forced_phase.Value.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static DataTemporalParameter FromProto(RawProto rp)
        {
            string strVal;
            DataTemporalParameter p = new DataTemporalParameter();
 
            if ((strVal = rp.FindValue("batch_size")) != null)
                p.batch_size = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("source")) != null)
                p.source = strVal;
 
            if ((strVal = rp.FindValue("source_type")) != null)
            {
                if (strVal == SOURCE_TYPE.PATH_NPY_FILE.ToString())
                    p.source_type = SOURCE_TYPE.PATH_NPY_FILE;
                else if (strVal == SOURCE_TYPE.SQL_DB.ToString())
                    p.source_type = SOURCE_TYPE.SQL_DB;
                else
                    throw new Exception("Unknown source_type '" + strVal + "'!");
            }
 
            if ((strVal = rp.FindValue("num_historical_steps")) != null)
                p.num_historical_steps = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("num_future_steps")) != null)
                p.num_future_steps = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("max_load_percent")) != null)
                p.max_load_percent = double.Parse(strVal);
 
            if ((strVal = rp.FindValue("drip_refresh_rate_in_sec")) != null)
                p.drip_refresh_rate_in_sec = int.Parse(strVal);
 
            if ((strVal = rp.FindValue("chunk_count")) != null)
                p.chunk_count = uint.Parse(strVal);
 
            if (p.chunk_count == 0)
                p.chunk_count = 1;
 
            if ((strVal = rp.FindValue("seed")) != null)
                p.seed = uint.Parse(strVal);
 
            if ((strVal = rp.FindValue("shuffle_data")) != null)
                p.shuffle_data = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("forced_phase")) != null)
            {
                if (strVal == Phase.TRAIN.ToString())
                    p.forced_phase = Phase.TRAIN;
                else if (strVal == Phase.TEST.ToString())
                    p.forced_phase = Phase.TEST;
                else if (strVal == Phase.RUN.ToString())
                    p.forced_phase = Phase.RUN;
                else
                    throw new Exception("Unknown forced_phase '" + strVal + "'!");
            }
 
            if ((strVal = rp.FindValue("output_target_historical")) != null)
                p.output_target_historical = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("enable_debug_output")) != null)
                p.enable_debug_output = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("debug_output_path")) != null)
                p.debug_output_path = strVal;
 
            return p;
        }
    }
}