mycaffe/html/_ssd_pascal_model_builder_8cs_source.html

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 class SsdPascalModelBuilder : ModelBuilder

    {

        int m_nGpuID = 0;

        List<int> m_rgGpuID = new List<int>();

        int m_nBatchSize;

        int m_nAccumBatchSize;

        int m_nBatchSizePerDevice;

        int m_nIterSize;

        double m_dfBaseLr;

        double m_dfLrMult = 1;

        bool m_bUseBatchNorm = false;

        int m_nNumTestImage = 4952; // Evaluate on the whole test set.

        int m_nTestBatchSize = 8;

        int m_nTestIter;

        string m_strTrainDataSource = "VOC0712.training";

        string m_strTestDataSource = "VOC0712.testing";

        string m_strNameSizeFile = "data\\ssd\\VOC0712\\test_name_size.txt";

        string m_strLabelMapFile = "data\\ssd\\VOC0712\\labelmap_voc.prototxt";

        string m_strPreTrainModel = "models\\VGGNet\\VGG_ILSVRC_16_layers_fc_reduced.caffemodel";

        TransformationParameter m_transformTrain = null;

        TransformationParameter m_transformTest = null;

        DetectionEvaluateParameter m_detectionEval = null;

        DetectionOutputParameter m_detectionOut = null;


        // Batch sampler.

        int m_nResizeWidth = 300;

        int m_nResizeHeight = 300;

        List<BatchSampler> m_rgBatchSampler = new List<BatchSampler>();

        string m_strJob;

        string m_strModel;


        // MultiBoxLoss Parameters

        LossParameter.NormalizationMode m_normalizationMode = LossParameter.NormalizationMode.VALID;

        LayerParameter m_multiBoxLossLayer;

        List<float> m_rgPriorVariance;

        bool m_bFlip = true;

        bool m_bClip = false;

        int m_nNumClasses = 21;

        bool m_bShareLocation = true;

        int m_nBackgroundLabelId = 0;

        double m_dfNegPosRatio = 3.0;

        double m_dfLocWeight;

        List<MultiBoxHeadInfo> m_rgMultiBoxInfo;


        public SsdPascalModelBuilder(string strBaseDirectory, int nBatchSize = 32, int nAccumBatchSize = 32, List<int> rgGpuId = null, bool bUseBatchNorm = false, LossParameter.NormalizationMode normMode = LossParameter.NormalizationMode.VALID, NetParameter net = null)

            : base(strBaseDirectory, net)

        {

            if (rgGpuId == null)

                m_rgGpuID.Add(0);

            else

                m_rgGpuID = new List<int>(rgGpuId);


            m_strJob = "SSD_" + m_nResizeWidth.ToString() + "x" + m_nResizeHeight.ToString();

            // The model name is used when initially creating the NetParameter.

            m_strModel = "VGG_VOC0712_" + m_strJob;


            m_bUseBatchNorm = bUseBatchNorm;

            m_normalizationMode = normMode;


            m_nBatchSize = nBatchSize;

            m_nAccumBatchSize = nAccumBatchSize;

            m_nIterSize = m_nAccumBatchSize / m_nBatchSize;


            m_nBatchSizePerDevice = (m_rgGpuID.Count == 1) ? m_nBatchSize : m_nBatchSize / m_rgGpuID.Count;

            m_nIterSize = (int)Math.Ceiling((float)m_nAccumBatchSize / (m_nBatchSizePerDevice * m_rgGpuID.Count));

            m_nGpuID = m_rgGpuID[0];


            // Set the base learning rate.

            m_dfLocWeight = (m_dfNegPosRatio + 1.0) / 4.0;

            m_dfBaseLr = (m_bUseBatchNorm) ? 0.0004 : 0.00004;


            switch (m_normalizationMode)

            {

                case LossParameter.NormalizationMode.NONE:

                    m_dfBaseLr /= m_nBatchSizePerDevice;

                    break;


                case LossParameter.NormalizationMode.VALID:

                    m_dfBaseLr *= 25.0 / m_dfLocWeight;

                    break;


                case LossParameter.NormalizationMode.FULL:

                    // Roughly there are 2000 prior bboxes per images (TODO: calculate and use exact number).

                    m_dfBaseLr *= 2000;

                    break;

            }


            // Ideally the test_batch_size should be divisible by the num_test_image,

            // otherwise mAP will be slightly off the true value.

            m_nTestIter = (int)Math.Ceiling((float)m_nNumTestImage / (float)m_nTestBatchSize);


            //-------------------------------------------------------

            // Create the transformer for Training.

            //-------------------------------------------------------

            m_transformTrain = new TransformationParameter();

            m_transformTrain.mirror = true;

            m_transformTrain.color_order = TransformationParameter.COLOR_ORDER.BGR; // to support caffe models.

            m_transformTrain.mean_value.Add(104);

            m_transformTrain.mean_value.Add(117);

            m_transformTrain.mean_value.Add(123);

            m_transformTrain.resize_param = new ResizeParameter(true);

            m_transformTrain.resize_param.prob = 1;

            m_transformTrain.resize_param.resize_mode = ResizeParameter.ResizeMode.WARP;

            m_transformTrain.resize_param.height = (uint)m_nResizeHeight;

            m_transformTrain.resize_param.width = (uint)m_nResizeWidth;

            m_transformTrain.resize_param.interp_mode.Add(ResizeParameter.InterpMode.LINEAR);

            m_transformTrain.resize_param.interp_mode.Add(ResizeParameter.InterpMode.AREA);

            m_transformTrain.resize_param.interp_mode.Add(ResizeParameter.InterpMode.NEAREST);

            m_transformTrain.resize_param.interp_mode.Add(ResizeParameter.InterpMode.CUBIC);

            m_transformTrain.resize_param.interp_mode.Add(ResizeParameter.InterpMode.LANCZOS4);

            m_transformTrain.distortion_param = new DistortionParameter(true);

            m_transformTrain.distortion_param.brightness_prob = 0.5f;

            m_transformTrain.distortion_param.brightness_delta = 32;

            m_transformTrain.distortion_param.contrast_prob = 0.5f;

            m_transformTrain.distortion_param.contrast_lower = 0.5f;

            m_transformTrain.distortion_param.contrast_upper = 1.5f;

            m_transformTrain.distortion_param.saturation_prob = 0.5f;

            m_transformTrain.distortion_param.saturation_lower = 0.5f;

            m_transformTrain.distortion_param.saturation_upper = 1.5f;

            m_transformTrain.distortion_param.random_order_prob = 0.0f;

            m_transformTrain.expansion_param = new ExpansionParameter(true);

            m_transformTrain.expansion_param.prob = 0.5f;

            m_transformTrain.expansion_param.max_expand_ratio = 4.0f;

            m_transformTrain.emit_constraint = new EmitConstraint(true);

            m_transformTrain.emit_constraint.emit_type = EmitConstraint.EmitType.CENTER;


            //-------------------------------------------------------

            // Create the transformer for Testing.

            //-------------------------------------------------------

            m_transformTest = new TransformationParameter();

            m_transformTest.color_order = TransformationParameter.COLOR_ORDER.BGR; // to support caffe models.

            m_transformTest.mean_value.Add(104);

            m_transformTest.mean_value.Add(117);

            m_transformTest.mean_value.Add(123);

            m_transformTest.resize_param = new ResizeParameter(true);

            m_transformTest.resize_param.prob = 1;

            m_transformTest.resize_param.resize_mode = ResizeParameter.ResizeMode.WARP;

            m_transformTest.resize_param.height = (uint)m_nResizeHeight;

            m_transformTest.resize_param.width = (uint)m_nResizeWidth;

            m_transformTest.resize_param.interp_mode.Add(ResizeParameter.InterpMode.LINEAR);


            //-------------------------------------------------------

            // Create the batch samplers.

            //-------------------------------------------------------

            BatchSampler sampler = createSampler(1, 1);

            m_rgBatchSampler.Add(sampler);


            sampler = createSampler(50, 1, 0.3f, 1.0f, 0.5f, 2.0f, 0.1f);

            m_rgBatchSampler.Add(sampler);


            sampler = createSampler(50, 1, 0.3f, 1.0f, 0.5f, 2.0f, 0.3f);

            m_rgBatchSampler.Add(sampler);


            sampler = createSampler(50, 1, 0.3f, 1.0f, 0.5f, 2.0f, 0.5f);

            m_rgBatchSampler.Add(sampler);


            sampler = createSampler(50, 1, 0.3f, 1.0f, 0.5f, 2.0f, 0.7f);

            m_rgBatchSampler.Add(sampler);


            sampler = createSampler(50, 1, 0.3f, 1.0f, 0.5f, 2.0f, 0.9f);

            m_rgBatchSampler.Add(sampler);


            sampler = createSampler(50, 1, 0.3f, 1.0f, 0.5f, 2.0f, null, 1.0f);

            m_rgBatchSampler.Add(sampler);


            //-------------------------------------------------------

            // Create the Multi-box parameters.

            //-------------------------------------------------------

            m_multiBoxLossLayer = new LayerParameter(LayerParameter.LayerType.MULTIBOX_LOSS);

            m_multiBoxLossLayer.multiboxloss_param.loc_loss_type = MultiBoxLossParameter.LocLossType.SMOOTH_L1;

            m_multiBoxLossLayer.multiboxloss_param.conf_loss_type = MultiBoxLossParameter.ConfLossType.SOFTMAX;

            m_multiBoxLossLayer.multiboxloss_param.neg_pos_ratio = (float)m_dfNegPosRatio;

            m_multiBoxLossLayer.multiboxloss_param.num_classes = (uint)m_nNumClasses;

            m_multiBoxLossLayer.multiboxloss_param.loc_weight = (float)m_dfLocWeight;

            m_multiBoxLossLayer.multiboxloss_param.share_location = m_bShareLocation;

            m_multiBoxLossLayer.multiboxloss_param.match_type = MultiBoxLossParameter.MatchType.PER_PREDICTION;

            m_multiBoxLossLayer.multiboxloss_param.overlap_threshold = 0.5f;

            m_multiBoxLossLayer.multiboxloss_param.use_prior_for_matching = true;

            m_multiBoxLossLayer.multiboxloss_param.background_label_id = (uint)m_nBackgroundLabelId;

            m_multiBoxLossLayer.multiboxloss_param.use_difficult_gt = true;

            m_multiBoxLossLayer.multiboxloss_param.mining_type = MultiBoxLossParameter.MiningType.MAX_NEGATIVE;

            m_multiBoxLossLayer.multiboxloss_param.neg_overlap = 0.5f;

            m_multiBoxLossLayer.multiboxloss_param.code_type = PriorBoxParameter.CodeType.CENTER_SIZE;

            m_multiBoxLossLayer.multiboxloss_param.ignore_cross_boundary_bbox = false;

            m_multiBoxLossLayer.loss_param.normalization = m_normalizationMode;


            if (m_multiBoxLossLayer.multiboxloss_param.code_type == PriorBoxParameter.CodeType.CENTER_SIZE)

                m_rgPriorVariance = new List<float>() { 0.1f, 0.1f, 0.2f, 0.2f };

            else

                m_rgPriorVariance = new List<float>() { 0.1f };


            //-------------------------------------------------------

            // Create the Detection Output parameters.

            //-------------------------------------------------------

            m_detectionOut = new DetectionOutputParameter();

            m_detectionOut.num_classes = (uint)m_nNumClasses;

            m_detectionOut.share_location = m_bShareLocation;

            m_detectionOut.background_label_id = m_nBackgroundLabelId;

            m_detectionOut.nms_param = new NonMaximumSuppressionParameter(true);

            m_detectionOut.nms_param.nms_threshold = 0.45f;

            m_detectionOut.nms_param.top_k = 400;

            m_detectionOut.save_output_param = new SaveOutputParameter(true);

            m_detectionOut.save_output_param.output_directory = m_strBaseDir + "\\results";

            m_detectionOut.save_output_param.output_name_prefix = "comp4_det_test_";

            m_detectionOut.save_output_param.label_map_file = getFileName(m_strLabelMapFile, null);

            m_detectionOut.save_output_param.name_size_file = getFileName(m_strNameSizeFile, null);

            m_detectionOut.save_output_param.num_test_image = (uint)m_nNumTestImage;

            m_detectionOut.keep_top_k = 200;

            m_detectionOut.confidence_threshold = 0.01f;

            m_detectionOut.code_type = m_multiBoxLossLayer.multiboxloss_param.code_type;


            //-------------------------------------------------------

            // Create the Detection Evaluation parameters.

            //-------------------------------------------------------

            m_detectionEval = new DetectionEvaluateParameter();

            m_detectionEval.num_classes = (uint)m_nNumClasses;

            m_detectionEval.background_label_id = (uint)m_nBackgroundLabelId;

            m_detectionEval.overlap_threshold = 0.5f;

            m_detectionEval.evaulte_difficult_gt = false;

            m_detectionEval.name_size_file = getFileName(m_strNameSizeFile, null);


            //-------------------------------------------------------

            // Setup the MultiBox head layer info.

            //-------------------------------------------------------

            // conv4_3 ==> 38 x 38

            // fc7     ==> 19 x 19

            // conv6_2 ==> 10 x 10

            // conv7_2 ==>  5 x 5

            // conv8_2 ==>  3 x 3

            // conv9_2 ==>  1 x 1

            List<string> rgstrMboxSourceLayers = new List<string>() { "conv4_3", "fc7", "conv6_2", "conv7_2", "conv8_2", "conv9_2" };

            List<double> rgAspectWid = new List<double>() { 2, 2, 2, 2, 2, 2 };

            List<double> rgAspectHt = new List<double>() { 2, 3, 3, 3, 2, 2 };

            // L2 normalize conv4_3

            List<double> rgNormalization = new List<double>() { 20, -1, -1, -1, -1, -1 };

            List<double> rgStepsW = new List<double>() { 8, 16, 32, 64, 100, 300 };

            List<double> rgStepsH = new List<double>() { 8, 16, 32, 64, 100, 300 };

            int nMinDim = 300;

            // in percent %

            double dfMinRatio = 20;

            double dfMaxRatio = 90;

            double dfRatioStep = (int)Math.Floor((dfMaxRatio - dfMinRatio) / (rgstrMboxSourceLayers.Count - 2));

            List<double> rgMinSizes = new List<double>();

            List<double> rgMaxSizes = new List<double>();


            for (double dfRatio = dfMinRatio; dfRatio < dfMaxRatio + 1; dfRatio += dfRatioStep)

            {

                rgMinSizes.Add(nMinDim * dfRatio / 100.0);

                rgMaxSizes.Add(nMinDim * (dfRatio + dfRatioStep) / 100.0);

            }


            rgMinSizes.Insert(0, nMinDim * 10 / 100.0);

            rgMaxSizes.Insert(0, nMinDim * 20 / 100.0);


            m_rgMultiBoxInfo = new List<MultiBoxHeadInfo>();


            for (int i = 0; i < rgstrMboxSourceLayers.Count; i++)

            {

                string strSrc = rgstrMboxSourceLayers[i];

                double dfMinSize = rgMinSizes[i];

                double dfMaxSize = rgMaxSizes[i];

                double dfStepW = rgStepsW[i];

                double dfStepH = rgStepsH[i];

                double dfAspectW = rgAspectWid[i];

                double dfAspectH = rgAspectHt[i];

                double dfNorm = rgNormalization[i];


                m_rgMultiBoxInfo.Add(new MultiBoxHeadInfo(strSrc, dfMinSize, dfMaxSize, dfStepW, dfStepH, dfAspectW, dfAspectH, dfNorm, null));

            }

        }


        private BatchSampler createSampler(int nMaxTrials, int nMaxSample, float fMinScale = 1.0f, float fMaxScale = 1.0f, float fMinAspectRatio = 1.0f, float fMaxAspectRatio = 1.0f, float? fMinJaccardOverlap = null, float? fMaxJaccardOverlap = null)

        {

            BatchSampler sampler = new BatchSampler();

            sampler.max_trials = (uint)nMaxTrials;

            sampler.max_sample = (uint)nMaxSample;

            sampler.sampler.min_scale = fMinScale;

            sampler.sampler.max_scale = fMaxScale;

            sampler.sampler.min_aspect_ratio = fMinAspectRatio;

            sampler.sampler.max_aspect_ratio = fMaxAspectRatio;


            if (fMinJaccardOverlap.HasValue)

                sampler.sample_constraint.min_jaccard_overlap = fMinJaccardOverlap.Value;


            if (fMaxJaccardOverlap.HasValue)

                sampler.sample_constraint.max_jaccard_overlap = fMaxJaccardOverlap.Value;


            return sampler;

        }


        public override SolverParameter CreateSolver()

        {

            m_solver = new SolverParameter();

            m_solver.type = SolverParameter.SolverType.SGD;

            m_solver.base_lr = m_dfBaseLr;

            m_solver.weight_decay = 0.0005;

            m_solver.LearningRatePolicy = SolverParameter.LearningRatePolicyType.MULTISTEP;

            m_solver.stepvalue = new List<int>() { 80000, 100000, 120000 };

            m_solver.gamma = 0.1;

            m_solver.momentum = 0.9;

            m_solver.iter_size = m_nIterSize;

            m_solver.max_iter = 120000;

            m_solver.snapshot = 80000;

            m_solver.display = 10;

            m_solver.average_loss = 10;

            m_solver.device_id = m_nGpuID;

            m_solver.debug_info = false;

            m_solver.snapshot_after_train = true;


            // Test parameters.

            m_solver.test_iter.Add(m_nTestIter);

            m_solver.test_interval = 10000;

            m_solver.test_initialization = false;

            m_solver.eval_type = SolverParameter.EvaluationType.DETECTION;

            m_solver.ap_version = ApVersion.ELEVENPOINT;


            return m_solver;

        }


        public override NetParameter CreateModel(bool bDeploy = false)

        {

            string strLabelMapFile = getFileName(m_strLabelMapFile, null);

            LayerParameter data = null;


            m_net = createNet(m_strModel);


            if (!bDeploy)

                addAnnotatedDataLayer(m_strTrainDataSource, Phase.TRAIN, m_nBatchSizePerDevice, true, strLabelMapFile, SimpleDatum.ANNOTATION_TYPE.NONE, m_transformTrain, m_rgBatchSampler);


            data = addAnnotatedDataLayer(m_strTestDataSource, Phase.TEST, 1, true, strLabelMapFile, SimpleDatum.ANNOTATION_TYPE.NONE, m_transformTest);


            LayerParameter lastLayer = addVGGNetBody(data, true, true, true, true, false, false);

            lastLayer = addExtraLayers(m_bUseBatchNorm, m_dfLrMult);


            List<LayerParameter> rgMboxLayers = createMultiBoxHead(data, m_nNumClasses, m_rgMultiBoxInfo, m_rgPriorVariance, false, m_bUseBatchNorm, m_dfLrMult, true, 0, 0, m_bShareLocation, m_bFlip, m_bClip, 0.5, 3, 1);


            // Create the MultiboxLossLayer.

            if (!bDeploy)

            {

                string strName = "mbox_loss";

                LayerParameter mbox_loss = new LayerParameter(LayerParameter.LayerType.MULTIBOX_LOSS);

                mbox_loss.name = strName;

                mbox_loss.multiboxloss_param = m_multiBoxLossLayer.multiboxloss_param;

                mbox_loss.loss_param = m_multiBoxLossLayer.loss_param;

                mbox_loss.include.Add(new NetStateRule(Phase.TRAIN));

                mbox_loss.propagate_down = new List<bool>() { true, true, false, false };

                mbox_loss.top.Add(mbox_loss.name);

                connectAndAddLayer(rgMboxLayers, mbox_loss);

                mbox_loss.bottom.Add(data.top[1]); // GT.

            }


            //-------------------------------------------------------

            //  Add testing layers.

            //-------------------------------------------------------

            string strConfName = "mbox_conf";

            lastLayer = findLayer(strConfName);


            if (m_multiBoxLossLayer.multiboxloss_param.conf_loss_type == MultiBoxLossParameter.ConfLossType.SOFTMAX)

            {

                string strReshapeName = strConfName + "_reshape";

                LayerParameter reshape = new LayerParameter(LayerParameter.LayerType.RESHAPE);

                reshape.name = strReshapeName;

                reshape.top.Add(reshape.name);

                reshape.reshape_param.shape = new BlobShape(new List<int>() { 0, -1, (int)m_multiBoxLossLayer.multiboxloss_param.num_classes });

                if (!bDeploy)

                {

                    reshape.include.Add(new NetStateRule(Phase.TEST));

                    reshape.include.Add(new NetStateRule(Phase.RUN));

                }

                lastLayer = connectAndAddLayer(lastLayer, reshape);


                string strSoftmaxName = strConfName + "_softmax";

                LayerParameter softmax = new LayerParameter(LayerParameter.LayerType.SOFTMAX);

                softmax.name = strSoftmaxName;

                softmax.top.Add(softmax.name);

                softmax.softmax_param.axis = 2;

                if (!bDeploy)

                {

                    softmax.include.Add(new NetStateRule(Phase.TEST));

                    softmax.include.Add(new NetStateRule(Phase.RUN));

                }

                lastLayer = connectAndAddLayer(lastLayer, softmax);


                string strFlattentName = strConfName + "_flatten";

                LayerParameter flatten = new LayerParameter(LayerParameter.LayerType.FLATTEN);

                flatten.name = strFlattentName;

                flatten.top.Add(flatten.name);

                flatten.flatten_param.axis = 1;

                if (!bDeploy)

                {

                    flatten.include.Add(new NetStateRule(Phase.TEST));

                    flatten.include.Add(new NetStateRule(Phase.RUN));

                }

                lastLayer = connectAndAddLayer(lastLayer, flatten);


                rgMboxLayers[1] = lastLayer;

            }

            else

            {

                string strSigmoidName = strConfName + "_sigmoid";

                LayerParameter sigmoid = new LayerParameter(LayerParameter.LayerType.SIGMOID);

                sigmoid.name = strSigmoidName;

                sigmoid.top.Add(sigmoid.name);

                if (!bDeploy)

                {

                    sigmoid.include.Add(new NetStateRule(Phase.TEST));

                    sigmoid.include.Add(new NetStateRule(Phase.RUN));

                }


                lastLayer = connectAndAddLayer(lastLayer, sigmoid);

                rgMboxLayers[1] = lastLayer;

            }


            LayerParameter detectionOut = new LayerParameter(LayerParameter.LayerType.DETECTION_OUTPUT);

            detectionOut.name = "detection_output";

            detectionOut.top.Add(detectionOut.name);

            detectionOut.detection_output_param = m_detectionOut;

            if (!bDeploy)

            {

                detectionOut.include.Add(new NetStateRule(Phase.TEST));

                detectionOut.include.Add(new NetStateRule(Phase.RUN));

            }

            lastLayer = connectAndAddLayer(rgMboxLayers, detectionOut);


            if (!bDeploy)

            {

                LayerParameter detectionEval = new LayerParameter(LayerParameter.LayerType.DETECTION_EVALUATE);

                detectionEval.name = "detection_eval";

                detectionEval.top.Add(detectionEval.name);

                detectionEval.include.Add(new NetStateRule(Phase.TEST));

                detectionEval.detection_evaluate_param = m_detectionEval;

                lastLayer = connectAndAddLayer(lastLayer, detectionEval);

                lastLayer.bottom.Add(data.top[1]);

            }


            return m_net;

        }


        public override NetParameter CreateDeployModel()

        {

            return CreateModel(true);

        }


        protected override LayerParameter addExtraLayers(bool bUseBatchNorm = true, double dfLrMult = 1)

        {

            bool bUseRelU = true;

            string strOutLayer;

            string strFromLayer = m_net.layer[m_net.layer.Count - 1].name;

            LayerParameter lastLayer;


            // 10 x 10

            strOutLayer = "conv6_1";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 256, 1, 0, 1, dfLrMult);

            strFromLayer = strOutLayer;


            strOutLayer = "conv6_2";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 512, 3, 1, 2, dfLrMult);

            strFromLayer = strOutLayer;


            // 5 x 5

            strOutLayer = "conv7_1";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 128, 1, 0, 1, dfLrMult);

            strFromLayer = strOutLayer;


            strOutLayer = "conv7_2";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 256, 3, 1, 2, dfLrMult);

            strFromLayer = strOutLayer;


            // 3 x 3

            strOutLayer = "conv8_1";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 128, 1, 0, 1, dfLrMult);

            strFromLayer = strOutLayer;


            strOutLayer = "conv8_2";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 256, 3, 0, 1, dfLrMult);

            strFromLayer = strOutLayer;


            // 1 x 1

            strOutLayer = "conv9_1";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 128, 1, 0, 1, dfLrMult);

            strFromLayer = strOutLayer;


            strOutLayer = "conv9_2";

            lastLayer = addConvBNLayer(strFromLayer, strOutLayer, bUseBatchNorm, bUseRelU, 256, 3, 0, 1, dfLrMult);

            strFromLayer = strOutLayer;


            return lastLayer;

        }

    }

}

