lachlants / denet

A simple extendable library for training and evaluating Deep Convolutional Neural Networks focussing on real-time image classification and detection.

DeNet

A simple extendable library for training and evaluating Deep Convolutional Neural Networks focussing on image classification and detection.

Requirements

• python3
• numpy
• pillow
• scipy
• theano REQUIRES development version (see below)
• cudnn

Installation

DeNet currently requires the development version of Theano:

1. Download Theano git e.g.

   git clone https://github.com/Theano/Theano.git

2. Revert to revision used in the papers (might not be neccessary):

   git checkout fadc8be492628dcef4760ab4cfcd147824a8226f

3. Setup PYTHONPATH environment variable:

   export PYTHONPATH=theano_git_dir:$PYTHONPATH

Probably want to add this command to your .bashrc so it doesn't have to be run repetitively.

Features

• Reference "DeNet: Scalable real-time object detection with directed sparse sampling" implementation (see /papers/dss/)
• Reference "Improving Object Localization with Fitness NMS and Bounded IoU Loss" implementation
• GPU optimized sparse sampling op and pool inv op
• Ability to split model into multiple executions for training (useful for very large models)
• Training on Multiple GPU's

Training

Training neural networks is performed via either "bin/model-train" or "bin/model-train-multi" for single / multi GPU implementation. Arguments are mostly the same for both implementations. The GPU to use for "model-train" is specified by exporting the "GPU=N" global variable (see examples), for "model-train-multi" GPUs are specified with the "--gpus" argument.

Note: the initial run of "model-train-multi" simply produces a "model-dims.json" file... you must rerun the command to begin training!

Example - Training simple 3 layer CNN on CIFAR10 / CIFAR100:

GPU=0 bin/model-train --border-mode half --activation relu  --model-desc C[128,3] BN A P[2] C[256,3] BN A P[2] C[512,3] BN A P.A R  --learn-rate 0.1 --solver sgd --epochs 30 --train TRAIN --test TEST --extension png 

where TRAIN and TEST are the train and test folders for CIFAR10 / CIFAR100

NOTE: see examples/ for a more comprehensive list of examples

Datasets:

Datasets are specified using the "--train FNAME" and "--test FNAME" arguments.

A number of different formats are supported including:

• Basic Dir: --ext=image type assumes directory is in format FNAME/class name/image.ext e.g. CIFAR10/CIFAR100
• Basic Array: --ext=npy uses FNAME_data.npy and FNAME_labels.npy saved numpy arrays. The data is of dim (B,C,H,W) and dtype=float32 and the labels is of dimension (B,) and dtype=int32 where B is the number of samples in the dataset, C is the number of channels and WxH are the spatial dimensions.
• ImageNet: --ext=imagenet,<image_loader arguments>
• MSCOCO: --ext=mscoco,<image_loader arguments>
• Pascal VOC: --ext=voc,<image_loader arguments>

The ImageNet, MSCOCO and Pascal VOC share the image_loader.py interface which enables background loading of the dataset and additional augmentation schemes. For large datasets I recommend a similar implementation.

Augmentation is either specified via the image_loader interface (occuring as the image is loaded from disk) or with the "--distort-mode" argument (operates on preloaded images). The basic distort-mode arguments are:

• random offsets - oX where X is the number of pixels (X and Y) to randomly offset sample
• random scale - sX where X is percent to vary the scale by
• random rotation - rX where X is the degrees to rotation left/right
• random mirroring - mX where X is the percentage probabilty of applying mirroring

Models Desc:

Model layers are specified in a feedforward manner via the "--model-desc" argument and take the format "TYPE.TAGS[ARGS]" where TYPE defines the layer type and TAGS are optional single character switchs (specific to each type) and ARGS defines the arguments to supply (if any). In most cases not all ARGS must be specified!

Common Layer Types:

• Convolution: C[filters, size, stride] or C.B to disable bias (useful for batch normalization)
  • filters = number of output filters, number of input filters is automatically determined
  • size = spatial dimensions of the convolution (default=1)
  • stride = the number of pixels between each evaluation (default=1)
  • e.g. C.B[256,3,2] = 256x3x3 convolution without bias with a stride of 2x2
