DebugInformation.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MyCaffe.layers;
 
namespace MyCaffe.common
{
    public class DebugInformation<T> : IDisposable
    {
        string m_strName;
        double m_dfExtraInfo = 0;
        Blob<T> m_blobWork;
        bool m_bDetectNans = false;
        List<LayerDebugInformation<T>> m_rgLayerInfo = new List<LayerDebugInformation<T>>();
 
        public DebugInformation(string strName, Blob<T> work, bool bDetectNans)
        {
            m_strName = strName;
            m_blobWork = work;
            m_bDetectNans = bDetectNans;
        }
 
        public void Dispose()
        {
            if (m_blobWork != null)
            {
                m_blobWork.Dispose();
                m_blobWork = null;
            }
        }
 
        public LayerDebugInformation<T> FindLayer(string strLayer)
        {
            foreach (LayerDebugInformation<T> layer in m_rgLayerInfo)
            {
                if (layer.Name == strLayer)
                    return layer;
            }
 
            return null;
        }
 
        public void Add(Layer<T> layer, BlobCollection<T> colBottomBlobs, BlobCollection<T> colTopBlobs)
        {
            m_rgLayerInfo.Add(new LayerDebugInformation<T>(layer, colBottomBlobs, colTopBlobs, m_blobWork, m_bDetectNans));
        }
 
        public string Name
        {
            get { return m_strName; }
        }
 
        public double ExtraInfo
        {
            get { return m_dfExtraInfo; }
            set { m_dfExtraInfo = value; }
        }
 
        public List<LayerDebugInformation<T>> LayerInfoList
        {
            get { return m_rgLayerInfo; }
        }
 
        public bool Compare(DebugInformation<T> dbg)
        {
            if (dbg.Name != m_strName)
                return false;
 
            if (dbg.m_rgLayerInfo.Count != m_rgLayerInfo.Count)
                return false;
 
            for (int i = 0; i < m_rgLayerInfo.Count; i++)
            {
                if (!dbg.m_rgLayerInfo[i].Compare(m_rgLayerInfo[i]))
                    return false;
            }
 
            return true;
        }
 
        public string DetectFirstNaN(out string strType)
        {
            for (int i = 0; i< m_rgLayerInfo.Count; i++)
            {
                LayerDebugInformation<T> dbg = m_rgLayerInfo[i];
                string strBlobNan = dbg.DetectFirstNaN(out strType);
 
                if (strBlobNan != null)
                    return strBlobNan;
            }
 
            strType = null;
            return null;
        }
 
        public string DetectLastNaN(out string strType)
        {
            for (int i = m_rgLayerInfo.Count - 1; i >= 0; i--)
            {
                LayerDebugInformation<T> dbg = m_rgLayerInfo[i];
                string strBlobNan = dbg.DetectLastNaN(out strType);
 
                if (strBlobNan != null)
                    return strBlobNan;
            }
 
            strType = null;
            return null;
        }
 
        public override string ToString()
        {
            return m_strName;
        }
    }
 
    public class LayerDebugInformation<T>
    {
        string m_strName;
        string m_strType;
        double m_dfForwardTiming = 0;
        double m_dfForwardTimingAve = 0;
        double m_dfBackwardTiming = 0;
        double m_dfBackwardTimingAve = 0;
        List<BlobDebugInformation<T>> m_rgBlobInfo = new List<BlobDebugInformation<T>>();
 
        public LayerDebugInformation(Layer<T> layer, BlobCollection<T> colBottom, BlobCollection<T> colTop, Blob<T> work, bool bDetectNans)
        {
            m_strName = layer.layer_param.name;
            m_strType = layer.type.ToString();
            m_dfForwardTiming = layer.forward_timing;
            m_dfForwardTimingAve = layer.forward_timing_average;
            m_dfBackwardTiming = layer.backward_timing;
            m_dfBackwardTimingAve = layer.backward_timing_average;
 
            foreach (Blob<T> b in colBottom)
            {
                m_rgBlobInfo.Add(new BlobDebugInformation<T>(b, work, BlobDebugInformation<T>.BLOBTYPE.DATA, BlobDebugInformation<T>.LOCATION.BOTTOM, bDetectNans));
            }
 
            foreach (Blob<T> b in colTop)
            {
                m_rgBlobInfo.Add(new BlobDebugInformation<T>(b, work, BlobDebugInformation<T>.BLOBTYPE.DATA, BlobDebugInformation<T>.LOCATION.TOP, bDetectNans));
            }
 
            foreach (Blob<T> b in layer.blobs)
            {
                m_rgBlobInfo.Add(new BlobDebugInformation<T>(b, work, BlobDebugInformation<T>.BLOBTYPE.PARAM, BlobDebugInformation<T>.LOCATION.NONE, bDetectNans));
            }
 
            foreach (Blob<T> b in layer.internal_blobs)
            {
                m_rgBlobInfo.Add(new BlobDebugInformation<T>(b, work, BlobDebugInformation<T>.BLOBTYPE.INTERNAL, BlobDebugInformation<T>.LOCATION.NONE, bDetectNans));
            }
        }
 