MyCaffe.basecode.SimpleDatum
The SimpleDatum class holds a data input within host memory.
Definition: SimpleDatum.cs:161

MyCaffe.basecode.SimpleDatum.ANNOTATION_TYPE
ANNOTATION_TYPE
Specifies the annotation type when using annotations.
Definition: SimpleDatum.cs:204

MyCaffe.model.ModelBuilder
The ModelBuilder is an abstract class that is overridden by a base class used to programically build ...
Definition: ModelBuilder.cs:19

MyCaffe.model.ModelBuilder.addVGGNetBody
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)
Adds the full VGG body to the network, connecting it to the 'lastLayer'.
Definition: ModelBuilder.cs:915

MyCaffe.model.ModelBuilder.m_solver
SolverParameter m_solver
Specifies the base solver to use.
Definition: ModelBuilder.cs:31

MyCaffe.model.ModelBuilder.addAnnotatedDataLayer
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)
Add the Annotated Data layer.
Definition: ModelBuilder.cs:192

MyCaffe.model.ModelBuilder.m_net
NetParameter m_net
Specifies the base net to be altered.
Definition: ModelBuilder.cs:27

MyCaffe.model.ModelBuilder.createMultiBoxHead
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="")
Create the multi-box head layers.
Definition: ModelBuilder.cs:244