• Pooling: P[size, stride, pad] for "Max Pooling" or P.A for "Mean Pooling"
  • size = spatial dimensions of the pooling operation (default=input spatial size)
  • stride = the number of pixels between each evaluation (default=size)
  • pad = input padding (default=0)
• Batch Normalization: BN[momentum, eps]
  • momentum = running mean momentum (default=0.9)
  • eps = epsilon to fix divide by zero errors (default=1e-5)
• Dropout: D[rate]
  • rate = probability of dropping an activation (default=0.5)
• Activation: A (applies activation of type specified in "--activation" argument)
• Regression: R (performs negative log-likelihood softmax regression to target classes)
• Residual Network Block: RSN[filters, size, stride]
• Multi Residual Network Blocks: nRSN[num, filters, size, stride]

Please refer to parse_desc() in the layer .py files for all arguments e.g. see /src/layer/batch_norm.py

Pretrained Models

See MSCOCO and VOC2007 to download pretrained DeNet models.

MSCOCO Results:

Model	Eval. Rate	MAP@IoU=[0.5:0.95]	MAP@IoU=0.5	MAP@IoU=0.75
DeNet34 skip (v1)	82 Hz	29.5%	47.7%	31.1%
DeNet34 wide (v1)	44 Hz	30.0%	48.9%	31.8%
DeNet101 skip (v1)	33 Hz	32.3%	51.4%	34.6%
DeNet101 wide (v1)	17 Hz	33.8%	53.4%	36.1%
DeNet34 wide (v2)	80 Hz	33.4%	49.8%	35.8%
DeNet101 wide (v2)	21 Hz	36.8%	53.9%	39.3%
DeNet101 wide x768 (v2)	11 Hz	39.5%	58.0%	42.6%

v1 models are from the original paper

v2 models are from the 2nd paper and include Joint fitness NMS, bounded IoU loss and corner clustering

The DeNet101wide x768 (v2) model is the DeNet101 wide (v2) model evaluated with 768x768 pixel input images and 1296 sample RoIs

Evaluation rate is for Titan X (Maxwell) GPU, Cuda v8.0 and CuDNN v5110. Note that variations in these versions can cause the MAP to fluctuate a bit e.g. +- 0.2%

Modifying models

Use the model-modify application to modify parameters for existing models and layers. e.g. to run prediction with 768x768 input images and 1296 RoIs use:

model-modify --input MODEL --output MODEL_X768 --image-size 768 768 --modify-layer denet-sparse sample_num=36
GPU=0 model-predict --batch-size 8 --thread-num 4 --predict-mode detect,mscoco --input MSCOCO_DIR --model MODEL_X768 --extension mscoco,2015-test-dev,images_per_subset=128,crop=768,scale_mode=large

Note the change to the "crop" parameter in the model-predict extension argument.

Contact

• Lachlan Tychsen-Smith (Research Engineer @ Data61, CSIRO, Australia) - [email protected] or [email protected]

denet's Issues

Theano error

Already use Theano v0.8.1 but get following error

Traceback (most recent call last):
  File "/home/jrmei/denet/denet/model/train_multi.py", line 445, in <module>
    sys.exit(main())
  File "/home/jrmei/denet/denet/model/train_multi.py", line 357, in main
    import model_cnn
  File "/home/jrmei/denet/denet/model/model_cnn.py", line 18, in <module>
    from denet.layer.layer_types import layer_types
  File "/home/jrmei/denet/denet/layer/layer_types.py", line 8, in <module>
    from denet.layer.batch_norm_relu import BatchNormReluLayer
  File "/home/jrmei/denet/denet/layer/batch_norm_relu.py", line 9, in <module>
    from theano.sandbox.cuda.dnn import GpuDnnBatchNorm, GpuDnnBatchNormGrad, dnn_batch_normalization_train, dnn_batch_normalization_test
ImportError: cannot import name 'GpuDnnBatchNorm'

Whether corner_pr is softmax normalized probability or log of it?

Hi @lachlants, thanks for your paper and code. I really enjoy using it.

