LossLayer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.common;
using MyCaffe.param;
 
namespace MyCaffe.layers
{
    public abstract class LossLayer<T> : Layer<T>
    {
        public const double kLOG_THRESHOLD = 1e-20;
        protected bool m_bIgnoreLabels = false;
        protected LossParameter.NormalizationMode m_normalization = LossParameter.NormalizationMode.NONE;
        protected int m_nOuterNum = 0;
        protected int m_nInnerNum = 0;
        public event EventHandler<LossArgs> OnLoss;
        LossArgs m_lossArgs = null;
 
        public LossLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.LOSS;
            m_parentLayerType = LayerParameter.LayerType.LOSS;
        }
 
        protected void callLossEvent(Blob<T> blob)
        {
            if (OnLoss == null)
                return;
 
            if (m_lossArgs == null)
                m_lossArgs = new LossArgs(blob.count(), blob.shape());
 
            float[] rgData = convertF(blob.mutable_cpu_data);
            Array.Copy(rgData, m_lossArgs.Data, rgData.Length);
 
            OnLoss(this, m_lossArgs);
        }
 
        protected virtual double get_normalizer(LossParameter.NormalizationMode normalization_mode, int nValidCount)
        {
            return GetNormalizer(normalization_mode, m_nOuterNum, m_nInnerNum, nValidCount);
        }
 
 
        public double GetNormalizer(LossParameter.NormalizationMode normalization_mode, int nOuterNum, int nInnerNum, int nValidCount)
        {
            double dfNormalizer = 0.0;
 
            switch (normalization_mode)
            {
                case LossParameter.NormalizationMode.FULL:
                    m_log.CHECK_GT(nInnerNum, 0, "The inner number must be set.");
                    m_log.CHECK_GT(nOuterNum, 0, "The outer number must be set.");
                    dfNormalizer = nOuterNum * nInnerNum;
                    break;
 
                case LossParameter.NormalizationMode.VALID:
                    if (nValidCount == -1)
                    {
                        m_log.CHECK_GT(nInnerNum, 0, "The inner number must be set.");
                        m_log.CHECK_GT(nOuterNum, 0, "The outer number must be set.");
                        dfNormalizer = nOuterNum * nInnerNum;
                    }
                    else
                        dfNormalizer = nValidCount;
                    break;
 
                case LossParameter.NormalizationMode.BATCH_SIZE:
                    m_log.CHECK_GT(nOuterNum, 0, "The outer number must be set.");
                    dfNormalizer = nOuterNum;
                    break;
 
                case LossParameter.NormalizationMode.NONE:
                    dfNormalizer = 1.0;
                    break;
 
                default:
                    m_log.FAIL("Unknown normalization mode " + normalization_mode.ToString());
                    break;
            }
 
            // Some users will have no labels for some examples in order to 'turn off' a 
            // particular loss in a multi-taks setup.  The max prevents Nans in that case.
            return Math.Max(dfNormalizer, 1.0);
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return 2; }
        }
 
        public override int ExactNumTopBlobs
        {
            get { return 1; }
        }
 
        public override bool AutoTopBlobs
        {
            get { return true; }
        }
 
        public override bool AllowForceBackward(int nBottomIdx)
        {
            if (nBottomIdx != 1)
                return true;
 
            return false;
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            // LossLayers have non-zero (1) loss by default.
            if (m_param.loss_weight.Count == 0)
                m_param.loss_weight.Add(1.0);
 
            m_log.CHECK(!m_param.loss_param.normalize, "normalize is drepreciated, use 'normalization'.");
            if (!m_param.loss_param.normalization.HasValue)
                m_normalization = (m_param.loss_param.normalize) ? LossParameter.NormalizationMode.VALID : LossParameter.NormalizationMode.BATCH_SIZE;
            else
                m_normalization = m_param.loss_param.normalization.Value;
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_log.CHECK_EQ(colBottom[0].shape(0), colBottom[1].shape(0), "The data and label should have the same first dimension.  Data has shape '" + colBottom[0].shape_string + "' and label has shape '" + colBottom[1].shape_string + "'.");
            List<int> rgLossShape = new List<int>(); // Loss layers output a scalar, 0 axes.
            colTop[0].Reshape(rgLossShape);
            colTop[0].type = BLOB_TYPE.LOSS;
        }
    }
}