        public string Name
        {
            get { return m_strName; }
        }
 
        public string Type
        {
            get { return m_strType; }
        }
 
        public double ForwardTiming
        {
            get { return m_dfForwardTiming; }
        }
 
        public double ForwardTimingAverage
        {
            get { return m_dfForwardTimingAve; }
        }
 
        public double BackwardTiming
        {
            get { return m_dfBackwardTiming; }
        }
 
        public double BackwardTimingAverage
        {
            get { return m_dfBackwardTimingAve; }
        }
 
        public List<BlobDebugInformation<T>> BlobInfoList
        {
            get { return m_rgBlobInfo; }
        }
 
        public BlobDebugInformation<T> FindBlob(string strBlob)
        {
            foreach (BlobDebugInformation<T> blob in m_rgBlobInfo)
            {
                if (blob.Name == strBlob)
                    return blob;
            }
 
            return null;
        }
 
        public bool Compare(LayerDebugInformation<T> dbg)
        {
            if (dbg.Name != m_strName)
                return false;
 
            if (dbg.Type != m_strType)
                return false;
 
            if (dbg.m_rgBlobInfo.Count != m_rgBlobInfo.Count)
                return false;
 
            for (int i = 0; i < m_rgBlobInfo.Count; i++)
            {
                if (!dbg.m_rgBlobInfo[i].Compare(m_rgBlobInfo[i]))
                    return false;
            }
 
            return true;
        }
 
        public string DetectFirstNaN(out string strType)
        {
            for (int i = 0; i < m_rgBlobInfo.Count; i++)
            {
                BlobDebugInformation<T> dbg = m_rgBlobInfo[i];
                string strBlobNan = dbg.DetectFirstNaN(out strType);
 
                if (strBlobNan != null)
                    return strBlobNan;
            }
 
            strType = null;
 
            return null;
        }
 
        public string DetectLastNaN(out string strType)
        {
            for (int i=m_rgBlobInfo.Count-1; i>=0; i--)
            {
                BlobDebugInformation<T> dbg = m_rgBlobInfo[i];
                string strBlobNan = dbg.DetectLastNaN(out strType);
 
                if (strBlobNan != null)
                    return strBlobNan;
            }
 
            strType = null;
 
            return null;
        }
 
        public override string ToString()
        {
            return m_strName + " (" + m_strType + ")";
        }
    }
 
    public class BlobDebugInformation<T>
    {
        BLOBTYPE m_type;
        LOCATION m_location;
        string m_strName;
        string m_strSize;
        double m_dfDataMin;
        double m_dfDataMax;
        double m_dfDiffMin;
        double m_dfDiffMax;
        double m_dfDataNanCount = 0;
        double m_dfDataInfCount = 0;
        double m_dfDiffNanCount = 0;
        double m_dfDiffInfCount = 0;
 
        public enum BLOBTYPE
        {
            DATA,
            PARAM,
            INTERNAL
        }
 
        public enum LOCATION
        {
            NONE,
            BOTTOM,
            TOP
        }
 
        public BlobDebugInformation(Blob<T> b, Blob<T> work, BLOBTYPE type, LOCATION loc = LOCATION.NONE, bool bDetectNans = false)
        {
            m_type = type;
            m_location = loc;
            m_strName = b.Name;
            m_strSize = b.ToSizeString();
 
            Tuple<double, double, double, double> data = b.minmax_data(work, bDetectNans);
            Tuple<double, double, double, double> diff = b.minmax_diff(work, bDetectNans);
 
            m_dfDataMin = data.Item1;
            m_dfDataMax = data.Item2;
            m_dfDataNanCount = data.Item3;
            m_dfDataInfCount = data.Item4;
            m_dfDiffMin = diff.Item1;
            m_dfDiffMax = diff.Item2;
            m_dfDiffNanCount = diff.Item3;
            m_dfDiffInfCount = diff.Item4;
        }
 
        public string Name
        {
            get { return m_strName; }
        }
 
        public string Size
        {
            get { return m_strSize; }
        }
 
        public double DataMinValue
        {
            get
            {
                if (DiffNanCount > 0)
                    return double.NaN;
 
                if (DiffInfCount > 0)
                    return double.PositiveInfinity;
 
                return m_dfDataMin;
            }
        }
 
