BaseDataLayer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
using MyCaffe.common;
using MyCaffe.param;
using MyCaffe.data;
using MyCaffe.db.image;
 
namespace MyCaffe.layers
{
    public abstract class BaseDataLayer<T> : Layer<T>
    {
        protected DataTransformer<T> m_transformer;
        protected bool m_bOutputLabels;
        protected IXImageDatabaseBase m_imgdb;
        protected SourceDescriptor m_src;
        protected SimpleDatum m_imgMean = null;
 
        public BaseDataLayer(CudaDnn<T> cuda, Log log, LayerParameter p, IXDatabaseBase db)
            : base(cuda, log, p)
        {
            if (db != null)
            {
                if (db.GetVersion() != DB_VERSION.IMG_V1 && db.GetVersion() != DB_VERSION.IMG_V2)
                    throw new Exception("Currently only image databases are supported by the BaseDataLayer.");
 
                m_imgdb = (IXImageDatabaseBase)db;
 
                if (p.type == LayerParameter.LayerType.DATA ||
                    p.type == LayerParameter.LayerType.ANNOTATED_DATA)
                    m_src = m_imgdb.GetSourceByName(p.data_param.source);
 
                if (p.transform_param.use_imagedb_mean)
                {
                    if (db != null)
                        m_imgMean = db.GetItemMean(m_src.ID);
                    else
                        m_log.WriteLine("WARNING: The image database is NULL, and therefore no mean image can not be acquired.");
                }
            }
        }
 
        protected override void dispose()
        {
            if (m_transformer != null)
            {
                m_transformer.Dispose();
                m_transformer = null;
            }
        }
 
        protected virtual bool setupSourceDescriptor()
        {
            return false;
        }
 
        public SimpleDatum ImageMean
        {
            get { return m_imgMean; }
            set { m_imgMean = value; }
        }
 
        public override void LayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            setupSourceDescriptor();
 
            if (colTop.Count == 1)
                m_bOutputLabels = false;
            else
                m_bOutputLabels = true;
 
            int nC = 0;
            int nH = 0;
            int nW = 0;
 
            if (m_src != null)
            {
                nC = m_src.Channels;
                nH = m_src.Height;
                nW = m_src.Width;
            }
            else if (m_imgMean != null)
            {
                nC = m_imgMean.Channels;
                nH = m_imgMean.Height;
                nW = m_imgMean.Width;
            }
            else if (m_param.type == LayerParameter.LayerType.MEMORYDATA)
            {
                nC = (int)m_param.memory_data_param.channels;
                nH = (int)m_param.memory_data_param.height;
                nW = (int)m_param.memory_data_param.width;
            }
            else if (m_param.type == LayerParameter.LayerType.DUMMYDATA)
            {
                nC = (int)m_param.dummy_data_param.channels[0];
                nH = (int)m_param.dummy_data_param.height[0];
                nW = (int)m_param.dummy_data_param.height[0];
            }
            else if (m_param.type == LayerParameter.LayerType.INPUT)
            {
                if (m_param.input_param.shape[0].dim.Count > 1)
                    nC = (int)m_param.input_param.shape[0].dim[1];
 
                if (m_param.input_param.shape[0].dim.Count > 2)
                    nH = (int)m_param.input_param.shape[0].dim[2];
 
                if (m_param.input_param.shape[0].dim.Count > 3)
                    nW = (int)m_param.input_param.shape[0].dim[3];
            }
            else if (m_param.type == LayerParameter.LayerType.VIDEO_DATA)
            {
                nC = 3;
                nH = (int)m_param.video_data_param.video_height;
                nW = (int)m_param.video_data_param.video_width;
            }
 
            if (nC == 0 && nH == 0 && nW == 0)
                throw new Exception("The sizing of C, H, W cannot be zero for all three!");
 
            if (nC == 0)
                nC = 1;
 
            if (nH == 0)
                nH = 1;
 
            if (nW == 0)
                nW = 1;
 
            m_transformer = new DataTransformer<T>(m_cuda, m_log, m_param.transform_param, m_param.phase, nC, nH, nW, m_imgMean);
            m_transformer.InitRand();
 
            // The subclasses should setup the size of bottom and top.
            DataLayerSetUp(colBottom, colTop);
        }
 
        protected abstract void DataLayerSetUp(BlobCollection<T> colBottom, BlobCollection<T> colTop);
 
        public override void Reshape(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
        }
 
        protected override void backward(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
        {
        }
 
        public DataTransformer<T> Transformer
        {
            get { return m_transformer; }
        }
    }
}