ModelBuilder.cs

using MyCaffe.basecode;
using MyCaffe.param;
using MyCaffe.param.ssd;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.model
{
    public abstract class ModelBuilder
    {
        protected string m_strBaseDir;
        protected NetParameter m_net = new NetParameter();
        protected SolverParameter m_solver = new SolverParameter();
 
        public enum SCALE_BIAS
        {
            NONE,
            SCALE,
            BIAS
        }
 
        public ModelBuilder(string strBaseDir, NetParameter net = null, SolverParameter solver = null)
        {
            m_strBaseDir = strBaseDir.TrimEnd('\\', '/');
            m_net = net;
            m_solver = solver;
        }
 
        public abstract SolverParameter CreateSolver();
 
        public abstract NetParameter CreateModel(bool bDeploy = false);
 
        public abstract NetParameter CreateDeployModel();
 
        protected string getFileName(string strFile, string strSubDir)
        {
            string strOut = m_strBaseDir + "\\";
 
            if (!string.IsNullOrEmpty(strSubDir))
                strOut += strSubDir + "\\";
 
            strOut += strFile;
 
            return strOut;
        }
 
        protected abstract LayerParameter addExtraLayers(bool bUseBatchNorm = true, double dfLrMult = 1.0);
 
        protected LayerParameter findLayer(string strName)
        {
            foreach (LayerParameter p in m_net.layer)
            {
                if (p.name == strName)
                    return p;
            }
 
            return null;
        }
 
        protected NetParameter createNet(string strName)
        {
            NetParameter net = new NetParameter();
 
            net.name = strName;
 
            return net;
        }
 
        protected LayerParameter addDataLayer(string strSource, Phase phase, int nBatchSize = 32, bool bOutputLabel = true, TransformationParameter transform = null, string strName = "data", bool bSiamese = false)
        {
            LayerParameter data = new LayerParameter(LayerParameter.LayerType.DATA);
 
            data.include.Add(new NetStateRule(phase));
 
            if (transform != null)
                data.transform_param = transform;
 
            data.name = strName;
            data.data_param.batch_size = (uint)nBatchSize;
            data.data_param.source = strSource;
 
            if (bSiamese)
            {
                data.data_param.images_per_blob = 2;
                data.data_param.output_all_labels = true;
                data.data_param.balance_matches = true;
            }
 
            data.top.Clear();
            data.top.Add(strName);
 
            if (bOutputLabel)
                data.top.Add("label");
 
            m_net.layer.Add(data);
 
            return data;
        }
 
        protected LayerParameter addAnnotatedDataLayer(string strSource, Phase phase, int nBatchSize = 32, bool bOutputLabel = true, string strLabelMapFile = "", SimpleDatum.ANNOTATION_TYPE anno_type = SimpleDatum.ANNOTATION_TYPE.NONE, TransformationParameter transform = null, List<BatchSampler> rgSampler = null)
        {
            LayerParameter data = new LayerParameter(LayerParameter.LayerType.ANNOTATED_DATA);
 
            data.include.Add(new NetStateRule(phase));
 
            if (transform != null)
                data.transform_param = transform;
 
            data.annotated_data_param.label_map_file = strLabelMapFile;
 
            if (rgSampler != null)
                data.annotated_data_param.batch_sampler = rgSampler;
 
            data.annotated_data_param.anno_type = anno_type;
            data.name = "data";
            data.data_param.batch_size = (uint)nBatchSize;
            data.data_param.source = strSource;
 
            data.top.Clear();
            data.top.Add("data");
 
            if (bOutputLabel)
                data.top.Add("label");
 
            m_net.layer.Add(data);
 
            return data;
        }
 
        protected List<LayerParameter> createMultiBoxHead(LayerParameter data, int nNumClasses, List<MultiBoxHeadInfo> rgInfo, List<float> rgPriorVariance, bool bUseObjectness = false, bool bUseBatchNorm = true, double dfLrMult = 1.0, bool useScale = true, int nImageHt = 0, int nImageWd = 0, bool bShareLocation = true, bool bFlip = true, bool bClip = true, double dfOffset = 0.5, int nKernelSize = 1, int nPad = 0, string strConfPostfix = "", string strLocPostfix = "")
        {
            LayerParameter lastLayer;
            string strName;
 
            for (int i = 1; i < rgInfo.Count; i++)
            {
                if (!rgInfo[0].Verify(rgInfo[1]))
                    throw new Exception("The multi-bix header info must be consistent across all items.");
            }
 
            if (nNumClasses <= 0)
                throw new Exception("The number of classes must be > 0.");
 
            List<string> rgstrLocLayers = new List<string>();
            List<string> rgstrConfLayers = new List<string>();
            List<string> rgstrPriorBoxLayers = new List<string>();
            List<string> rgstrObjLayers = new List<string>();
 
            for (int i = 0; i < rgInfo.Count; i++)
            {
                LayerParameter fromLayer = findLayer(rgInfo[i].SourceLayer);
 
                //---------------------------------------------------
                // Get the normalize value.
                //---------------------------------------------------
                if (rgInfo[i].Normalization.HasValue && rgInfo[i].Normalization.Value != -1)
                {
                    LayerParameter norm = new LayerParameter(LayerParameter.LayerType.NORMALIZATION2);
                    norm.name = fromLayer.name + "_norm";
                    norm.normalization2_param.scale_filler = new FillerParameter("constant", rgInfo[i].Normalization.Value);
                    norm.normalization2_param.across_spatial = false;
                    norm.normalization2_param.channel_shared = false;
                    norm.top.Add(norm.name);
                    fromLayer = connectAndAddLayer(fromLayer, norm);
                }
 
                //---------------------------------------------------
                // Intermediate layers.
                //---------------------------------------------------
                if (rgInfo[i].InterLayerDepth.HasValue && rgInfo[i].InterLayerDepth.Value > 0)
                    fromLayer = addConvBNLayer(fromLayer.name, fromLayer.name + "_inter", bUseBatchNorm, true, (int)rgInfo[i].InterLayerDepth.Value, 3, 1, 1, dfLrMult);
 
                //---------------------------------------------------
                // Estimate number of priors per location given provided parameters.
                //---------------------------------------------------
                double? dfMinSize = rgInfo[i].MinSize;
                double? dfMaxSize = rgInfo[i].MaxSize;
                double? dfAspectHt = rgInfo[i].AspectRatioHeight;
                double? dfAspectWd = rgInfo[i].AspectRatioWidth;
                double? dfStepWd = rgInfo[i].StepWidth;
                double? dfStepHt = rgInfo[i].StepHeight;
                int nAspectLen = (dfAspectWd == dfAspectHt) ? 1 : 2;
                int nNumPriorsPerLocation = (dfMaxSize.HasValue) ? (2 + nAspectLen) : (1 + nAspectLen);
 
                if (bFlip)
                    nNumPriorsPerLocation += nAspectLen;
 
                //---------------------------------------------------
                // Create location prediction layer.
                //---------------------------------------------------
                int nNumLocOutput = nNumPriorsPerLocation * 4;
                if (!bShareLocation)
                    nNumLocOutput *= nNumClasses;
 
                strName = fromLayer.name + "_mbox_loc" + strLocPostfix;
                lastLayer = addConvBNLayer(fromLayer.name, strName, bUseBatchNorm, false, nNumLocOutput, nKernelSize, nPad, 1, dfLrMult);
 
                LayerParameter permute = new LayerParameter(LayerParameter.LayerType.PERMUTE);
                permute.name = strName + "_perm";
                permute.permute_param.order = new List<int>() { 0, 2, 3, 1 };
                permute.top.Add(permute.name);
                lastLayer = connectAndAddLayer(lastLayer, permute);
 
                LayerParameter flatten = new LayerParameter(LayerParameter.LayerType.FLATTEN);
                flatten.name = strName + "_flat";
                flatten.flatten_param.axis = 1;
                flatten.top.Add(flatten.name);
                lastLayer = connectAndAddLayer(lastLayer, flatten);
                rgstrLocLayers.Add(lastLayer.name);
 
                //---------------------------------------------------
                // Create confidence prediction layer.
                //---------------------------------------------------
                strName = fromLayer.name + "_mbox_conf" + strConfPostfix;
                int nNumConfOutput = nNumPriorsPerLocation * nNumClasses;
                lastLayer = addConvBNLayer(fromLayer.name, strName, bUseBatchNorm, false, nNumConfOutput, nKernelSize, nPad, 1, dfLrMult);
 
                permute = new LayerParameter(LayerParameter.LayerType.PERMUTE);
                permute.name = strName + "_perm";
                permute.permute_param.order = new List<int>() { 0, 2, 3, 1 };
                permute.top.Add(permute.name);
                lastLayer = connectAndAddLayer(lastLayer, permute);
 
                flatten = new LayerParameter(LayerParameter.LayerType.FLATTEN);
                flatten.name = strName + "_flat";
                flatten.flatten_param.axis = 1;
                flatten.top.Add(flatten.name);
                lastLayer = connectAndAddLayer(lastLayer, flatten);
                rgstrConfLayers.Add(lastLayer.name);
 
                //---------------------------------------------------
                // Create prior generation layer.
                //---------------------------------------------------
                strName = fromLayer.name + "_mbox_priorbox";
                LayerParameter priorbox = new LayerParameter(LayerParameter.LayerType.PRIORBOX);
                priorbox.name = strName;
                priorbox.top.Add(priorbox.name);
                priorbox.prior_box_param.min_size.Add((float)dfMinSize.Value);
                priorbox.prior_box_param.clip = bClip;
                priorbox.prior_box_param.variance = rgPriorVariance;
                priorbox.prior_box_param.offset = (float)dfOffset;
 
                if (dfMaxSize.HasValue)
                    priorbox.prior_box_param.max_size.Add((float)dfMaxSize.Value);
 
                if (dfAspectWd.HasValue)
                    priorbox.prior_box_param.aspect_ratio.Add((float)dfAspectWd.Value);
 
                if (dfAspectHt.HasValue)
                    priorbox.prior_box_param.aspect_ratio.Add((float)dfAspectHt.Value);
 
                if (dfStepWd.HasValue && dfStepHt.HasValue)
                {
                    if (dfStepWd.Value == dfStepHt.Value)
                    {
                        priorbox.prior_box_param.step = (float)dfStepWd.Value;
                    }
                    else
                    {
                        priorbox.prior_box_param.step_h = (float)dfStepHt.Value;
                        priorbox.prior_box_param.step_w = (float)dfStepWd.Value;
                    }
                }
 
                if (nImageHt != 0 && nImageWd != 0)
                {
                    if (nImageHt == nImageWd)
                    {
                        priorbox.prior_box_param.img_size = (uint)nImageHt;
                    }
                    else
                    {
                        priorbox.prior_box_param.img_h = (uint)nImageHt;
                        priorbox.prior_box_param.img_w = (uint)nImageWd;
                    }
                }
 
                lastLayer = connectAndAddLayer(fromLayer, priorbox);
                lastLayer.bottom.Add(data.top[0]);
                rgstrPriorBoxLayers.Add(lastLayer.name);
 
                //---------------------------------------------------
                // Create objectness prediction layer
                //---------------------------------------------------
                if (bUseObjectness)
                {
                    strName = fromLayer.name + "_mbox_objectness";
                    int nNumObjOutput = nNumPriorsPerLocation * 2;
                    lastLayer = addConvBNLayer(fromLayer.name, strName, bUseBatchNorm, false, nNumObjOutput, nKernelSize, nPad, 1, dfLrMult);
 
                    permute = new LayerParameter(LayerParameter.LayerType.PERMUTE);
                    permute.name = strName + "_perm";
                    permute.permute_param.order = new List<int>() { 0, 2, 3, 1 };
                    lastLayer = connectAndAddLayer(lastLayer, permute);
 
                    flatten = new LayerParameter(LayerParameter.LayerType.FLATTEN);
                    flatten.name = strName + "_flat";
                    flatten.flatten_param.axis = 1;
                    lastLayer = connectAndAddLayer(lastLayer, flatten);
                    rgstrObjLayers.Add(lastLayer.name);
                }
            }
 
            //---------------------------------------------------
            // Concatenate priorbox, loc, and conf layers.
            //---------------------------------------------------
            List<LayerParameter> rgMboxLayers = new List<LayerParameter>();
            strName = "mbox_loc";
 
            LayerParameter concat = new LayerParameter(LayerParameter.LayerType.CONCAT);
            concat.name = strName;
            concat.concat_param.axis = 1;
            concat.bottom = rgstrLocLayers;
            concat.top.Add(concat.name);
            m_net.layer.Add(concat);
            rgMboxLayers.Add(concat);
 
            strName = "mbox_conf";
            concat = new LayerParameter(LayerParameter.LayerType.CONCAT);
            concat.name = strName;
            concat.concat_param.axis = 1;
            concat.bottom = rgstrConfLayers;
            concat.top.Add(concat.name);
            m_net.layer.Add(concat);
            rgMboxLayers.Add(concat);
 
            strName = "mbox_priorbox";
            concat = new LayerParameter(LayerParameter.LayerType.CONCAT);
            concat.name = strName;
            concat.concat_param.axis = 2;
            concat.bottom = rgstrPriorBoxLayers;
            concat.top.Add(concat.name);
            m_net.layer.Add(concat);
            rgMboxLayers.Add(concat);
 
            if (bUseObjectness)
            {
                strName = "mbox_objectness";
                concat = new LayerParameter(LayerParameter.LayerType.CONCAT);
                concat.name = strName;
                concat.concat_param.axis = 1;
                concat.bottom = rgstrObjLayers;
                concat.top.Add(concat.name);
                m_net.layer.Add(concat);
                rgMboxLayers.Add(concat);
            }
 
            return rgMboxLayers;
        }
 
        protected LayerParameter addConvBNLayer(string strInputLayer, string strOutputLayer, bool bUseBatchNorm, bool bUseRelU, int nNumOutput, int nKernelSize, int nPad, int nStride, double dfLrMult = 1.0, int nDilation = 1, SCALE_BIAS useScale = SCALE_BIAS.SCALE, string strConvPrefix = "", string strConvPostfix = "", string strBnPrefix = "", string strBnPostfix = "_bn", string strScalePrefix = "", string strScalePostFix = "_scale", string strBiasPrefix = "", string strBiasPostfix = "_bias", bool bNamedParams = false, string strLayerPostfix = "", Phase phaseExclude = Phase.NONE)
        {
            LayerParameter lastLayer = findLayer(strInputLayer);
            string strName = strConvPrefix + strOutputLayer + strConvPostfix;
 
            LayerParameter.LayerType type = LayerParameter.LayerType.CONVOLUTION;
            LayerParameter convLayer = new LayerParameter(type);
            convLayer.convolution_param.weight_filler = new FillerParameter("xavier");
            convLayer.convolution_param.bias_filler = new FillerParameter("constant", 0);
            convLayer.convolution_param.bias_term = true;
            convLayer.name = strName + strLayerPostfix;
            convLayer.convolution_param.kernel_size.Add((uint)nKernelSize);
            convLayer.convolution_param.pad.Add((uint)nPad);
            convLayer.convolution_param.stride.Add((uint)nStride);
            convLayer.convolution_param.dilation.Add((uint)nDilation);
            convLayer.convolution_param.num_output = (uint)nNumOutput;
            convLayer.top.Add(convLayer.name);
 
            addExclusion(convLayer, phaseExclude);
 
            LayerParameter bnLayer = null;
            LayerParameter bnLayerL = null;
            LayerParameter scaleLayer = null;
            LayerParameter biasLayer = null;
            LayerParameter reluLayer = null;
 
            // Setup the BachNorm Layer
            if (bUseBatchNorm)
            {
                convLayer.parameters.Add(new ParamSpec(dfLrMult, 1.0, (bNamedParams) ? strName + "_w" : null));
                convLayer.convolution_param.weight_filler = new FillerParameter("gaussian", 0, 0, 0.01);
                convLayer.convolution_param.bias_term = false;
 
                bnLayer = new LayerParameter(LayerParameter.LayerType.BATCHNORM);
                strName = strBnPrefix + strOutputLayer + strBnPostfix;
                bnLayer.name = strName + strLayerPostfix;
                bnLayer.batch_norm_param.eps = 0.001;
                bnLayer.batch_norm_param.moving_average_fraction = 0.999;
                bnLayer.batch_norm_param.use_global_stats = false;
                bnLayer.parameters.Add(new ParamSpec(0.0, 0.0, (bNamedParams) ? strName + "_w1" : null));
                bnLayer.parameters.Add(new ParamSpec(0.0, 0.0, (bNamedParams) ? strName + "_w2" : null));
                bnLayer.parameters.Add(new ParamSpec(0.0, 0.0, (bNamedParams) ? strName + "_w3" : null));
                bnLayer.top.Add(bnLayer.name);
                addExclusion(bnLayer, phaseExclude);
 
                double dfBnLrMult = dfLrMult;
 
                // When using global stats, not updating scale/bias parameters.
                if (bnLayer.batch_norm_param.use_global_stats.GetValueOrDefault(false))
                    dfBnLrMult = 0;
 
                // Parameters for scale bias layer after batchnorm.
                if (useScale == SCALE_BIAS.SCALE)
                {
                    scaleLayer = new LayerParameter(LayerParameter.LayerType.SCALE);
                    strName = strScalePrefix + strOutputLayer + strScalePostFix;
                    scaleLayer.name = strName + strLayerPostfix;
                    scaleLayer.scale_param.bias_term = true;
                    scaleLayer.scale_param.filler = new FillerParameter("constant", 1.0);
                    scaleLayer.scale_param.bias_filler = new FillerParameter("constant", 0.0);
                    scaleLayer.parameters.Add(new ParamSpec(dfBnLrMult, 0.0, (bNamedParams) ? strName + "_w" : null));
                    scaleLayer.parameters.Add(new ParamSpec(dfBnLrMult, 0.0, (bNamedParams) ? strName + "_b" : null));
                    scaleLayer.top.Add(scaleLayer.name);
                    addExclusion(scaleLayer, phaseExclude);
                }
                else if (useScale == SCALE_BIAS.BIAS)
                {
                    biasLayer = new LayerParameter(LayerParameter.LayerType.BIAS);
                    strName = strBiasPrefix + strOutputLayer + strBiasPostfix;
                    biasLayer.name = strName + strLayerPostfix;
                    biasLayer.bias_param.filler = new FillerParameter("constant", 0.0);
                    biasLayer.parameters.Add(new ParamSpec(dfBnLrMult, 0.0, (bNamedParams) ? strName + "_w" : null));
                    biasLayer.top.Add(biasLayer.name);
                    addExclusion(biasLayer, phaseExclude);
                }
            }
            else
            {
                convLayer.parameters.Add(new ParamSpec(dfLrMult, 1.0, (bNamedParams) ? strName + "_w" : null));
                convLayer.parameters.Add(new ParamSpec(dfLrMult * 2, 0.0, (bNamedParams) ? strName + "_b" : null));
            }
 
            lastLayer = connectAndAddLayer(strInputLayer, convLayer);
 
            if (bnLayer != null)
                lastLayer = connectAndAddLayer(lastLayer, bnLayer, true, true);
 
            if (scaleLayer != null)
                lastLayer = connectAndAddLayer(lastLayer, scaleLayer, true, true);
 
            if (biasLayer != null)
                lastLayer = connectAndAddLayer(lastLayer, biasLayer);
 
            if (bUseRelU)
            {
                reluLayer = new LayerParameter(LayerParameter.LayerType.RELU);
                reluLayer.name = convLayer.name + "_relu";
                addExclusion(reluLayer, phaseExclude);
                lastLayer = connectAndAddLayer(lastLayer, reluLayer, true, true);
            }
 
            return lastLayer;
        }
 
        protected LayerParameter connectAndAddLayer(string fromLayer, LayerParameter toLayer, string fromLayer2 = null)
        {
            toLayer.bottom.Clear();
            toLayer.bottom.Add(fromLayer);
 
            if (fromLayer2 != null)
                toLayer.bottom.Add(fromLayer2);
 
            m_net.layer.Add(toLayer);
 
            return toLayer;
        }
 
        protected LayerParameter connectAndAddLayer(LayerParameter fromLayer, LayerParameter toLayer, bool bInPlace = false, bool bAdd = true, int nTopIdx = 0)
        {
            toLayer.bottom.Clear();
            toLayer.bottom.Add(fromLayer.top[nTopIdx]);
 
            if (bAdd)
                m_net.layer.Add(toLayer);
 
            if (bInPlace)
            {
                toLayer.top.Clear();
                toLayer.top.Add(fromLayer.top[nTopIdx]);
            }
 
            return toLayer;
        }
 
        protected LayerParameter connectAndAddLayer(List<LayerParameter> rgFromLayer, LayerParameter toLayer, bool bAdd = true)
        {
            toLayer.bottom.Clear();
 
            for (int i = 0; i < rgFromLayer.Count; i++)
            {
                toLayer.bottom.Add(rgFromLayer[i].top[0]);
            }
 
            if (bAdd)
                m_net.layer.Add(toLayer);
 
            return toLayer;
        }
 
        protected LayerParameter createConvolution(string strName, int nNumOutput, int nKernelSize, int nPad = 0, int nStride = 1, int nDilation = 1)
        {
            LayerParameter conv = new LayerParameter(LayerParameter.LayerType.CONVOLUTION);
            conv.name = strName;
            conv.convolution_param.num_output = (uint)nNumOutput;
            conv.convolution_param.kernel_size.Add((uint)nKernelSize);
            conv.convolution_param.pad.Add((uint)nPad);
            conv.convolution_param.stride.Add((uint)nStride);
            conv.convolution_param.dilation.Add((uint)nDilation);
            conv.convolution_param.weight_filler = new FillerParameter("xavier");
            conv.convolution_param.bias_filler = new FillerParameter("constant", 0.0);
            conv.parameters.Add(new ParamSpec(1.0, 1.0));
            conv.parameters.Add(new ParamSpec(2.0, 0.0));
            conv.top.Add(strName);
 
            return conv;
        }
 
        protected LayerParameter createPooling(string strName, PoolingParameter.PoolingMethod method, int nKernelSize, int nPad = 0, int nStride = 1)
        {
            LayerParameter pool = new LayerParameter(LayerParameter.LayerType.POOLING);
            pool.name = strName;
            pool.pooling_param.kernel_size.Add((uint)nKernelSize);
            pool.pooling_param.stride.Add((uint)nStride);
            pool.pooling_param.pad.Add((uint)nPad);
            pool.pooling_param.pool = method;
            pool.top.Add(strName);
 
            return pool;
        }
 
        protected LayerParameter addVGGBlock(LayerParameter lastLayer, int nBlockIdx, int nConvIdx, int nNumOutput, int nConvCount, bool? bNoPool, bool bDilatePool = false, int nKernelSize = 3, int nPad = 1, int nStride = 1, int nDilation = 1)
        {
            for (int i = 0; i < nConvCount; i++)
            {
                string strConvName = "conv" + nBlockIdx.ToString() + "_" + nConvIdx.ToString();
 
                LayerParameter conv = createConvolution(strConvName, nNumOutput, nKernelSize, nPad, nStride, nDilation);
                lastLayer = connectAndAddLayer(lastLayer, conv);
 
                LayerParameter relu = new LayerParameter(LayerParameter.LayerType.RELU);
                relu.name = "relu" + nBlockIdx.ToString();
                lastLayer = connectAndAddLayer(lastLayer, relu, true);
 
                nConvIdx++;
            }
 
            if (!bNoPool.HasValue)
                return lastLayer;
 
            if (bNoPool.Value)
            {
                string strConvName = "conv" + nBlockIdx.ToString() + "_" + nConvIdx.ToString();
                LayerParameter conv = createConvolution(strConvName, nNumOutput, 3, 1, 2);
                lastLayer = connectAndAddLayer(lastLayer, conv);
            }
            else
            {
                string strPoolName = "pool" + nBlockIdx.ToString();
                LayerParameter pool = (bDilatePool) ? createPooling(strPoolName, PoolingParameter.PoolingMethod.MAX, 3, 1, 1) : createPooling(strPoolName, PoolingParameter.PoolingMethod.MAX, 2, 0, 2);
                lastLayer = connectAndAddLayer(lastLayer, pool);
            }
 
            return lastLayer;
        }
 
        protected LayerParameter addVGGfc(LayerParameter lastLayer, int nBlockIdx, int nConvIdx, int nNumOutput, int nDilation, bool bDilated, bool bNoPool, bool bFullConv, bool bReduced, bool bDropout)
        {
            string strConvName = "conv" + nBlockIdx.ToString() + "_" + nConvIdx.ToString();
            string strPoolName = "pool" + nBlockIdx.ToString();
 
            if (bDilated)
            {
                if (bNoPool)
                {
                    LayerParameter conv = createConvolution(strConvName, nNumOutput, 3, 1, 1);
                    lastLayer = connectAndAddLayer(lastLayer, conv);
                }
                else
                {
                    LayerParameter pool = createPooling(strPoolName, PoolingParameter.PoolingMethod.MAX, 3, 1, 1);
                    lastLayer = connectAndAddLayer(lastLayer, pool);
                }
            }
            else
            {
                if (bNoPool)
                {
                    LayerParameter conv = createConvolution(strConvName, nNumOutput, 3, 1, 2);
                    lastLayer = connectAndAddLayer(lastLayer, conv);
                }
                else
                {
                    LayerParameter pool = createPooling(strPoolName, PoolingParameter.PoolingMethod.MAX, 2, 0, 2);
                    lastLayer = connectAndAddLayer(lastLayer, pool);
                }
            }
 
            if (bFullConv)
            {
                int nKernelSize;
 
                if (bDilated)
                {
                    if (bReduced)
                    {
                        nDilation *= 6;
                        nKernelSize = 3;
                        nNumOutput = 1024;
                    }
                    else
                    {
                        nDilation *= 2;
                        nKernelSize = 7;
                        nNumOutput = 4096;
                    }
                }
                else
                {
                    if (bReduced)
                    {
                        nDilation *= 3;
                        nKernelSize = 3;
                        nNumOutput = 1024;
                    }
                    else
                    {
                        nKernelSize = 7;
                        nNumOutput = 4096;
                    }
                }
 
                int nPad = (int)((nKernelSize + (nDilation - 1) * (nKernelSize - 1)) - 1) / 2;
                LayerParameter fc6 = createConvolution("fc6", nNumOutput, nKernelSize, nPad, 1, nDilation);
                lastLayer = connectAndAddLayer(lastLayer, fc6);
 
                LayerParameter relu = new LayerParameter(LayerParameter.LayerType.RELU);
                relu.name = "relu" + nBlockIdx.ToString();
                lastLayer = connectAndAddLayer(lastLayer, relu, true);
 
                if (bDropout)
                {
                    LayerParameter dropout = new LayerParameter(LayerParameter.LayerType.DROPOUT);
                    dropout.name = "dropout6";
                    dropout.dropout_param.dropout_ratio = 0.5;
                    lastLayer = connectAndAddLayer(lastLayer, dropout, true);
                }
 
                LayerParameter fc7 = createConvolution("fc7", nNumOutput, 1);
                lastLayer = connectAndAddLayer(lastLayer, fc7);
 
                if (bDropout)
                {
                    LayerParameter dropout = new LayerParameter(LayerParameter.LayerType.DROPOUT);
                    dropout.name = "dropout7";
                    dropout.dropout_param.dropout_ratio = 0.5;
                    lastLayer = connectAndAddLayer(lastLayer, dropout, true);
                }
            }
            else
            {
                LayerParameter fc6 = new LayerParameter(LayerParameter.LayerType.INNERPRODUCT);
                fc6.inner_product_param.num_output = 4096;
                fc6.name = "fc6";
                lastLayer = connectAndAddLayer(lastLayer, fc6, true);
 
                if (bDropout)
                {
                    LayerParameter dropout = new LayerParameter(LayerParameter.LayerType.DROPOUT);
                    dropout.name = "dropout6";
                    dropout.dropout_param.dropout_ratio = 0.5;
                    lastLayer = connectAndAddLayer(lastLayer, dropout, true);
                }
 
                LayerParameter fc7 = new LayerParameter(LayerParameter.LayerType.INNERPRODUCT);
                fc6.inner_product_param.num_output = 4096;
                fc6.name = "fc7";
                lastLayer = connectAndAddLayer(lastLayer, fc7);
 
                if (bDropout)
                {
                    LayerParameter dropout = new LayerParameter(LayerParameter.LayerType.DROPOUT);
                    dropout.name = "dropout7";
                    dropout.dropout_param.dropout_ratio = 0.5;
                    lastLayer = connectAndAddLayer(lastLayer, dropout, true);
                }
            }
 
            return lastLayer;
        }
 
        protected LayerParameter addVGGNetBody(LayerParameter lastLayer, bool bNeedFc = true, bool bFullConv = true, bool bReduced = true, bool bDilated = true, bool bNoPool = false, bool bDropout = false, List<string> rgstrFreezeLayers = null, bool bDilatePool4 = false)
        {
            lastLayer = addVGGBlock(lastLayer, 1, 1, 64, 2, bNoPool, false, 3, 1, 1);
            lastLayer = addVGGBlock(lastLayer, 2, 1, 128, 2, bNoPool, false, 3, 1, 1);
            lastLayer = addVGGBlock(lastLayer, 3, 1, 256, 3, bNoPool, false, 3, 1, 1);
            lastLayer = addVGGBlock(lastLayer, 4, 1, 512, 3, bNoPool, bDilatePool4, 3, 1, 1);
 
            int nDilation = (bDilatePool4) ? 2 : 1;
            int nKernelSize = 3;
            int nPad = (int)((nKernelSize + (nDilation - 1) * (nKernelSize - 1)) - 1) / 2;
            lastLayer = addVGGBlock(lastLayer, 5, 1, 512, 3, null, false, nKernelSize, nPad, 1, nDilation);
 
            if (bNeedFc)    
                lastLayer = addVGGfc(lastLayer, 5, 4, 512, nDilation, bDilated, bNoPool, bFullConv, bReduced, bDropout);
 
            if (rgstrFreezeLayers != null)
            {
                foreach (string strFreezeLayer in rgstrFreezeLayers)
                {
                    LayerParameter p = findLayer(strFreezeLayer);
                    if (p != null)
                        p.freeze_learning = true;
                }
            }
 
            return lastLayer;
        }
 
 
        protected LayerParameter addResBody(LayerParameter lastLayer, string strBlockName, int nOut2A, int nOut2B, int nOut2C, int nStride, bool bUseBranch1, int nDilation = 1, bool bNamedParams = false, string strLayerPostfix = "", Phase phaseExclude = Phase.NONE)
        {
            string strConvPrefix = "res_" + strBlockName;
            string strConvPostfix = "";
            string strBnPrefix = "bn_" + strBlockName;
            string strBnPostfix = "";
            string strScalePrefix = "scale_" + strBlockName;
            string strScalePostfix = "";
            SCALE_BIAS useScale = SCALE_BIAS.SCALE;
            string strBranch1 = lastLayer.name;
            string strBranch2;
            string strBranchName;
            string strOutName = lastLayer.name;
 
            if (bUseBranch1)
            {
                strBranchName = "_br1";
                lastLayer = addConvBNLayer(lastLayer.name, strBranchName, true, false, nOut2C, 1, 0, nStride, 1, nDilation, useScale, strConvPrefix, strConvPostfix, strBnPrefix, strBnPostfix, strScalePrefix, strScalePostfix, "", "_bias", bNamedParams, strLayerPostfix, phaseExclude);
                strBranch1 = lastLayer.top[0];
                strOutName = strBranch1;
                nStride = 1;
            }
 
            strBranchName = "_br2a";
            lastLayer = addConvBNLayer(strOutName, strBranchName, true, true, nOut2A, 1, 0, nStride, 1, nDilation, useScale, strConvPrefix, strConvPostfix, strBnPrefix, strBnPostfix, strScalePrefix, strScalePostfix, "", "_bias", bNamedParams, strLayerPostfix, phaseExclude);        
            strOutName = strConvPrefix + strBranchName + strLayerPostfix;
            strBranchName = "_br2b";
 
            if (nDilation == 1)
            {
                lastLayer = addConvBNLayer(strOutName, strBranchName, true, true, nOut2B, 3, 1, 1, 1, nDilation, useScale, strConvPrefix, strConvPostfix, strBnPrefix, strBnPostfix, strScalePrefix, strScalePostfix, "", "_bias", bNamedParams, strLayerPostfix, phaseExclude);
            }
            else
            {
                int nPad = (int)(((3 + (nDilation - 1) * 2) - 1) / 2);
                lastLayer = addConvBNLayer(strOutName, strBranchName, true, true, nOut2B, 3, nPad, 1, 1, nDilation, useScale, strConvPrefix, strConvPostfix, strBnPrefix, strBnPostfix, strScalePrefix, strScalePostfix, "", "_bias", bNamedParams, strLayerPostfix, phaseExclude);
            }
 
            strOutName = strConvPrefix + strBranchName + strLayerPostfix;
            strBranchName = "_br2c";
 
            lastLayer = addConvBNLayer(strOutName, strBranchName, true, false, nOut2C, 1, 0, 1, 1, 1, useScale, strConvPrefix, strConvPostfix, strBnPrefix, strBnPostfix, strScalePrefix, strScalePostfix, "", "_bias", bNamedParams, strLayerPostfix, phaseExclude);
            strBranch2 = lastLayer.top[0];
 
            LayerParameter eltwise = new LayerParameter(LayerParameter.LayerType.ELTWISE);
            eltwise.name = "res" + strBlockName + strLayerPostfix;
            eltwise.bottom.Add(strBranch1);
            eltwise.bottom.Add(strBranch2);
            eltwise.top.Add(eltwise.name);
            addExclusion(eltwise, phaseExclude);
            m_net.layer.Add(eltwise);
            lastLayer = eltwise;
 
            LayerParameter relu = new LayerParameter(LayerParameter.LayerType.RELU);
            relu.name = eltwise.name + "_relu";
            addExclusion(relu, phaseExclude);
            connectAndAddLayer(lastLayer, relu, true, true);
 
            return lastLayer;
        }
 
        protected void addExclusion(LayerParameter p, Phase phase)
        {
            if (phase == Phase.NONE)
                return;
 
            if (p.include.Count > 0)
                return;
 
            p.exclude.Add(new NetStateRule(phase));
        }
 
        protected LayerParameter addResNetBody(string strDataName, int nBlock3Count = 4, int nBlock4Count = 23, bool bUsePool5 = true, bool bUseDilationConv5 = false, bool bNamedParams = false, string strLayerPostfix = "", Phase phaseExclude = Phase.NONE)
        {
            string strConvPrefix = "";
            string strConvPostfix = "";
            string strBnPrefix = "bn_";
            string strBnPostfix = "";
            string strScalePrefix = "scale_";
            string strScalePostfix = "";
 
            LayerParameter lastLayer = addConvBNLayer(strDataName, "conv1", true, true, 64, 7, 3, 2, 1, 1, SCALE_BIAS.SCALE, strConvPrefix, strConvPostfix, strBnPrefix, strBnPostfix, strScalePrefix, strScalePostfix, "", "_bias", bNamedParams, strLayerPostfix, phaseExclude);
 
            LayerParameter pool = createPooling("pool1" + strLayerPostfix, PoolingParameter.PoolingMethod.MAX, 3, 0, 2);
            addExclusion(pool, phaseExclude);
            lastLayer = connectAndAddLayer(lastLayer, pool);
 
            lastLayer = addResBody(lastLayer, "2a", 64, 64, 256, 1, true, 1, bNamedParams, strLayerPostfix, phaseExclude);
            lastLayer = addResBody(lastLayer, "2b", 64, 64, 256, 1, false, 1, bNamedParams, strLayerPostfix, phaseExclude);
            lastLayer = addResBody(lastLayer, "2c", 64, 64, 256, 1, false, 1, bNamedParams, strLayerPostfix, phaseExclude);
 
            lastLayer = addResBody(lastLayer, "3a", 128, 128, 512, 2, true, 1, bNamedParams, strLayerPostfix, phaseExclude);
            for (int i = 1; i <= nBlock3Count; i++)
            {
                lastLayer = addResBody(lastLayer, "3b" + i.ToString(), 128, 128, 512, 1, false, 1, bNamedParams, strLayerPostfix, phaseExclude);
            }
 
            lastLayer = addResBody(lastLayer, "4a", 256, 256, 1024, 2, true, 1, bNamedParams, strLayerPostfix, phaseExclude);
            for (int i = 1; i <= nBlock4Count; i++)
            {
                lastLayer = addResBody(lastLayer, "4b" + i.ToString(), 256, 256, 1024, 1, false, 1, bNamedParams, strLayerPostfix, phaseExclude);
            }
 
            int nStride = 2;
            int nDilation = 1;
            if (bUseDilationConv5)
            {
                nStride = 1;
                nDilation = 2;
            }
 
            lastLayer = addResBody(lastLayer, "5a", 512, 512, 2048, nStride, true, nDilation, bNamedParams, strLayerPostfix, phaseExclude);
            lastLayer = addResBody(lastLayer, "5b", 512, 512, 2048, 1, false, nDilation, bNamedParams, strLayerPostfix, phaseExclude);
            lastLayer = addResBody(lastLayer, "5c", 512, 512, 2048, 1, false, nDilation, bNamedParams, strLayerPostfix, phaseExclude);
 
            if (bUsePool5)
            {
                LayerParameter pool5 = createPooling("pool5" + strLayerPostfix, PoolingParameter.PoolingMethod.AVE, 3, 0, 1);
                addExclusion(pool5, phaseExclude);
                pool5.pooling_param.global_pooling = true;
                lastLayer = connectAndAddLayer(lastLayer, pool5);
            }
           
            return lastLayer;
        }
 
        public NetParameter Net
        {
            get { return m_net; }
        }
 
        public SolverParameter Solver
        {
            get { return m_solver; }
        }
    }
 
    public class MultiBoxHeadInfo
    {
        string m_strSourceLayer;
        double? m_dfMinSize;
        double? m_dfMaxSize;
        double? m_dfStepWidth;
        double? m_dfStepHeight;
        double? m_dfAspectRatioHeight;
        double? m_dfAspectRatioWidth;
        double? m_dfNormalization;
        double? m_nInterLayerDepth;
 
        public MultiBoxHeadInfo(string strSrcLayer, double? dfMinSize = null, double? dfMaxSize = null, double? dfStepWidth = null, double? dfStepHeight = null, double? dfAspectRatioWidth = null, double? dfAspectRatioHeight = null, double? dfNormalization = null, int? nInterLayerDepth = null)
        {
            m_strSourceLayer = strSrcLayer;
            m_dfMinSize = dfMinSize;
            m_dfMaxSize = dfMaxSize;
            m_dfStepWidth = dfStepWidth;
            m_dfStepHeight = dfStepHeight;
            m_dfAspectRatioHeight = dfAspectRatioHeight;
            m_dfAspectRatioWidth = dfAspectRatioWidth;
            m_dfNormalization = dfNormalization;
            m_nInterLayerDepth = nInterLayerDepth;
        }
 
        private bool verify(double? df1, double? df2)
        {
            if ((df1.HasValue && !df2.HasValue) || (!df1.HasValue && df2.HasValue))
                return false;
 
            return true;
        }
 
        public bool Verify(MultiBoxHeadInfo info)
        {
            if (!verify(m_dfAspectRatioHeight, info.m_dfAspectRatioHeight))
                return false;
 
            if (!verify(m_dfAspectRatioWidth, info.m_dfAspectRatioWidth))
                return false;
 
            if (!verify(m_dfMaxSize, info.m_dfMaxSize))
                return false;
 
            if (!verify(m_dfMinSize, info.m_dfMinSize))
                return false;
 
            if (!verify(m_dfNormalization, info.m_dfNormalization))
                return false;
 
            if (!verify(m_dfStepWidth, info.m_dfStepWidth))
                return false;
 
            if (!verify(m_dfStepHeight, info.m_dfStepHeight))
                return false;
 
            if (!verify(m_nInterLayerDepth, info.m_nInterLayerDepth))
                return false;
 
            return true;
        }
 
        public string SourceLayer
        {
            get { return m_strSourceLayer; }
        }
 
        public double? MinSize
        {
            get { return m_dfMinSize; }
        }
 
        public double? MaxSize
        {
            get { return m_dfMaxSize; }
        }
 
        public double? StepHeight
        {
            get { return m_dfStepHeight; }
        }
 
        public double? StepWidth
        {
            get { return m_dfStepWidth; }
        }
 
        public double? AspectRatioHeight
        {
            get { return m_dfAspectRatioHeight; }
        }
 
        public double? AspectRatioWidth
        {
            get { return m_dfAspectRatioWidth; }
        }
 
        public double? Normalization
        {
            get { return m_dfNormalization; }
        }
 
        public double? InterLayerDepth
        {
            get { return m_nInterLayerDepth; }
        }
    }
}