ContrastiveLossParameter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using System.ComponentModel;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class ContrastiveLossParameter : LayerParameterBase
    {
        double m_dfMargin = 1.0;
        bool m_bLegacyVersion = false;
        bool m_bOutputMatches = false;
        double m_dfMatchingDistScale = 1.0;
        CENTROID_LEARNING m_centroidLearning = CENTROID_LEARNING.NONE;
        DISTANCE_CALCULATION m_distanceCalc = DISTANCE_CALCULATION.EUCLIDEAN;
 
        public enum DISTANCE_CALCULATION
        {
            EUCLIDEAN,
            MANHATTAN
        }
 
        public enum CENTROID_LEARNING
        {
            NONE,
            MATCHING,
            NONMATCHING,
            ALL
        }
 
        public ContrastiveLossParameter()
        {
        }
 
        [Description("Specifies the margin for dissimilar pair.")]
        public double margin
        {
            get { return m_dfMargin; }
            set { m_dfMargin = value; }
        }
 
        [Description("Specifies to use the legacy version or not.  When true the legacy version '(margin - d^2)' is used.  Otherwise the default is to use the version '(margin - d)^2' proposed in the Hadsell paper.")]
        //[ReadOnly(true)] // currently legacy version causes bug in auto test on backwards
        public bool legacy_version
        {
            get { return m_bLegacyVersion; }
            set { m_bLegacyVersion = value; }
        }
 
        [Description("Optionally, specifies to output match information (default = false).")]
        public bool output_matches
        {
            get { return m_bOutputMatches; }
            set { m_bOutputMatches = value; }
        }
 
        [Description("Optionally, specifies to use centroid learning as soon as the centroids (from the DecodeLayer) are ready - e.g. they have an asum > 0 (default = false, meaning no centroid learning occurs).")]
        public CENTROID_LEARNING centroid_learning
        {
            get { return m_centroidLearning; }
            set { m_centroidLearning = value; }
        }
 
        [Description("Optionally, specifies the distance calculation to use when calculating the distance between encoding pairs (default = EUCLIDEAN).")]
        public DISTANCE_CALCULATION distance_calculation
        {
            get { return m_distanceCalc; }
            set { m_distanceCalc = value; }
        }
 
        [Description("Optionally, specifies the scaling applied to distances between matching pairs (default = 1.0, which ignores the scaling).")]
        public double matching_distance_scale
        {
            get { return m_dfMatchingDistScale; }
            set { m_dfMatchingDistScale = value; }
        }
 
        public override object Load(System.IO.BinaryReader br, bool bNewInstance = true)
        {
            RawProto proto = RawProto.Parse(br.ReadString());
            ContrastiveLossParameter p = FromProto(proto);
 
            if (!bNewInstance)
                Copy(p);
 
            return p;
        }
 
        public override void Copy(LayerParameterBase src)
        {
            ContrastiveLossParameter p = (ContrastiveLossParameter)src;
            m_dfMargin = p.m_dfMargin;
            m_bLegacyVersion = p.m_bLegacyVersion;
            m_bOutputMatches = p.m_bOutputMatches;
            m_centroidLearning = p.m_centroidLearning;
            m_distanceCalc = p.m_distanceCalc;
            m_dfMatchingDistScale = p.m_dfMatchingDistScale;
        }
 
        public override LayerParameterBase Clone()
        {
            ContrastiveLossParameter p = new ContrastiveLossParameter();
            p.Copy(this);
            return p;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            if (margin != 1.0)
                rgChildren.Add("margin", margin.ToString());
 
            if (legacy_version != false)
                rgChildren.Add("legacy_version", legacy_version.ToString());
 
            if (output_matches)
                rgChildren.Add("output_matches", output_matches.ToString());
 
            if (centroid_learning != CENTROID_LEARNING.NONE)
                rgChildren.Add("centroid_learning", centroid_learning.ToString());
 
            rgChildren.Add("distance_calculation", distance_calculation.ToString());
            rgChildren.Add("matching_distance_scale", matching_distance_scale.ToString());
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static ContrastiveLossParameter FromProto(RawProto rp)
        {
            string strVal;
            ContrastiveLossParameter p = new ContrastiveLossParameter();
 
            if ((strVal = rp.FindValue("margin")) != null)
                p.margin = ParseDouble(strVal);
 
            if ((strVal = rp.FindValue("legacy_version")) != null)
                p.legacy_version = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("output_matches")) != null)
                p.output_matches = bool.Parse(strVal);
 
            if ((strVal = rp.FindValue("centroid_learning")) != null)
            {
                if (strVal == CENTROID_LEARNING.ALL.ToString())
                    p.centroid_learning = CENTROID_LEARNING.ALL;
                else if (strVal == CENTROID_LEARNING.MATCHING.ToString())
                    p.centroid_learning = CENTROID_LEARNING.MATCHING;
                else if (strVal == CENTROID_LEARNING.NONMATCHING.ToString())
                    p.centroid_learning = CENTROID_LEARNING.NONMATCHING;
            }
 
            if ((strVal = rp.FindValue("distance_calculation")) != null)
            {
                if (strVal == DISTANCE_CALCULATION.MANHATTAN.ToString())
                    p.distance_calculation = DISTANCE_CALCULATION.MANHATTAN;
            }
 
            if ((strVal = rp.FindValue("matching_distance_scale")) != null)
                p.matching_distance_scale = ParseDouble(strVal);
 
            return p;
        }
    }
}