I have one issue regarding the corner_pr in denet_sparse.py. It seems to me here the corner_pr is the probability map after softmax normalization. And self.corner_threshold should be the probability threshold. However, in your C implementation, the probability is summed instead of multiplied (https://github.com/lachlants/denet/blob/master/denet/layer/denet_sparse.cc#L271) and you also took a log on the threshold https://github.com/lachlants/denet/blob/master/denet/layer/denet_sparse.cc#L506.

I believe I miss something. Could you help me point out it?

AssertionError when try to run predict.py

Hello,
I'v never worked with Theano before, so I just installed the GitHub version you provided and tried to run predict.py via Anaconda and also through shell script model-predict with your pretrained model. I get an assertion error problem:
Failure
Traceback (most recent call last):
File "/home/yulia/anaconda3/lib/python3.6/unittest/case.py", line 59, in testPartExecutor
yield
File "/home/yulia/anaconda3/lib/python3.6/unittest/case.py", line 601, in run
testMethod()
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/failure.py", line 39, in runTest
raise self.exc_val.with_traceback(self.tb)
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/loader.py", line 417, in loadTestsFromName
addr.filename, addr.module)
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/importer.py", line 47, in importFromPath
return self.importFromDir(dir_path, fqname)
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/importer.py", line 94, in importFromDir
mod = load_module(part_fqname, fh, filename, desc)
File "/home/yulia/anaconda3/lib/python3.6/imp.py", line 234, in load_module
return load_source(name, filename, file)
File "/home/yulia/anaconda3/lib/python3.6/imp.py", line 172, in load_source
module = _load(spec)
File "", line 675, in _load
File "", line 655, in _load_unlocked
File "", line 678, in exec_module
File "", line 205, in _call_with_frames_removed
File "/home/yulia/PycharmProjects/denet/denet/model/predict.py", line 14, in
import denet.model.model_cnn as model_cnn
File "/home/yulia/PycharmProjects/denet/denet/model/model_cnn.py", line 18, in
from denet.layer.layer_types import layer_types
File "/home/yulia/PycharmProjects/denet/denet/layer/layer_types.py", line 23, in
from denet.layer.denet_sparse import DeNetSparseLayer
File "/home/yulia/PycharmProjects/denet/denet/layer/denet_sparse.py", line 19, in
assert not c_code is None
AssertionError
F
FAIL: Failure: AssertionError ()
Traceback (most recent call last):
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/failure.py", line 39, in runTest
raise self.exc_val.with_traceback(self.tb)
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/loader.py", line 417, in loadTestsFromName
addr.filename, addr.module)
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/importer.py", line 47, in importFromPath
return self.importFromDir(dir_path, fqname)
File "/home/yulia/anaconda3/lib/python3.6/site-packages/nose/importer.py", line 94, in importFromDir
mod = load_module(part_fqname, fh, filename, desc)
File "/home/yulia/anaconda3/lib/python3.6/imp.py", line 234, in load_module
return load_source(name, filename, file)
File "/home/yulia/anaconda3/lib/python3.6/imp.py", line 172, in load_source
module = _load(spec)
File "", line 675, in _load
File "", line 655, in _load_unlocked
File "", line 678, in exec_module
File "", line 205, in _call_with_frames_removed
File "/home/yulia/PycharmProjects/denet/denet/model/predict.py", line 14, in
import denet.model.model_cnn as model_cnn
File "/home/yulia/PycharmProjects/denet/denet/model/model_cnn.py", line 18, in
from denet.layer.layer_types import layer_types
File "/home/yulia/PycharmProjects/denet/denet/layer/layer_types.py", line 23, in
from denet.layer.denet_sparse import DeNetSparseLayer
File "/home/yulia/PycharmProjects/denet/denet/layer/denet_sparse.py", line 19, in
assert not c_code is None
AssertionError
Ran 1 test in 0.011s
FAILED (failures=1)
Process finished with exit code 1

I walked through debugger and here is the code where it throws an exception:

`def import_c(fname):
# import logging
# logging.getLogger("theano.gof.cmodule").setLevel(logging.DEBUG)

#compile code
import theano
import theano.gof.cmodule as cmodule
import theano.gof.compilelock as compilelock
from theano.gof.utils import hash_from_code
compilelock.get_lock()
try:
    compile_args = ["-std=c++11", "-fPIC", "-O3", "-fno-math-errno", "-Wno-unused-label", "-Wno-unused-variable", "-Wno-write-strings"]
    compile_dir = cmodule.dlimport_workdir(theano.config.compiledir)
    with open(fname, "r") as f:
        compile_code = f.read()

    compile_hash = os.path.basename(os.path.splitext(fname)[0])
    **cmodule_import = cmodule.GCC_compiler.compile_str(compile_hash, compile_code, compile_dir, preargs = compile_args)**
except Exception as e:
    print("Warning: Failed to compile cmodule:", e)
    cmodule_import = None
finally:
    compilelock.release_lock()

return cmodule_import`