MyCaffe.model.ModelBuilder.addConvBNLayer
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)
Add convolution, batch-norm layers.
Definition: ModelBuilder.cs:491

MyCaffe.model.ModelBuilder.m_strBaseDir
string m_strBaseDir
Specifies the base directory that contains the data and models.
Definition: ModelBuilder.cs:23

MyCaffe.model.ModelBuilder.createNet
NetParameter createNet(string strName)
Create the base network parameter for the model and set its name to the 'm_strModel' name.
Definition: ModelBuilder.cs:129

MyCaffe.model.ModelBuilder.findLayer
LayerParameter findLayer(string strName)
Find a layer with a given name.
Definition: ModelBuilder.cs:113

MyCaffe.model.ModelBuilder.connectAndAddLayer
LayerParameter connectAndAddLayer(string fromLayer, LayerParameter toLayer, string fromLayer2=null)
Connect the from layer to the 'to' layer.
Definition: ModelBuilder.cs:602

MyCaffe.model.ModelBuilder.getFileName
string getFileName(string strFile, string strSubDir)
Returns the full path of the filename using the base directory original set when creating the ModelBu...
Definition: ModelBuilder.cs:89

MyCaffe.model.MultiBoxHeadInfo
The MultiBoxHeadInfo contains information used to build the multi-box head of layers.
Definition: ModelBuilder.cs:1123

