DataNormalizerParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class DataNormalizerParameter : LayerParameterBase
    {
        bool m_bNormalizeAcrossDataAndLabel = false;
        List<int> m_rgIgnoreChannels = new List<int>();
        List<NORMALIZATION_STEP> m_rgNormalizationSteps = new List<NORMALIZATION_STEP>();
        double m_dfOutputMin = 0;
        double m_dfOutputMax = 1;
        double m_dfInputMin = 0;
        double m_dfInputMax = 0;
        double? m_dfInputStdDev = null;
        double? m_dfInputMean = null;
        int? m_nLabelDataChannel = null;
 
        public enum NORMALIZATION_STEP
        {
            CENTER,
            STDEV,
            RANGE,
            ADDITIVE,
            RETURNS,
            LOG
        }
 
        public DataNormalizerParameter()
        {
        }
 
        [Description("Specifies to data channel used for the label (if any).")]
        public int? label_data_channel
        {
            get { return m_nLabelDataChannel; }
            set { m_nLabelDataChannel = value; }
        }
 
        [Description("Specifies to normalize across both the data and label data together.")]
        public bool across_data_and_label
        {
            get { return m_bNormalizeAcrossDataAndLabel; }
            set { m_bNormalizeAcrossDataAndLabel = value; }
        }
 
        [Description("Specifies the normalization steps which are performed in the order for which they are listed.")]
        public List<NORMALIZATION_STEP> steps
        {
            get { return m_rgNormalizationSteps; }
            set { m_rgNormalizationSteps = value; }
        }
 
        [Description("Specifies the channels to ignore and just pass through in their original form.")]
        public List<int> ignore_channels
        {
            get { return m_rgIgnoreChannels; }
            set { m_rgIgnoreChannels = value; }
        }
 
        [Description("Specifies the minimum data range of the intput, if known.  When not specified the input_stdev is determined dynamically from the data input itself.")]
        public double? input_stdev
        {
            get { return m_dfInputStdDev; }
            set { m_dfInputStdDev = value; }
        }
 
        [Description("Specifies the minimum data range of the intput, if known.  When not specified the input_mean is determined dynamically from the data input itself.")]
        public double? input_mean
        {
            get { return m_dfInputMean; }
            set { m_dfInputMean = value; }
        }
 
        [Description("Specifies the minimum data range of the intput, if known.  If both input_min and input_max are 0 the input_min/input_max are determined dynamically from the data input itself.")]
        public double input_min
        {
            get { return m_dfInputMin; }
            set { m_dfInputMin = value; }
        }
 
        [Description("Specifies the maximum data range of the intput, if known.  If both input_min and input_max are 0 the input_min/input_max are determined dynamically from the data input itself.")]
        public double input_max
        {
            get { return m_dfInputMax; }
            set { m_dfInputMax = value; }
        }
 
        [Description("Specifies the minimum data range of the output.")]
        public double output_min
        {
            get { return m_dfOutputMin; }
            set { m_dfOutputMin = value; }
        }
 
        [Description("Specifies the maximum data range of the output.")]
        public double output_max
        {
            get { return m_dfOutputMax; }
            set { m_dfOutputMax = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            DataNormalizerParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            DataNormalizerParameter p = (DataNormalizerParameter)src;
        }
 
        public override LayerParameterBase Clone()
        {
            DataParameter p = new DataParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
            List<string> rgstrStep = new List<string>();
 
            for (int i = 0; i < m_rgNormalizationSteps.Count; i++)
            {
                rgstrStep.Add(steps[i].ToString().ToLower());
            }
 
            rgChildren.Add<string>("step", rgstrStep);           
            rgChildren.Add("across_data_and_label", "\"" + across_data_and_label.ToString() + "\"");
            rgChildren.Add<int>("ignore_ch", ignore_channels);
            rgChildren.Add("input_min", input_min.ToString());
            rgChildren.Add("input_max", input_max.ToString());
            rgChildren.Add("output_min", output_min.ToString());
            rgChildren.Add("output_max", output_max.ToString());
 
            if (input_mean.HasValue)
                rgChildren.Add("input_mean", input_mean.Value.ToString());
 
            if (input_stdev.HasValue)
                rgChildren.Add("input_stdev", input_stdev.Value.ToString());
 
            if (label_data_channel.HasValue)
                rgChildren.Add("label_data_channel", label_data_channel.Value.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static DataNormalizerParameter FromProto(RawProto rp, DataNormalizerParameter p = null)
        {
            string strVal;
 
            if (p == null)
                p = new DataNormalizerParameter();
 
            List<string> rgstrStep = rp.FindArray<string>("step");
            p.steps = new List<NORMALIZATION_STEP>();
            
            foreach (string strStep in rgstrStep)
            {
                p.steps.Add(convertStep(strStep));
            }
 
            if ((strVal = rp.FindValue("across_data_and_label")) != null)
                p.across_data_and_label = bool.Parse(strVal);
 
            p.ignore_channels = rp.FindArray<int>("ignore_ch");
 
            if ((strVal = rp.FindValue("input_min")) != null)
                p.input_min = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("input_max")) != null)
                p.input_max = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("output_min")) != null)
                p.output_min = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("output_max")) != null)
                p.output_max = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("input_mean")) != null)
                p.input_mean = ParseDouble(strVal);
            else
                p.input_mean = null;
 
            if ((strVal = rp.FindValue("input_stdev")) != null)
                p.input_stdev = ParseDouble(strVal);
            else
                p.input_stdev = null;
 
            if ((strVal = rp.FindValue("label_data_channel")) != null)
                p.label_data_channel = int.Parse(strVal);
            else
                p.label_data_channel = null;
 
            return p;
        }
 
        private static NORMALIZATION_STEP convertStep(string str)
        {
            str = str.ToUpper();
 
            if (str == NORMALIZATION_STEP.ADDITIVE.ToString())
                return NORMALIZATION_STEP.ADDITIVE;
 
            if (str == NORMALIZATION_STEP.CENTER.ToString())
                return NORMALIZATION_STEP.CENTER;
 
            if (str == NORMALIZATION_STEP.LOG.ToString())
                return NORMALIZATION_STEP.LOG;
 
            if (str == NORMALIZATION_STEP.RANGE.ToString())
                return NORMALIZATION_STEP.RANGE;
 
            if (str == NORMALIZATION_STEP.RETURNS.ToString())
                return NORMALIZATION_STEP.RETURNS;
 
            if (str == NORMALIZATION_STEP.STDEV.ToString())
                return NORMALIZATION_STEP.STDEV;
 
            throw new Exception("The step '" + str + "' is unknown!");
        }
    }
}