On this line cmodule_import = cmodule.GCC_compiler.compile_str(compile_hash, compile_code, compile_dir, preargs = compile_args)

Hope, you can help me with this issue. Thank you in advance)

Using Joint Fitness NMS

Hi , Thank you for sharing this great work
I want to use the function that implements Joint Fitness NMS in other implementation what should I do ?

Thank you

How to get class probability vectors?

Hello) I would like to thank you for helping me with my first issue again) If it is possible for you to help me with the following question, then is it possible get something like softmax class probability vectors in the detectons.json. What I've already managed to do, is to modify denet_detect.cc like:

typedef std::tuple<float, float, float, float, float, npy_intp, npy_intp, float*> Instance;`

static float get_overlap_iou(const Instance& inst_a, const Instance& inst_b){
    float x0_a = std::get<1>(inst_a);
    float y0_a = std::get<2>(inst_a);
    float x1_a = std::get<3>(inst_a);
    float y1_a = std::get<4>(inst_a);

    float x0_b = std::get<1>(inst_b);
    float y0_b = std::get<2>(inst_b);
    float x1_b = std::get<3>(inst_b);
    float y1_b = std::get<4>(inst_b);

    float dx = std::max(0.0f, std::min(x1_a, x1_b) - std::max(x0_a, x0_b));
    float dy = std::max(0.0f, std::min(y1_a, y1_b) - std::max(y0_a, y0_b));
    float area_intersect = dx*dy;
    float area_a = (x1_a - x0_a)*(y1_a - y0_a);
    float area_b = (x1_b - x0_b)*(y1_b - y0_b);
    float area_union = area_a + area_b - area_intersect;
    return area_intersect / area_union;
};

static PyObject* build_detections_nms(PyObject *self, PyObject *args) {

    //get args
    float pr_threshold; 
    float nms_threshold; 
    PyObject* det_obj; //ndarray
    PyObject* bbox_obj; //ndarray
    PyObject* bbox_num; //list of int
    if (!PyArg_ParseTuple(args, "ffOOO", &pr_threshold, &nms_threshold, &det_obj, &bbox_obj, &bbox_num))
        return NULL;

    PyArrayObject* det_pr = (PyArrayObject*)PyArray_FROM_OTF(det_obj, NPY_FLOAT, NPY_IN_ARRAY);
    if (det_pr == NULL)
        return NULL;

    PyArrayObject* bbox = (PyArrayObject*)PyArray_FROM_OTF(bbox_obj, NPY_FLOAT, NPY_IN_ARRAY);
    if (bbox == NULL)
        return NULL;

    float log_pr_threshold = std::log(pr_threshold);
    npy_intp batch_size = PyArray_DIM(det_pr, 0);
    npy_intp class_num = PyArray_DIM(det_pr, 1) - 1;
    npy_intp sample_num = PyArray_DIM(det_pr, 2);

    PyObject* det_lists = PyList_New(0);
    for(npy_intp b=0; b < batch_size; b++){

        long batch_bbox_num = PyLong_AS_LONG(PyList_GET_ITEM(bbox_num, b));
        PyObject* batch_dets = PyList_New(0);
        size_t before_nms=0, after_nms=0;
        for(npy_intp cls=0; cls < class_num; cls++){

            std::vector<Instance> instances;
            for(npy_intp j=0; (j < sample_num) && ((j*sample_num) < batch_bbox_num); j++){
                for(npy_intp i=0; (i < sample_num) && ((j*sample_num + i) < batch_bbox_num); i++){

                   float* sample_probs = new float[class_num + 1];
                    for(npy_intp cls1=0; cls1 < class_num + 1; cls1++){
                        float sample_log_pr = *(float*)PyArray_GETPTR4(det_pr, b, cls1, j, i);
                        float sample_prob = std::exp(sample_log_pr);
                        sample_probs[cls1] = sample_prob;
                    }

                    float log_pr = *(float*)PyArray_GETPTR4(det_pr, b, cls, j, i);
                    if (log_pr >= log_pr_threshold){
                        float* det_bbox = (float*)PyArray_GETPTR4(bbox, b, j, i, 0);
                        instances.push_back(Instance(log_pr, det_bbox[0], det_bbox[1], det_bbox[2], det_bbox[3], j, i, sample_probs));
                    }
                }
            }
            before_nms += instances.size();

            //run NMS
            std::vector<Instance> instances_nms;
            if ((nms_threshold > 0.0) && (nms_threshold < 1.0)){
                
                for(const Instance& inst_a: instances){
                    bool unique=true;
                    for(const Instance& inst_b : instances){
                        if ((std::get<0>(inst_a) < std::get<0>(inst_b)) && (get_overlap_iou(inst_a, inst_b) > nms_threshold)){
                            unique = false;
                            break;
                        }
                    }
                    if (unique)
                        instances_nms.push_back(inst_a);
                };
                
            } else {
                instances_nms = instances;
            }
            after_nms += instances_nms.size();

            for(const Instance& inst: instances_nms){
                **std::string probs_string = "";
                for(int i = 0; i < class_num + 1; i++){
                    probs_string += "f";
                }**
                PyObject* det = Py_BuildValue(("fi(ffff)"** + probs_string).c_str()**, std::exp(std::get<0>(inst)), cls, std::get<1>(inst), std::get<2>(inst), std::get<3>(inst), std::get<4>(inst), std::get<7>(inst));
                PyList_Append(batch_dets, det);
                Py_DECREF(det);
            }
        }
        // printf("%i - NMS before: %zu, after %zu\n", b, before_nms, after_nms);
        PyList_Append(det_lists, batch_dets);
        Py_DECREF(batch_dets);
    }

    Py_DECREF(det_pr);
    Py_DECREF(bbox);
    return det_lists;

}

static PyMethodDef methods[] = {
        {"build_detections_nms", build_detections_nms, METH_VARARGS, ""},
        {NULL, NULL, 0, NULL}
};

static struct PyModuleDef moduledef = {
    PyModuleDef_HEAD_INIT,
    "denet_detect",
    NULL,
    -1,
    methods,
    NULL,
    NULL,
    NULL,
    NULL
};

PyMODINIT_FUNC PyInit_denet_detect(void){
    import_array();
    PyObject *m = PyModule_Create(&moduledef);
    return m;
};

with assumption, that det_pr contains a softmax vector (is your case log_softmax vector) is your class probabilities vectors for detections and first 20 components of it denotes to PASCAL VOC classes and the last 21 component to class 'null' (and because it is log_softmax you need to compute exp before you get actual class probabilities). But when I write them into the detections.json I get:

{
"meta": {
"scale": [
1.024,
1.024
],
"bbox": [
[
0.382,
0.155,
0.726,
0.621
]
],
"mirror": false,
"image": {
"fname": "/home/yulia/PycharmProjects/PASCAL VOC/VOC2007 test/VOC2007/JPEGImages/000008.jpg",
"difficult": [
false
],
"bboxs": [
[
8,
[
191,
15,
363,
248
]
]
]
},
"class": [
8
],
"offset": [
0,
-64
],
"image_size": [
500,
375
]
},
"detections": [
[
0.3030449151992798,
8,
[
0.0013727322220802307,
0.5019946694374084,
0.10281166434288025,
0.864723265171051
],
0.0,
1.5514139955e-314,
1.9035985662552932e+185,
6.9532438905885e-310,
3.079071413e-315,
0.864723265171051,
0.10281166434288025,
0.5019946694374084,
2.5e-323,
4e-323,
0.0013727322220802307,
1.2e-322,
2.846e-321,
6.9365108328561e-310,
4.15e-322,
-1239.3887228797048,
6.936529101712e-310,
0.3030449151992798,
6.93650252247864e-310,
6.93651684831124e-310,
4e-323
],
[
0.9998823404312134,
8,
[
0.38018351793289185,
0.17481878399848938,
0.705095112323761,
0.6256318092346191
],
0.0,
1.5514139955e-314,
1.9035985662552932e+185,
6.9532438905885e-310,
3.079071413e-315,
0.6256318092346191,
0.705095112323761,
0.17481878399848938,
2.5e-323,
4e-323,
0.38018351793289185,
1.2e-322,
2.846e-321,
6.9365108328561e-310,
4.15e-322,
-1239.3887228797048,
6.936529101712e-310,
0.9998823404312134,
6.93650252247864e-310,
6.93651684831124e-310,
4e-323
],
[
0.08476103097200394,
8,
[
0.27250778675079346,
0.5628441572189331,
0.6248316168785095,
0.8794838190078735
],
0.0,
1.5514139955e-314,
1.9035985662552932e+185,
6.9532438905885e-310,
3.079071413e-315,
0.8794838190078735,
0.6248316168785095,
0.5628441572189331,
2.5e-323,
4e-323,
0.27250778675079346,
1.2e-322,
2.846e-321,
6.9365108328561e-310,
4.15e-322,
-1239.3887228797048,
6.936529101712e-310,
0.08476103097200394,
6.93650252247864e-310,
6.93651684831124e-310,
4e-323
],
[
0.0431208536028862,
11,
[
-0.0007366538047790527,
0.5240722894668579,
0.1058601438999176,
0.8655219078063965
],
0.0,
1.595616974e-314,
1.9035985662552932e+185,
6.9532438905885e-310,
2.92780701e-315,
0.8655219078063965,
0.1058601438999176,
0.5240722894668579,
2.5e-323,
5.4e-323,
-0.0007366538047790527,
1.2e-322,
2.846e-321,
6.9365108328561e-310,
4.15e-322,
-1239.3887228797048,
6.936529101712e-310,
0.0431208536028862,
6.93650252247864e-310,
6.93651684831124e-310,
4e-323
],
[
0.05106999725103378,
14,
[
-0.00273049995303154,
0.5344655513763428,
0.09292234480381012,
0.8737093210220337
],
0.0,
1.5957156223e-314,
1.9035985662552932e+185,
6.9532438905885e-310,
2.927773413e-315,
0.8737093210220337,
0.09292234480381012,
0.5344655513763428,
2.5e-323,
7e-323,
-0.00273049995303154,
1.2e-322,
2.846e-321,
6.9365108328561e-310,
4.15e-322,
-1239.3887228797048,
6.936529101712e-310,
0.05106999725103378,
6.93650252247864e-310,
6.93651684831124e-310,
4e-323
],
[
0.04868819937109947,
17,
[
0.0009535849094390869,
0.504220724105835,
0.10251316428184509,
0.8658108711242676
],
0.0,
1.595068334e-314,
1.9035985662552932e+185,
6.9532438905885e-310,
3.081500555e-315,
0.8658108711242676,
0.10251316428184509,
0.504220724105835,
2.5e-323,
8.4e-323,
0.0009535849094390869,
1.2e-322,
2.846e-321,
6.9365108328561e-310,
4.15e-322,
-1239.3887228797048,
6.936529101712e-310,
0.04868819937109947,
6.93650252247864e-310,
6.93651684831124e-310,
4e-323
],
[
0.7103296518325806,
17,
[
0.8675391674041748,
0.5496058464050293,
1.0043929815292358,
0.8745944499969482
],
0.0,
1.595068334e-314,
1.9035985662552932e+185,
6.9532438905885e-310,
3.081500555e-315,
0.8745944499969482,
1.0043929815292358,
0.5496058464050293,
2.5e-323,
8.4e-323,
0.8675391674041748,
1.2e-322,
2.846e-321,
6.9365108328561e-310,
4.15e-322,
-1239.3887228797048,
6.936529101712e-310,
0.7103296518325806,
6.93650252247864e-310,
6.93651684831124e-310,
4e-323
]
]
},

So I think I've missed something, and what I'm trying to work with isn't class probabilities at all. It wolud be great, if you could give me a hint, what I understand wrong) Thank you in advance)

what does evaluation rate mean?

For usual，fps is used to present the speed of a model. But in your paper, evaluation rate is used to estimate model performance, what does that mean?

A demo?

Thanks for your fantastic work.

Is there a pretrained model?
Could you please offer a guidance for reproduce the result in the paper?
Where could I find initial.mdl.gz and resnet101.mdl.gz?