AccuracyDecodeLayer.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.beta
{
    public class AccuracyDecodeLayer<T> : Layer<T>
    {
        public AccuracyDecodeLayer(CudaDnn<T> cuda, Log log, LayerParameter p)
            : base(cuda, log, p)
        {
            m_type = LayerParameter.LayerType.ACCURACY_DECODE;
        }
 
        protected override void dispose()
        {
            base.dispose();
        }
 
        public override int ExactNumBottomBlobs
        {
            get { return 2; }
        }
 
        public override int ExactNumTopBlobs
        {
            get { return 1; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_log.CHECK_EQ((int)m_param.accuracy_param.top_k, 1, "Accuracy Encoding Layer only supports a topk = 1.");
            m_log.CHECK_EQ((int)m_param.accuracy_param.axis, 1, "Accuracy Encoding Layer expects axis to = 1.");
        }
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            List<int> rgTopShape = new List<int>(); // Accuracy is a scalar; 0 axes.
            colTop[0].Reshape(rgTopShape);
            colTop[0].type = BLOB_TYPE.ACCURACY;
        }
 
        protected override void forward(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_log.CHECK_EQ(colBottom[0].num, colBottom[1].num, "The bottom[0] and bottom[1] must have the same num.");
 
            int nNum = colBottom[0].num;
            int nClasses = colBottom[0].channels;
            int nLabelDim = colBottom[1].channels;
            float[] rgDecode = convertF(colBottom[0].update_cpu_data()); // num of items where each item contains a distance for each class.
            float[] rgLabel = convertF(colBottom[1].update_cpu_data());  // num of labels where labels are in pairs of label dim (we only use the first label).
            int nCorrectCount = 0;
            int nTotal = 0;
 
            for (int i = 0; i < nNum; i++)
            {
                int nExpectedLabel = (int)rgLabel[i * nLabelDim];
                int nActualLabel = -1;
                float fMin = float.MaxValue;
 
                for (int j = 0; j < nClasses; j++)
                {
                    float fDist = rgDecode[i * nClasses + j];
                    if (fDist < fMin)
                    {
                        fMin = fDist;
                        nActualLabel = j;
                    }
                }
 
                if (m_param.accuracy_param.IgnoreLabel(nExpectedLabel))
                    continue;
                
                if (nActualLabel == nExpectedLabel)
                    nCorrectCount++;
 
                nTotal++;
            }
 
            double dfAccuracy = (double)nCorrectCount / (double)nTotal;
 
            colTop[0].SetData(dfAccuracy, 0);
            colTop[0].Tag = m_param.accuracy_param.top_k;
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
            if (rgbPropagateDown[0])
                throw new NotImplementedException();
        }
    }
}