BlobCollection.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using System.IO;
using System.Globalization;
 
namespace MyCaffe.common
{
    public class BlobCollection<T> : IEnumerable<Blob<T>>, IDisposable 
    {
        List<Blob<T>> m_rgBlobs = new List<Blob<T>>();
 
        public BlobCollection()
        {
        }
 
        public int Count
        {
            get { return m_rgBlobs.Count; }
        }
 
        public Blob<T> this[int nIdx]
        {
            get { return m_rgBlobs[nIdx]; }
            set { m_rgBlobs[nIdx] = value; }
        }
 
        public Blob<T> this[string strName]
        {
            get
            {
                Blob<T> blob = FindBlob(strName);
                if (blob != null)
                    return blob;
 
                throw new Exception("Could not find the blob named '" + strName + "' in the collection.");
            }
        }
 
        public Blob<T> FindBlob(string strName)
        {
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                if (m_rgBlobs[i] != null && m_rgBlobs[i].Name == strName)
                    return m_rgBlobs[i];
            }
 
            return null;
        }
 
        public void Insert(int nIdx, Blob<T> b)
        {
            m_rgBlobs.Insert(nIdx, b);
        }
 
        public void Add(Blob<T> b)
        {
            m_rgBlobs.Add(b);
        }
 
        public void Add(BlobCollection<T> rg)
        {
            if (rg == null)
                return;
 
            foreach (Blob<T> b in rg)
            {
                m_rgBlobs.Add(b);
            }
        }
 
        public bool Remove(Blob<T> b)
        {
            return m_rgBlobs.Remove(b);
        }
 
        public void RemoveAt(int nIdx)
        {
            m_rgBlobs.RemoveAt(nIdx);
        }
 
        public void Clear(bool bDispose = false)
        {
            if (bDispose)
            {
                foreach (Blob<T> b in m_rgBlobs)
                {
                    b.Dispose();
                }
            }
 
            m_rgBlobs.Clear();
        }
 
        public bool Contains(Blob<T> blob)
        {
            return m_rgBlobs.Contains(blob);
        }
 
        public BlobCollection<T> FindRelatedBlobs(Blob<T> b)
        {
            BlobCollection<T> rg = new BlobCollection<T>();
 
            foreach (Blob<T> b1 in m_rgBlobs)
            {
                if (b1 != null && b1.Name.Contains(b.Name))
                    rg.Add(b1);
            }
 
            return rg;
        }
 
        public IEnumerator<Blob<T>> GetEnumerator()
        {
            return m_rgBlobs.GetEnumerator();
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return m_rgBlobs.GetEnumerator();
        }
 
        public BlobCollection<T> Clone()
        {
            BlobCollection<T> col = new BlobCollection<T>();
 
            foreach (Blob<T> b in m_rgBlobs)
            {
                col.Add(b.Clone());
            }
 
            return col;
        }
 
