EltwiseParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using MyCaffe.basecode;
using MyCaffe.common;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class EltwiseParameter : LayerParameterBase
    {
        public enum EltwiseOp
        {
            PROD = 0,
            SUM = 1,
            MAX = 2,
            MIN = 3,
            DIV = 4,
            SUB = 5
        }
 
        EltwiseOp m_operation = EltwiseOp.SUM;
        List<double> m_rgdfCoeff = new List<double>();
        bool m_bStableProdGrad = true;
        bool m_bCoeffBlob = false;
        bool m_bAllowSingleBatchInput = false;
 
        public EltwiseParameter()
        {
        }
 
        [Description("Specifies the element-wise operation to perform.")]
        public EltwiseOp operation
        {
            get { return m_operation; }
            set { m_operation = value; }
        }
 
        [Description("Specifies whether to allow single batch input for the second input (default = false).")]
        public bool allow_single_batch_input
        {
            get { return m_bAllowSingleBatchInput; }
            set { m_bAllowSingleBatchInput = value; }
        }
 
        [Description("Specifies the blob-wise coefficient for SUM operation.")]
        public List<double> coeff
        {
            get { return m_rgdfCoeff; }
            set { m_rgdfCoeff = value; }
        }
 
        [Description("Specifies whether or not to use an asymtotically slower (for > 2 inputs) but stabler method for computing the gradient for PROD operation (No effect for SUM operation).")]
        public bool stable_prod_grad
        {
            get { return m_bStableProdGrad; }
            set { m_bStableProdGrad = value; }
        }
 
        [Description("If true and EltwiseOp is SUM, the last bottom blob is a singleton coefficient for the first N-1 bottom blobs, with shape (N-1, 1, 1, 1).")]
        public bool coeff_blob
        {
            get { return m_bCoeffBlob; }
            set { m_bCoeffBlob = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            EltwiseParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            EltwiseParameter p = (EltwiseParameter)src;
            m_operation = p.m_operation;
            m_rgdfCoeff = Utility.Clone<double>(p.m_rgdfCoeff);
            m_bStableProdGrad = p.m_bStableProdGrad;
            m_bCoeffBlob = p.m_bCoeffBlob;
            m_bAllowSingleBatchInput = p.allow_single_batch_input;
        }
 
        public override LayerParameterBase Clone()
        {
            EltwiseParameter p = new EltwiseParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("operation", operation.ToString());
            rgChildren.Add<double>("coeff", coeff);
 
            if (stable_prod_grad != true)
                rgChildren.Add("stable_prod_grad", stable_prod_grad.ToString());
 
            if (coeff_blob != false)
                rgChildren.Add("coeff_blob", coeff_blob.ToString());
 
            if (allow_single_batch_input != false)
                rgChildren.Add("allow_single_batch_input", allow_single_batch_input.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static EltwiseParameter FromProto(RawProto rp)
        {
            string strVal;
            EltwiseParameter p = new EltwiseParameter();
 
            if ((strVal = rp.FindValue("operation")) != null)
            {
                switch (strVal)
                {
                    case "PROD":
                        p.operation = EltwiseOp.PROD;
                        break;
 
                    case "SUM":
                        p.operation = EltwiseOp.SUM;
                        break;
 
                    case "MAX":
                        p.operation = EltwiseOp.MAX;
                        break;
 
                    case "MIN":
                        p.operation = EltwiseOp.MIN;
                        break;
 
                    case "DIV":
                        p.operation = EltwiseOp.DIV;
                        break;
 
                    case "SUB":
                        p.operation = EltwiseOp.SUB;
                        break;
 
                    default:
                        throw new Exception("Unknown 'operation' value: " + strVal);
                }
            }
 
            p.coeff = rp.FindArray<double>("coeff");
 
            if ((strVal = rp.FindValue("stable_prod_grad")) != null)
                p.stable_prod_grad = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("coeff_blob")) != null)
                p.coeff_blob = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("allow_single_batch_input")) != null)
                p.allow_single_batch_input = bool.Parse(strVal);
 
            return p;
        }
    }
}