MyCaffe.model.SsdPascalModelBuilder
The SsdPascalModelBuilder adds the extra layers to a 'base' model for the Pascal model used with SSD.
Definition: SsdPascalModelBuilder.cs:16

MyCaffe.model.SsdPascalModelBuilder.CreateSolver
override SolverParameter CreateSolver()
Create the base solver to use.
Definition: SsdPascalModelBuilder.cs:322

MyCaffe.model.SsdPascalModelBuilder.CreateDeployModel
override NetParameter CreateDeployModel()
Create the testing SSD model for the pascal dataset.
Definition: SsdPascalModelBuilder.cs:478

MyCaffe.model.SsdPascalModelBuilder.SsdPascalModelBuilder
SsdPascalModelBuilder(string strBaseDirectory, int nBatchSize=32, int nAccumBatchSize=32, List< int > rgGpuId=null, bool bUseBatchNorm=false, LossParameter.NormalizationMode normMode=LossParameter.NormalizationMode.VALID, NetParameter net=null)
The constructor.
Definition: SsdPascalModelBuilder.cs:70

MyCaffe.model.SsdPascalModelBuilder.addExtraLayers
override LayerParameter addExtraLayers(bool bUseBatchNorm=true, double dfLrMult=1)
Add extra layers (for SSD with the Pascal dataset) on top of a 'base' network (e.g....
Definition: SsdPascalModelBuilder.cs:488

MyCaffe.model.SsdPascalModelBuilder.CreateModel
override NetParameter CreateModel(bool bDeploy=false)
Create the training SSD model for the pascal dataset.
Definition: SsdPascalModelBuilder.cs:355

MyCaffe.param.BlobShape
Specifies the shape of a Blob.
Definition: BlobShape.cs:15

MyCaffe.param.FlattenParameter.axis
int axis
Specifies the first axis to flatten: all preceding axes are retained in the output....
Definition: FlattenParameter.cs:35

MyCaffe.param.LayerParameter
Specifies the base parameter for all layers.
Definition: LayerParameter.cs:24

MyCaffe.param.LayerParameter.name
string name
Specifies the name of this LayerParameter.
Definition: LayerParameter.cs:1865

MyCaffe.param.LayerParameter.detection_output_param
DetectionOutputParameter detection_output_param
Returns the parmeter set when initialized with LayerType.DETECTION_OUTPUT
Definition: LayerParameter.cs:2236

MyCaffe.param.LayerParameter.multiboxloss_param
MultiBoxLossParameter multiboxloss_param
Returns the parameter set when initializing with LayerType.MULTIBOX_LOSS
Definition: LayerParameter.cs:2569

MyCaffe.param.LayerParameter.softmax_param
SoftmaxParameter softmax_param
Returns the parameter set when initialized with LayerType.SOFTMAX
Definition: LayerParameter.cs:2794

MyCaffe.param.LayerParameter.propagate_down
List< bool > propagate_down
Specifies whether or not the LayerParameter (or protions of) should be backpropagated.
Definition: LayerParameter.cs:1982

MyCaffe.param.LayerParameter.include
List< NetStateRule > include
Specifies the NetStateRule's for which this LayerParameter should be included.
Definition: LayerParameter.cs:1991

MyCaffe.param.LayerParameter.top
List< string > top
Specifies the active top connections (in the bottom, out the top)
Definition: LayerParameter.cs:1919

MyCaffe.param.LayerParameter.reshape_param
ReshapeParameter reshape_param
Returns the parameter set when initialized with LayerType.RESHAPE
Definition: LayerParameter.cs:2731

MyCaffe.param.LayerParameter.detection_evaluate_param
DetectionEvaluateParameter detection_evaluate_param
Returns the parmeter set when initialized with LayerType.DETECTION_EVALUATE
Definition: LayerParameter.cs:2227

MyCaffe.param.LayerParameter.flatten_param
FlattenParameter flatten_param
Returns the parameter set when initialized with LayerType.FLATTEN
Definition: LayerParameter.cs:2344

MyCaffe.param.LayerParameter.bottom
List< string > bottom
Specifies the active bottom connections (in the bottom, out the top).
Definition: LayerParameter.cs:1910

MyCaffe.param.LayerParameter.LayerType
LayerType
Specifies the layer type.
Definition: LayerParameter.cs:110

MyCaffe.param.LayerParameter.loss_param
LossParameter loss_param
Returns the parameter set when initialized with LayerType.LOSS
Definition: LayerParameter.cs:2027

MyCaffe.param.LossParameter
Stores the parameters used by loss layers.
Definition: LossParameter.cs:16

MyCaffe.param.LossParameter.NormalizationMode
NormalizationMode
How to normalize the loss for loss layers that aggregate across batches, spatial dimensions,...
Definition: LossParameter.cs:27

MyCaffe.param.LossParameter.normalization
NormalizationMode? normalization
Specifies the normalization mode (default = VALID).
Definition: LossParameter.cs:81

MyCaffe.param.NetParameter
Specifies the parameters use to create a Net
Definition: NetParameter.cs:18

MyCaffe.param.NetParameter.layer
List< LayerParameter > layer
The layers that make up the net. Each of their configurations, including connectivity and behavior,...
Definition: NetParameter.cs:169

MyCaffe.param.NetStateRule
Specifies a NetStateRule used to determine whether a Net falls within a given include or exclude patt...
Definition: NetStateRule.cs:20

MyCaffe.param.ReshapeParameter.shape
BlobShape shape
Specifies the output dimensions.
Definition: ReshapeParameter.cs:53

MyCaffe.param.SoftmaxParameter.axis
int axis
The axis along which to perform the softmax – may be negative to index from the end (e....
Definition: SoftmaxParameter.cs:83

MyCaffe.param.SolverParameter
The SolverParameter is a parameter for the solver, specifying the train and test networks.
Definition: SolverParameter.cs:32

MyCaffe.param.SolverParameter.max_iter
int max_iter
The maximum number of iterations.
Definition: SolverParameter.cs:435

MyCaffe.param.SolverParameter.test_iter
List< int > test_iter
The number of iterations for each test.
Definition: SolverParameter.cs:359

MyCaffe.param.SolverParameter.debug_info
bool debug_info
If true, print information about the state of the net that may help with debugging learning problems.
Definition: SolverParameter.cs:890

MyCaffe.param.SolverParameter.LearningRatePolicyType
LearningRatePolicyType
Defines the learning rate policy to use.
Definition: SolverParameter.cs:182

MyCaffe.param.SolverParameter.SolverType
SolverType
Defines the type of solver.
Definition: SolverParameter.cs:113

MyCaffe.param.SolverParameter.LearningRatePolicy
LearningRatePolicyType LearningRatePolicy
The learning rate decay policy.
Definition: SolverParameter.cs:475

MyCaffe.param.SolverParameter.device_id
int device_id
The device id that will be used when run on the GPU.
Definition: SolverParameter.cs:798

MyCaffe.param.SolverParameter.ap_version
ApVersion ap_version
Specifies the AP Version to use for average precision when using Single-Shot Detection (SSD) - (defau...
Definition: SolverParameter.cs:934

MyCaffe.param.SolverParameter.average_loss
int average_loss
Display the loss averaged over the last average_loss iterations.
Definition: SolverParameter.cs:424

MyCaffe.param.SolverParameter.test_interval
int test_interval
The number of iterations between two testing phases.
Definition: SolverParameter.cs:370

MyCaffe.param.SolverParameter.iter_size
int iter_size
Accumulate gradients over 'iter_size' x 'batch_size' instances.
Definition: SolverParameter.cs:446

MyCaffe.param.SolverParameter.EvaluationType
EvaluationType
Defines the evaluation method used in the SSD algorithm.
Definition: SolverParameter.cs:87

MyCaffe.param.SolverParameter.gamma
double gamma
Specifies the 'gamma' parameter to compute the 'step', 'exp', 'inv', and 'sigmoid' learning policy (d...
Definition: SolverParameter.cs:576

MyCaffe.param.SolverParameter.snapshot_after_train
bool snapshot_after_train
If false, don't save a snapshot after training finishes.
Definition: SolverParameter.cs:912

MyCaffe.param.SolverParameter.eval_type
EvaluationType eval_type
Specifies the evaluation type to use when using Single-Shot Detection (SSD) - (default = NONE,...
Definition: SolverParameter.cs:923

MyCaffe.param.SolverParameter.test_initialization
bool test_initialization
If true, run an initial test pass before the first iteration, ensuring memory availability and printi...
Definition: SolverParameter.cs:392

MyCaffe.param.SolverParameter.display
int display
The number of iterations between displaying info. If display = 0, no info will be displayed.
Definition: SolverParameter.cs:414

MyCaffe.param.SolverParameter.weight_decay
double weight_decay
Specifies the weight decay (default = 0.0005).
Definition: SolverParameter.cs:609

MyCaffe.param.SolverParameter.stepvalue
List< int > stepvalue
The step values for learning rate policy 'multistep'.
Definition: SolverParameter.cs:696

MyCaffe.param.SolverParameter.momentum
double momentum
Specifies the momentum value - used by all solvers EXCEPT the 'AdaGrad' and 'RMSProp' solvers....
Definition: SolverParameter.cs:599

MyCaffe.param.SolverParameter.snapshot
int snapshot
Specifies the snapshot interval.
Definition: SolverParameter.cs:728

MyCaffe.param.SolverParameter.base_lr
double base_lr
The base learning rate (default = 0.01).
Definition: SolverParameter.cs:402

MyCaffe.param.SolverParameter.type
SolverType type
Specifies the solver type.
Definition: SolverParameter.cs:828

MyCaffe.param.TransformationParameter
Stores parameters used to apply transformation to the data layer's data.
Definition: TransformationParameter.cs:19

MyCaffe.param.TransformationParameter.COLOR_ORDER
COLOR_ORDER
Defines the color ordering used to tranform the input data.
Definition: TransformationParameter.cs:63

MyCaffe.param.TransformationParameter.distortion_param
DistortionParameter distortion_param
Optionally, specifies the distortion policy, otherwise this is null.
Definition: TransformationParameter.cs:250

MyCaffe.param.TransformationParameter.mean_value
List< double > mean_value
If specified can be repeated once (would subtract it from all the channels or can be repeated the sam...
Definition: TransformationParameter.cs:156

MyCaffe.param.TransformationParameter.mirror
bool mirror
Specify if we want to randomly mirror the data.
Definition: TransformationParameter.cs:118

MyCaffe.param.TransformationParameter.color_order
COLOR_ORDER color_order
Specifies the color ordering to use. Native Caffe models often uses COLOR_ORDER.BGR,...
Definition: TransformationParameter.cs:211

MyCaffe.param.TransformationParameter.expansion_param
ExpansionParameter expansion_param
Optionally, specifies the expansion policy, otherwise this is null.
Definition: TransformationParameter.cs:263

MyCaffe.param.TransformationParameter.resize_param
ResizeParameter resize_param
Optionally, specifies the resize policy, otherwise this is null.
Definition: TransformationParameter.cs:224

MyCaffe.param.TransformationParameter.emit_constraint
EmitConstraint emit_constraint
Optionally, specifies the emit constraint on emitting annotation after transformation,...
Definition: TransformationParameter.cs:276

MyCaffe.param.ssd.BatchSampler
Specifies a sample of batch of bboxes with provided constraints in SSD.
Definition: BatchSampler.cs:22

MyCaffe.param.ssd.BatchSampler.sample_constraint
SamplerConstraint sample_constraint
Get/set the sample constraint.
Definition: BatchSampler.cs:122

MyCaffe.param.ssd.BatchSampler.sampler
Sampler sampler
Specifies the constraints for sampling the bbox
Definition: BatchSampler.cs:113

MyCaffe.param.ssd.BatchSampler.max_trials
uint max_trials
Maximum number of trials for sampling to avoid an infinite loop.
Definition: BatchSampler.cs:104

MyCaffe.param.ssd.BatchSampler.max_sample
uint max_sample
If provided (greater than zero), break when found certain number of samples satisfying the sample con...
Definition: BatchSampler.cs:95

MyCaffe.param.ssd.DetectionEvaluateParameter
Specifies the parameters for the DetectionEvaluateLayer.
Definition: DetectionEvaluateParameter.cs:20

MyCaffe.param.ssd.DetectionEvaluateParameter.background_label_id
uint background_label_id
Specifies the background class.
Definition: DetectionEvaluateParameter.cs:53

MyCaffe.param.ssd.DetectionEvaluateParameter.evaulte_difficult_gt
bool evaulte_difficult_gt
Specifies whether or not to consider the ground truth for evaluation.
Definition: DetectionEvaluateParameter.cs:73

MyCaffe.param.ssd.DetectionEvaluateParameter.name_size_file
string name_size_file
Specifies the file which contains a list of names and sizes in the same order of the input database....
Definition: DetectionEvaluateParameter.cs:88

MyCaffe.param.ssd.DetectionEvaluateParameter.num_classes
uint num_classes
Specifies the number of classes that are actually predicted - required!
Definition: DetectionEvaluateParameter.cs:40

MyCaffe.param.ssd.DetectionEvaluateParameter.overlap_threshold
float overlap_threshold
Specifies the threshold for deciding true/false positive.
Definition: DetectionEvaluateParameter.cs:63

MyCaffe.param.ssd.DetectionOutputParameter
Specifies the parameters for the DetectionOutputLayer.
Definition: DetectionOutputParameter.cs:20

MyCaffe.param.ssd.DetectionOutputParameter.code_type
PriorBoxParameter.CodeType code_type
Specifies the coding method for the bbox.
Definition: DetectionOutputParameter.cs:99

MyCaffe.param.ssd.DetectionOutputParameter.confidence_threshold
float? confidence_threshold
Specifies the threshold for deciding which detections to consider - only those which are larger than ...
Definition: DetectionOutputParameter.cs:129

MyCaffe.param.ssd.DetectionOutputParameter.nms_param
NonMaximumSuppressionParameter nms_param
Specifies the parameter used for non maximum suppression.
Definition: DetectionOutputParameter.cs:79

MyCaffe.param.ssd.DetectionOutputParameter.share_location
bool share_location
Specifies whether or not to sare the bounding box is shared among different classes (default = true).
Definition: DetectionOutputParameter.cs:56

MyCaffe.param.ssd.DetectionOutputParameter.num_classes
uint num_classes
Specifies the number of classes that are actually predicted - required!
Definition: DetectionOutputParameter.cs:46

MyCaffe.param.ssd.DetectionOutputParameter.save_output_param
SaveOutputParameter save_output_param
Specifies the parameter used for saving the detection results.
Definition: DetectionOutputParameter.cs:89

MyCaffe.param.ssd.DetectionOutputParameter.background_label_id
int background_label_id
Specifies the background class.
Definition: DetectionOutputParameter.cs:69

MyCaffe.param.ssd.DetectionOutputParameter.keep_top_k
int keep_top_k
Specifies the number of total bboxes to be kept per image after nms step, -1 means keeping all bboxes...
Definition: DetectionOutputParameter.cs:119

MyCaffe.param.ssd.DistortionParameter
Specifies the parameters for the DistortionParameter used with SSD.
Definition: DistortionParameter.cs:22

MyCaffe.param.ssd.DistortionParameter.contrast_lower
float contrast_lower
Get/set lower bound for random contrast factor (default = 0.5).
Definition: DistortionParameter.cs:101

MyCaffe.param.ssd.DistortionParameter.random_order_prob
float random_order_prob
Get/set the probability of randomly ordering the image channels (default = 0).
Definition: DistortionParameter.cs:151

MyCaffe.param.ssd.DistortionParameter.brightness_delta
float brightness_delta
Get/set amount to add to the pixel values within [-delta,delta] (default = 0)
Definition: DistortionParameter.cs:81

MyCaffe.param.ssd.DistortionParameter.saturation_prob
float saturation_prob
Get/set probability of adjusting the saturation (default = 0).
Definition: DistortionParameter.cs:121

MyCaffe.param.ssd.DistortionParameter.saturation_lower
float saturation_lower
Get/set lower bound for random saturation factor (default = 0.5).
Definition: DistortionParameter.cs:131

MyCaffe.param.ssd.DistortionParameter.saturation_upper
float saturation_upper
Get/set upper bound for random saturation factor (default = 1.5).
Definition: DistortionParameter.cs:141

MyCaffe.param.ssd.DistortionParameter.brightness_prob
float brightness_prob
Get/set probability of adjusting the brightness (default = 0).
Definition: DistortionParameter.cs:71

MyCaffe.param.ssd.DistortionParameter.contrast_prob
float contrast_prob
Get/set probability of adjusting the contrast (default = 0).
Definition: DistortionParameter.cs:91

MyCaffe.param.ssd.DistortionParameter.contrast_upper
float contrast_upper
Get/set upper bound for random contrast factor (default = 1.5).
Definition: DistortionParameter.cs:111

MyCaffe.param.ssd.EmitConstraint
Specifies the parameters for the EmitConstraint used with SSD.
Definition: EmitConstraint.cs:22

MyCaffe.param.ssd.EmitConstraint.emit_type
EmitType emit_type
Get/set the emit type.
Definition: EmitConstraint.cs:54

MyCaffe.param.ssd.EmitConstraint.EmitType
EmitType
Specifies the emit type.
Definition: EmitConstraint.cs:30

MyCaffe.param.ssd.ExpansionParameter
Specifies the parameters for the ExpansionParameter used with SSD.
Definition: ExpansionParameter.cs:22

MyCaffe.param.ssd.ExpansionParameter.max_expand_ratio
float max_expand_ratio
Get/set the ratio to expand the image.
Definition: ExpansionParameter.cs:49

MyCaffe.param.ssd.ExpansionParameter.prob
float prob
Get/set probability of using this expansion policy.
Definition: ExpansionParameter.cs:39

MyCaffe.param.ssd.MultiBoxLossParameter
Specifies the parameters for the MultiBoxLossParameter.
Definition: MultiBoxLossParameter.cs:23

MyCaffe.param.ssd.MultiBoxLossParameter.loc_weight
float loc_weight
Get/set the weight for the localization loss (default = 1.0).
Definition: MultiBoxLossParameter.cs:232

MyCaffe.param.ssd.MultiBoxLossParameter.overlap_threshold
float overlap_threshold
Get/set the overlap threshold (default = 0.5).
Definition: MultiBoxLossParameter.cs:272

MyCaffe.param.ssd.MultiBoxLossParameter.use_difficult_gt
bool use_difficult_gt
Get/set whether or not to consider the difficult ground truth (defalt = true).
Definition: MultiBoxLossParameter.cs:292

MyCaffe.param.ssd.MultiBoxLossParameter.MatchType
MatchType
Defines the matching method used during training.
Definition: MultiBoxLossParameter.cs:122

MyCaffe.param.ssd.MultiBoxLossParameter.code_type
PriorBoxParameter.CodeType code_type
Get/set the coding method for the bounding box.
Definition: MultiBoxLossParameter.cs:335

MyCaffe.param.ssd.MultiBoxLossParameter.neg_overlap
float neg_overlap
Get/set the negative overlap upperbound for the unmatched predictions (default = 0....
Definition: MultiBoxLossParameter.cs:325

MyCaffe.param.ssd.MultiBoxLossParameter.LocLossType
LocLossType
Defines the localization loss types.
Definition: MultiBoxLossParameter.cs:52

MyCaffe.param.ssd.MultiBoxLossParameter.neg_pos_ratio
float neg_pos_ratio
Get/set the negative/positive ratio (default = 3.0).
Definition: MultiBoxLossParameter.cs:315

MyCaffe.param.ssd.MultiBoxLossParameter.share_location
bool share_location
Get/sets whether or not the bounding box is shared among different classes (default = true).
Definition: MultiBoxLossParameter.cs:252

MyCaffe.param.ssd.MultiBoxLossParameter.MiningType
MiningType
Defines the mining type used during training.
Definition: MultiBoxLossParameter.cs:158

MyCaffe.param.ssd.MultiBoxLossParameter.loc_loss_type
LocLossType loc_loss_type
Get/set the localization loss type (default = SMOOTH_L1).
Definition: MultiBoxLossParameter.cs:212

MyCaffe.param.ssd.MultiBoxLossParameter.background_label_id
uint background_label_id
Get/set the background label id.
Definition: MultiBoxLossParameter.cs:282

MyCaffe.param.ssd.MultiBoxLossParameter.ConfLossType
ConfLossType
Defines the confidence loss types.
Definition: MultiBoxLossParameter.cs:87

MyCaffe.param.ssd.MultiBoxLossParameter.ignore_cross_boundary_bbox
bool ignore_cross_boundary_bbox
Get/set whether or not to ignore cross boundary bbox during matching (default = false)....
Definition: MultiBoxLossParameter.cs:366

MyCaffe.param.ssd.MultiBoxLossParameter.conf_loss_type
ConfLossType conf_loss_type
Get/set the confidence loss type (default = SOFTMAX).
Definition: MultiBoxLossParameter.cs:222

MyCaffe.param.ssd.MultiBoxLossParameter.use_prior_for_matching
bool use_prior_for_matching
Get/set whether or not to use prior for matching.
Definition: MultiBoxLossParameter.cs:426

MyCaffe.param.ssd.MultiBoxLossParameter.num_classes
uint num_classes
Get/set the number of classes to be predicted - required!
Definition: MultiBoxLossParameter.cs:242

MyCaffe.param.ssd.MultiBoxLossParameter.mining_type
MiningType mining_type
Get/set the mining type used during training (default = MAX_NEGATIVE).
Definition: MultiBoxLossParameter.cs:386

MyCaffe.param.ssd.MultiBoxLossParameter.match_type
MatchType match_type
Get/set the matching method used during training (default = PER_PREDICTION).
Definition: MultiBoxLossParameter.cs:262

MyCaffe.param.ssd.NonMaximumSuppressionParameter
Specifies the parameters for the NonMaximumSuppressionParameter used with SSD.
Definition: NonMaximumSuppressionParameter.cs:22

MyCaffe.param.ssd.NonMaximumSuppressionParameter.top_k
int? top_k
Get/set the maximum number of results kept.
Definition: NonMaximumSuppressionParameter.cs:50

MyCaffe.param.ssd.NonMaximumSuppressionParameter.nms_threshold
float nms_threshold
Get/set the threshold to be used in nms.
Definition: NonMaximumSuppressionParameter.cs:40

MyCaffe.param.ssd.PriorBoxParameter
Specifies the parameters for the PriorBoxParameter.
Definition: PriorBoxParameter.cs:22

MyCaffe.param.ssd.PriorBoxParameter.CodeType
CodeType
Defines the encode/decode type.
Definition: PriorBoxParameter.cs:41

MyCaffe.param.ssd.ResizeParameter
Specifies the parameters for the ResizeParameter for use with SSD.
Definition: ResizeParameter.cs:22

MyCaffe.param.ssd.ResizeParameter.InterpMode
InterpMode
Defines the interpolation mode.
Definition: ResizeParameter.cs:75

MyCaffe.param.ssd.ResizeParameter.height
uint height
Get/set the resizing height.
Definition: ResizeParameter.cs:131

MyCaffe.param.ssd.ResizeParameter.interp_mode
List< InterpMode > interp_mode
Get/set the interp mode which is repeated once for all channels, or provided once per channel.
Definition: ResizeParameter.cs:191

MyCaffe.param.ssd.ResizeParameter.width
uint width
Get/set the resizing width.
Definition: ResizeParameter.cs:141

MyCaffe.param.ssd.ResizeParameter.ResizeMode
ResizeMode
Defines the resizing mode.
Definition: ResizeParameter.cs:37

MyCaffe.param.ssd.ResizeParameter.resize_mode
ResizeMode resize_mode
Get/set the resizing mode.
Definition: ResizeParameter.cs:121

MyCaffe.param.ssd.ResizeParameter.prob
float prob
Get/set probability of using this resize policy.
Definition: ResizeParameter.cs:111

MyCaffe.param.ssd.SamplerConstraint.max_jaccard_overlap
float? max_jaccard_overlap
Get/set the maximum Jaccard overlap between sampled bbox and all boxes in AnnotationGroup.
Definition: SamplerConstraint.cs:113

MyCaffe.param.ssd.SamplerConstraint.min_jaccard_overlap
float? min_jaccard_overlap
Get/set the minimum Jaccard overlap between sampled bbox and all boxes in AnnotationGroup.
Definition: SamplerConstraint.cs:104

MyCaffe.param.ssd.Sampler.max_scale
float max_scale
Get/set the maximum scale of the sampled bbox.
Definition: Sampler.cs:92

MyCaffe.param.ssd.Sampler.max_aspect_ratio
float max_aspect_ratio
Get/set the maximum aspect ratio of the sampled bbox.
Definition: Sampler.cs:110

MyCaffe.param.ssd.Sampler.min_scale
float min_scale
Get/set the minimum scale of the sampled bbox.
Definition: Sampler.cs:83

MyCaffe.param.ssd.Sampler.min_aspect_ratio
float min_aspect_ratio
Get/set the minimum aspect ratio of the sampled bbox.
Definition: Sampler.cs:101

MyCaffe.param.ssd.SaveOutputParameter
Specifies the parameters for the SaveOutputLayer.
Definition: SaveOutputParameter.cs:21

MyCaffe.param.ssd.SaveOutputParameter.output_directory
string output_directory
Specifies the output directory - if not empty, the results will be saved.
Definition: SaveOutputParameter.cs:62

MyCaffe.param.ssd.SaveOutputParameter.name_size_file
string name_size_file
Optionally, specifies the output name size file.
Definition: SaveOutputParameter.cs:108

MyCaffe.param.ssd.SaveOutputParameter.label_map_file
string label_map_file
Optionally, specifies the output label map file.
Definition: SaveOutputParameter.cs:92

MyCaffe.param.ssd.SaveOutputParameter.output_name_prefix
string output_name_prefix
Specifies the output name prefix.
Definition: SaveOutputParameter.cs:72

MyCaffe.param.ssd.SaveOutputParameter.num_test_image
uint? num_test_image
Specifies the number of test images.
Definition: SaveOutputParameter.cs:120

MyCaffe.basecode
The MyCaffe.basecode contains all generic types used throughout MyCaffe.
Definition: Annotation.cs:12

MyCaffe.basecode.Phase
Phase
Defines the Phase under which to run a Net.
Definition: Interfaces.cs:61

MyCaffe.basecode.ApVersion
ApVersion
Defines the different way of computing average precision.
Definition: Interfaces.cs:234

MyCaffe.model
The MyCaffe.model namespace contains all classes used to programically create new model scripts.
Definition: ModelBuilder.cs:14

MyCaffe.param.ssd
The MyCaffe.param.ssd namespace contains all SSD related parameter objects that correspond to the nat...
Definition: AnnotatedDataParameter.cs:20

MyCaffe.param
The MyCaffe.param namespace contains parameters used to create models.
Definition: AttentionParameter.cs:9

MyCaffe
The MyCaffe namespace contains the main body of MyCaffe code that closesly tracks the C++ Caffe open-...
Definition: Annotation.cs:12

System
Definition: Component.cs:11