        public double DataMaxValue
        {
            get
            {
                if (DiffNanCount > 0)
                    return double.NaN;
 
                if (DiffInfCount > 0)
                    return double.PositiveInfinity;
 
                return m_dfDataMax;
            }
        }
 
        public double DataNanCount
        {
            get { return m_dfDataNanCount; }
        }
 
        public double DataInfCount
        {
            get { return m_dfDataInfCount; }
        }
 
        public double DiffMinValue
        {
            get
            {
                if (DiffNanCount > 0)
                    return double.NaN;
 
                if (DiffInfCount > 0)
                    return double.PositiveInfinity;
 
                return m_dfDiffMin;
            }
        }
 
        public double DiffMaxValue
        {
            get
            {
                if (DiffNanCount > 0)
                    return double.NaN;
 
                if (DiffInfCount > 0)
                    return double.PositiveInfinity;
 
                return m_dfDiffMax;
            }
        }
 
        public double DiffNanCount
        {
            get { return m_dfDiffNanCount; }
        }
 
        public double DiffInfCount
        {
            get { return m_dfDiffInfCount; }
        }
 
        public BLOBTYPE BlobType
        {
            get { return m_type; }
        }
 
        public LOCATION BlobLocation
        {
            get { return m_location; }
        }
 
        public bool Compare(BlobDebugInformation<T> dbg)
        {
            if (dbg.Name != m_strName)
                return false;
 
            if (dbg.Size != m_strSize)
                return false;
 
            if (dbg.BlobLocation != m_location)
                return false;
 
            if (dbg.BlobType != m_type)
                return false;
 
            if (dbg.DataMinValue != m_dfDataMin)
                return false;
 
            if (dbg.DataMaxValue != m_dfDataMax)
                return false;
 
            if (dbg.DataNanCount != m_dfDataNanCount)
                return false;
 
            if (dbg.DataInfCount != m_dfDiffInfCount)
                return false;
 
            if (dbg.DiffMinValue != m_dfDiffMin)
                return false;
 
            if (dbg.DiffMaxValue != m_dfDiffMax)
                return false;
 
            if (dbg.DiffNanCount != m_dfDiffNanCount)
                return false;
 
            if (dbg.DiffInfCount != m_dfDiffInfCount)
                return false;
 
            return true;
        }
 
        public string DetectFirstNaN(out string strType)
        {
            if (!isValid(m_dfDataMin))
            {
                strType = "data min";
                return m_strName;
            }
 
            if (!isValid(m_dfDataMax))
            {
                strType = "data max";
                return m_strName;
            }
 
            if (m_dfDataNanCount > 0)
            {
                strType = "data nan";
                return m_strName;
            }
 
            if (m_dfDataInfCount > 0)
            {
                strType = "data inf";
                return m_strName;
            }
 
            if (!isValid(m_dfDiffMin))
            {
                strType = "diff min";
                return m_strName;
            }
 
            if (!isValid(m_dfDiffMax))
            {
                strType = "diff max";
                return m_strName;
            }
 
            if (m_dfDiffNanCount > 0)
            {
                strType = "diff nan";
                return m_strName;
            }
 
            if (m_dfDiffInfCount > 0)
            {
                strType = "diff inf";
                return m_strName;
            }
 
            strType = null;
            return null;
        }
 
        public string DetectLastNaN(out string strType)
        {
            if (!isValid(m_dfDiffMin))
            {
                strType = "diff min";
                return m_strName;
            }
 
            if (!isValid(m_dfDiffMax))
            {
                strType = "diff max";
                return m_strName;
            }
 
            if (m_dfDiffNanCount > 0)
            {
                strType = "diff nan";
                return m_strName;
            }
 
            if (m_dfDiffInfCount > 0)
            {
                strType = "diff inf";
                return m_strName;
            }
 
            if (!isValid(m_dfDataMin))
            {
                strType = "data min";
                return m_strName;
            }
 
            if (!isValid(m_dfDataMax))
            {
                strType = "data max";
                return m_strName;
            }
 
            if (m_dfDataNanCount > 0)
            {
                strType = "data nan";
                return m_strName;
            }
 
            if (m_dfDataInfCount > 0)
            {
                strType = "data inf";
                return m_strName;
            }
 
            strType = null;
            return null;
        }
 
        private bool isValid(double df)
        {
            if (double.IsNaN(df))
                return false;
 
            if (double.IsInfinity(df))
                return false;
 
            return true;
        }
 
        public override string ToString()
        {
            return m_strName + " (" + m_strSize + ")";
        }
    }
}