        public void ReshapeLike(BlobCollection<T> src)
        {
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                m_rgBlobs[i].ReshapeLike(src[i]);
            }
        }
 
        public void ReshapeLike(Blob<T> blob)
        {
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                m_rgBlobs[i].ReshapeLike(blob);
            }
        }
 
        public void Reshape(int[] rgShape)
        {
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                m_rgBlobs[i].Reshape(rgShape);
            }
        }
 
        public void Reshape(int nN, int nC, int nH, int nW)
        {
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                m_rgBlobs[i].Reshape(nN, nC, nH, nW);
            }
        }
 
        public void CopyFrom(BlobCollection<T> bSrc, bool bCopyDiff = false)
        {
            if (Count != bSrc.Count)
                throw new Exception("The source and destination should have the same count.");
 
            for (int i = 0; i < bSrc.Count; i++)
            {
                m_rgBlobs[i].CopyFrom(bSrc[i], bCopyDiff, true);
            }
        }
 
        public void Accumulate(CudaDnn<T> cuda, BlobCollection<T> src, bool bAccumulateDiff)
        {
            for (int i = 0; i < src.Count; i++)
            {
                Blob<T> bSrc = src[i];
                Blob<T> bDst = m_rgBlobs[i];
                int nSrcCount = bSrc.count();
                int nDstCount = bDst.count();
 
                if (nSrcCount != nDstCount)
                    throw new Exception("The src and dst blobs at index #" + i.ToString() + " have different sizes!");
 
                if (bAccumulateDiff)
                {
                    if (bSrc.DiffExists && bDst.DiffExists)
                        cuda.add(nSrcCount, bSrc.gpu_diff, bDst.gpu_diff, bDst.mutable_gpu_diff);
                }
                else
                {
                    cuda.add(nSrcCount, bSrc.gpu_data, bDst.gpu_data, bDst.mutable_gpu_data);
                }
            }
        }
 
        public void SetDiff(double df)
        {
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                m_rgBlobs[i].SetDiff(df);
            }
        }
 
        public void SetData(double df)
        {
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                m_rgBlobs[i].SetData(df);
            }
        }
 
        public BlobCollection<T> MathSub(BlobCollection<T> col, bool bSkipFirstItem)
        {
            if (col.Count != m_rgBlobs.Count)
                throw new Exception("The input blob collection must have the same count at this blob collection!");
 
            BlobCollection<T> colOut = new BlobCollection<T>();
 
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                if (i > 0 || !bSkipFirstItem)
                    colOut.Add(m_rgBlobs[i].MathSub(col[i]));
            }
 
            return colOut;
        }
 
        public BlobCollection<T> MathAdd(BlobCollection<T> colA, double dfScale, bool bSkipFirstItem)
        {
            if (colA.Count != m_rgBlobs.Count)
                throw new Exception("The input blob collection must have the same count at this blob collection!");
 
            BlobCollection<T> colOut = new BlobCollection<T>();
            T fScale = (T)Convert.ChangeType(dfScale, typeof(T));
 
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                if (i > 0 || !bSkipFirstItem)
                    colOut.Add(m_rgBlobs[i].MathAdd(colA[i], fScale));
            }
 
            return colOut;
        }
 
        public BlobCollection<T> MathDiv(double dfVal, bool bSkipFirstItem)
        {
            BlobCollection<T> colOut = new BlobCollection<T>();
            T fVal = (T)Convert.ChangeType(dfVal, typeof(T));
 
            for (int i = 0; i < m_rgBlobs.Count; i++)
            {
                if (i > 0 || !bSkipFirstItem)
                    colOut.Add(m_rgBlobs[i].MathDiv(fVal));
            }
 
            return colOut;
        }
 
        public void Save(BinaryWriter bw, bool bData, bool bDiff)
        {
            bw.Write(m_rgBlobs.Count);
 
            foreach (Blob<T> b in m_rgBlobs)
            {
                b.Save(bw, bData, bDiff);
            }
        }
 
        public static BlobCollection<T> Load(CudaDnn<T> cuda, Log log, BinaryReader br, bool bData, bool bDiff)
        {
            BlobCollection<T> col = new BlobCollection<T>();
            int nCount = br.ReadInt32();
 
            for (int i = 0; i < nCount; i++)
            {
                col.Add(Blob<T>.Load(cuda, log, br, bData, bDiff));
            }
 
            return col;
        }
 
        public bool Share(Blob<T> b, List<int> rgMinShape, bool bThrowExceptions, bool bAllowEndsWith = false)
        {
            int nCount = 0;
 
            if (rgMinShape != null && rgMinShape.Count > 0)
            {
                nCount = rgMinShape[0];
                for (int i = 1; i < rgMinShape.Count; i++)
                {
                    nCount *= rgMinShape[i];
                }
            }
 
            foreach (Blob<T> blobShare in m_rgBlobs)
            {
                if (blobShare.Name == b.Name || (bAllowEndsWith && blobShare.Name.EndsWith(b.Name)))
                {
                    if (nCount > 0)
                    {
                        if (blobShare.count() < nCount)
                        {
                            if (bThrowExceptions)
                                throw new Exception("The blob to be shared is smaller that the expected minimum count!");
 
                            return false;
                        }
                    }
 
                    b.Share(blobShare);
                    return true;
                }
            }
 
            return false;
        }
 
        public bool SnapshotRequested(bool bReset)
        {
            bool bRequested = false;
 
            foreach (Blob<T> blob in m_rgBlobs)
            {
                if (blob.snapshot_requested)
                {
                    bRequested = true;
 
                    if (bReset)
                        blob.snapshot_requested = false;
                }
            }
 
            return bRequested;
        }
 
        public Dictionary<string, Tuple<double, double, double, double>> CollectMinMax(Blob<T> blobWork, bool bDiff = false)
        {
            Dictionary<string, Tuple<double, double, double, double>> rgMinMax = new Dictionary<string, Tuple<double, double, double, double>>();
            Dictionary<string, int> rgDuplicates = new Dictionary<string, int>();
 
            foreach (Blob<T> b in m_rgBlobs)
            {
                Tuple<double, double, double, double> minmax = bDiff ? b.minmax_diff(blobWork, true) : b.minmax_data(blobWork, true);
                string strName = b.Name;
 
                if (rgMinMax.ContainsKey(strName))
                {
                    if (!rgDuplicates.ContainsKey(strName))
                        rgDuplicates.Add(strName, 1);
                    else
                        rgDuplicates[strName]++;
 
                    strName = b.Name + "_DUPLICATE_NAME_" + rgDuplicates[strName].ToString();
                }    
 
                rgMinMax.Add(strName, minmax);
            }
 
            return rgMinMax;
        }
 
        public void Dispose()
        {
            foreach (Blob<T> b in m_rgBlobs)
            {
                b.Dispose();
            }
 
            m_rgBlobs.Clear();
        }
    }
}