Clean code

app.py

@@ -1,6 +1,6 @@
 import sys
 sys.path.append('.')
-sys.path.append('./face_recognition1')
+sys.path.append('./face_recognition')
 import os
 import io
 import cv2
@@ -14,15 +14,15 @@ import configparser
 import numpy as np
 from PIL import Image
 
-# from face_recognition.match import match_1_1
-from face_recognition1.run import match_image
+from face_recognition.match import match_1_1
+# from face_recognition1.run import match_image
 
 
 def face_recognition_on_file(file1, file2):
     img1 = cv2.imread(file1)
     img2 = cv2.imread(file2)
 
-    response = match_image(img1, img2)
+    response = match_1_1(img1, img2)
 
     return response
 

face_recognition1/face_detect/checkpoints/FaceBoxesProd.pth

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c0cb2b1e40710c0aa5fc32a8759b1496a0fe0a126c907ca0ffe35b4bd0709d09
-size 4072492

face_recognition1/face_detect/checkpoints/Widerface-RetinaFace.caffemodel

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d08338a2c207df16a9c566f767fea67fb43ba6fff76ce11e938fe3fabefb9402
-size 1866013

face_recognition1/face_detect/checkpoints/deploy.prototxt

@@ -1,2499 +0,0 @@
-name: "20200403141819_Widerface-RetinaFace_mb_640_negscope-0_epoch_4"
-input: "data"
-input_dim: 1
-input_dim: 3
-input_dim: 640
-input_dim: 640
-layer {
-  name: "conv1"
-  type: "Convolution"
-  bottom: "data"
-  top: "conv_blob1"
-  convolution_param {
-    num_output: 8
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 2
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm1"
-  type: "BatchNorm"
-  bottom: "conv_blob1"
-  top: "batch_norm_blob1"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale1"
-  type: "Scale"
-  bottom: "batch_norm_blob1"
-  top: "batch_norm_blob1"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu1"
-  type: "ReLU"
-  bottom: "batch_norm_blob1"
-  top: "relu_blob1"
-}
-layer {
-  name: "conv2"
-  type: "Convolution"
-  bottom: "relu_blob1"
-  top: "conv_blob2"
-  convolution_param {
-    num_output: 8
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 8
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm2"
-  type: "BatchNorm"
-  bottom: "conv_blob2"
-  top: "batch_norm_blob2"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale2"
-  type: "Scale"
-  bottom: "batch_norm_blob2"
-  top: "batch_norm_blob2"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu2"
-  type: "ReLU"
-  bottom: "batch_norm_blob2"
-  top: "relu_blob2"
-}
-layer {
-  name: "conv3"
-  type: "Convolution"
-  bottom: "relu_blob2"
-  top: "conv_blob3"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm3"
-  type: "BatchNorm"
-  bottom: "conv_blob3"
-  top: "batch_norm_blob3"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale3"
-  type: "Scale"
-  bottom: "batch_norm_blob3"
-  top: "batch_norm_blob3"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu3"
-  type: "ReLU"
-  bottom: "batch_norm_blob3"
-  top: "relu_blob3"
-}
-layer {
-  name: "conv4"
-  type: "Convolution"
-  bottom: "relu_blob3"
-  top: "conv_blob4"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 16
-    stride: 2
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm4"
-  type: "BatchNorm"
-  bottom: "conv_blob4"
-  top: "batch_norm_blob4"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale4"
-  type: "Scale"
-  bottom: "batch_norm_blob4"
-  top: "batch_norm_blob4"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu4"
-  type: "ReLU"
-  bottom: "batch_norm_blob4"
-  top: "relu_blob4"
-}
-layer {
-  name: "conv5"
-  type: "Convolution"
-  bottom: "relu_blob4"
-  top: "conv_blob5"
-  convolution_param {
-    num_output: 32
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm5"
-  type: "BatchNorm"
-  bottom: "conv_blob5"
-  top: "batch_norm_blob5"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale5"
-  type: "Scale"
-  bottom: "batch_norm_blob5"
-  top: "batch_norm_blob5"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu5"
-  type: "ReLU"
-  bottom: "batch_norm_blob5"
-  top: "relu_blob5"
-}
-layer {
-  name: "conv6"
-  type: "Convolution"
-  bottom: "relu_blob5"
-  top: "conv_blob6"
-  convolution_param {
-    num_output: 32
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 32
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm6"
-  type: "BatchNorm"
-  bottom: "conv_blob6"
-  top: "batch_norm_blob6"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale6"
-  type: "Scale"
-  bottom: "batch_norm_blob6"
-  top: "batch_norm_blob6"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu6"
-  type: "ReLU"
-  bottom: "batch_norm_blob6"
-  top: "relu_blob6"
-}
-layer {
-  name: "conv7"
-  type: "Convolution"
-  bottom: "relu_blob6"
-  top: "conv_blob7"
-  convolution_param {
-    num_output: 32
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm7"
-  type: "BatchNorm"
-  bottom: "conv_blob7"
-  top: "batch_norm_blob7"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale7"
-  type: "Scale"
-  bottom: "batch_norm_blob7"
-  top: "batch_norm_blob7"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu7"
-  type: "ReLU"
-  bottom: "batch_norm_blob7"
-  top: "relu_blob7"
-}
-layer {
-  name: "conv8"
-  type: "Convolution"
-  bottom: "relu_blob7"
-  top: "conv_blob8"
-  convolution_param {
-    num_output: 32
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 32
-    stride: 2
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm8"
-  type: "BatchNorm"
-  bottom: "conv_blob8"
-  top: "batch_norm_blob8"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale8"
-  type: "Scale"
-  bottom: "batch_norm_blob8"
-  top: "batch_norm_blob8"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu8"
-  type: "ReLU"
-  bottom: "batch_norm_blob8"
-  top: "relu_blob8"
-}
-layer {
-  name: "conv9"
-  type: "Convolution"
-  bottom: "relu_blob8"
-  top: "conv_blob9"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm9"
-  type: "BatchNorm"
-  bottom: "conv_blob9"
-  top: "batch_norm_blob9"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale9"
-  type: "Scale"
-  bottom: "batch_norm_blob9"
-  top: "batch_norm_blob9"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu9"
-  type: "ReLU"
-  bottom: "batch_norm_blob9"
-  top: "relu_blob9"
-}
-layer {
-  name: "conv10"
-  type: "Convolution"
-  bottom: "relu_blob9"
-  top: "conv_blob10"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 64
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm10"
-  type: "BatchNorm"
-  bottom: "conv_blob10"
-  top: "batch_norm_blob10"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale10"
-  type: "Scale"
-  bottom: "batch_norm_blob10"
-  top: "batch_norm_blob10"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu10"
-  type: "ReLU"
-  bottom: "batch_norm_blob10"
-  top: "relu_blob10"
-}
-layer {
-  name: "conv11"
-  type: "Convolution"
-  bottom: "relu_blob10"
-  top: "conv_blob11"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm11"
-  type: "BatchNorm"
-  bottom: "conv_blob11"
-  top: "batch_norm_blob11"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale11"
-  type: "Scale"
-  bottom: "batch_norm_blob11"
-  top: "batch_norm_blob11"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu11"
-  type: "ReLU"
-  bottom: "batch_norm_blob11"
-  top: "relu_blob11"
-}
-layer {
-  name: "conv12"
-  type: "Convolution"
-  bottom: "relu_blob11"
-  top: "conv_blob12"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 64
-    stride: 2
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm12"
-  type: "BatchNorm"
-  bottom: "conv_blob12"
-  top: "batch_norm_blob12"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale12"
-  type: "Scale"
-  bottom: "batch_norm_blob12"
-  top: "batch_norm_blob12"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu12"
-  type: "ReLU"
-  bottom: "batch_norm_blob12"
-  top: "relu_blob12"
-}
-layer {
-  name: "conv13"
-  type: "Convolution"
-  bottom: "relu_blob12"
-  top: "conv_blob13"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm13"
-  type: "BatchNorm"
-  bottom: "conv_blob13"
-  top: "batch_norm_blob13"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale13"
-  type: "Scale"
-  bottom: "batch_norm_blob13"
-  top: "batch_norm_blob13"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu13"
-  type: "ReLU"
-  bottom: "batch_norm_blob13"
-  top: "relu_blob13"
-}
-layer {
-  name: "conv14"
-  type: "Convolution"
-  bottom: "relu_blob13"
-  top: "conv_blob14"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 128
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm14"
-  type: "BatchNorm"
-  bottom: "conv_blob14"
-  top: "batch_norm_blob14"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale14"
-  type: "Scale"
-  bottom: "batch_norm_blob14"
-  top: "batch_norm_blob14"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu14"
-  type: "ReLU"
-  bottom: "batch_norm_blob14"
-  top: "relu_blob14"
-}
-layer {
-  name: "conv15"
-  type: "Convolution"
-  bottom: "relu_blob14"
-  top: "conv_blob15"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm15"
-  type: "BatchNorm"
-  bottom: "conv_blob15"
-  top: "batch_norm_blob15"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale15"
-  type: "Scale"
-  bottom: "batch_norm_blob15"
-  top: "batch_norm_blob15"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu15"
-  type: "ReLU"
-  bottom: "batch_norm_blob15"
-  top: "relu_blob15"
-}
-layer {
-  name: "conv16"
-  type: "Convolution"
-  bottom: "relu_blob15"
-  top: "conv_blob16"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 128
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm16"
-  type: "BatchNorm"
-  bottom: "conv_blob16"
-  top: "batch_norm_blob16"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale16"
-  type: "Scale"
-  bottom: "batch_norm_blob16"
-  top: "batch_norm_blob16"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu16"
-  type: "ReLU"
-  bottom: "batch_norm_blob16"
-  top: "relu_blob16"
-}
-layer {
-  name: "conv17"
-  type: "Convolution"
-  bottom: "relu_blob16"
-  top: "conv_blob17"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm17"
-  type: "BatchNorm"
-  bottom: "conv_blob17"
-  top: "batch_norm_blob17"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale17"
-  type: "Scale"
-  bottom: "batch_norm_blob17"
-  top: "batch_norm_blob17"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu17"
-  type: "ReLU"
-  bottom: "batch_norm_blob17"
-  top: "relu_blob17"
-}
-layer {
-  name: "conv18"
-  type: "Convolution"
-  bottom: "relu_blob17"
-  top: "conv_blob18"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 128
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm18"
-  type: "BatchNorm"
-  bottom: "conv_blob18"
-  top: "batch_norm_blob18"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale18"
-  type: "Scale"
-  bottom: "batch_norm_blob18"
-  top: "batch_norm_blob18"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu18"
-  type: "ReLU"
-  bottom: "batch_norm_blob18"
-  top: "relu_blob18"
-}
-layer {
-  name: "conv19"
-  type: "Convolution"
-  bottom: "relu_blob18"
-  top: "conv_blob19"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm19"
-  type: "BatchNorm"
-  bottom: "conv_blob19"
-  top: "batch_norm_blob19"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale19"
-  type: "Scale"
-  bottom: "batch_norm_blob19"
-  top: "batch_norm_blob19"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu19"
-  type: "ReLU"
-  bottom: "batch_norm_blob19"
-  top: "relu_blob19"
-}
-layer {
-  name: "conv20"
-  type: "Convolution"
-  bottom: "relu_blob19"
-  top: "conv_blob20"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 128
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm20"
-  type: "BatchNorm"
-  bottom: "conv_blob20"
-  top: "batch_norm_blob20"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale20"
-  type: "Scale"
-  bottom: "batch_norm_blob20"
-  top: "batch_norm_blob20"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu20"
-  type: "ReLU"
-  bottom: "batch_norm_blob20"
-  top: "relu_blob20"
-}
-layer {
-  name: "conv21"
-  type: "Convolution"
-  bottom: "relu_blob20"
-  top: "conv_blob21"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm21"
-  type: "BatchNorm"
-  bottom: "conv_blob21"
-  top: "batch_norm_blob21"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale21"
-  type: "Scale"
-  bottom: "batch_norm_blob21"
-  top: "batch_norm_blob21"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu21"
-  type: "ReLU"
-  bottom: "batch_norm_blob21"
-  top: "relu_blob21"
-}
-layer {
-  name: "conv22"
-  type: "Convolution"
-  bottom: "relu_blob21"
-  top: "conv_blob22"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 128
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm22"
-  type: "BatchNorm"
-  bottom: "conv_blob22"
-  top: "batch_norm_blob22"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale22"
-  type: "Scale"
-  bottom: "batch_norm_blob22"
-  top: "batch_norm_blob22"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu22"
-  type: "ReLU"
-  bottom: "batch_norm_blob22"
-  top: "relu_blob22"
-}
-layer {
-  name: "conv23"
-  type: "Convolution"
-  bottom: "relu_blob22"
-  top: "conv_blob23"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm23"
-  type: "BatchNorm"
-  bottom: "conv_blob23"
-  top: "batch_norm_blob23"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale23"
-  type: "Scale"
-  bottom: "batch_norm_blob23"
-  top: "batch_norm_blob23"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu23"
-  type: "ReLU"
-  bottom: "batch_norm_blob23"
-  top: "relu_blob23"
-}
-layer {
-  name: "conv24"
-  type: "Convolution"
-  bottom: "relu_blob23"
-  top: "conv_blob24"
-  convolution_param {
-    num_output: 128
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 128
-    stride: 2
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm24"
-  type: "BatchNorm"
-  bottom: "conv_blob24"
-  top: "batch_norm_blob24"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale24"
-  type: "Scale"
-  bottom: "batch_norm_blob24"
-  top: "batch_norm_blob24"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu24"
-  type: "ReLU"
-  bottom: "batch_norm_blob24"
-  top: "relu_blob24"
-}
-layer {
-  name: "conv25"
-  type: "Convolution"
-  bottom: "relu_blob24"
-  top: "conv_blob25"
-  convolution_param {
-    num_output: 256
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm25"
-  type: "BatchNorm"
-  bottom: "conv_blob25"
-  top: "batch_norm_blob25"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale25"
-  type: "Scale"
-  bottom: "batch_norm_blob25"
-  top: "batch_norm_blob25"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu25"
-  type: "ReLU"
-  bottom: "batch_norm_blob25"
-  top: "relu_blob25"
-}
-layer {
-  name: "conv26"
-  type: "Convolution"
-  bottom: "relu_blob25"
-  top: "conv_blob26"
-  convolution_param {
-    num_output: 256
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 256
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm26"
-  type: "BatchNorm"
-  bottom: "conv_blob26"
-  top: "batch_norm_blob26"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale26"
-  type: "Scale"
-  bottom: "batch_norm_blob26"
-  top: "batch_norm_blob26"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu26"
-  type: "ReLU"
-  bottom: "batch_norm_blob26"
-  top: "relu_blob26"
-}
-layer {
-  name: "conv27"
-  type: "Convolution"
-  bottom: "relu_blob26"
-  top: "conv_blob27"
-  convolution_param {
-    num_output: 256
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm27"
-  type: "BatchNorm"
-  bottom: "conv_blob27"
-  top: "batch_norm_blob27"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale27"
-  type: "Scale"
-  bottom: "batch_norm_blob27"
-  top: "batch_norm_blob27"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu27"
-  type: "ReLU"
-  bottom: "batch_norm_blob27"
-  top: "relu_blob27"
-}
-layer {
-  name: "conv28"
-  type: "Convolution"
-  bottom: "relu_blob11"
-  top: "conv_blob28"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm28"
-  type: "BatchNorm"
-  bottom: "conv_blob28"
-  top: "batch_norm_blob28"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale28"
-  type: "Scale"
-  bottom: "batch_norm_blob28"
-  top: "batch_norm_blob28"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu28"
-  type: "ReLU"
-  bottom: "batch_norm_blob28"
-  top: "relu_blob28"
-}
-layer {
-  name: "conv29"
-  type: "Convolution"
-  bottom: "relu_blob23"
-  top: "conv_blob29"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm29"
-  type: "BatchNorm"
-  bottom: "conv_blob29"
-  top: "batch_norm_blob29"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale29"
-  type: "Scale"
-  bottom: "batch_norm_blob29"
-  top: "batch_norm_blob29"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu29"
-  type: "ReLU"
-  bottom: "batch_norm_blob29"
-  top: "relu_blob29"
-}
-layer {
-  name: "conv30"
-  type: "Convolution"
-  bottom: "relu_blob27"
-  top: "conv_blob30"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm30"
-  type: "BatchNorm"
-  bottom: "conv_blob30"
-  top: "batch_norm_blob30"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale30"
-  type: "Scale"
-  bottom: "batch_norm_blob30"
-  top: "batch_norm_blob30"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu30"
-  type: "ReLU"
-  bottom: "batch_norm_blob30"
-  top: "relu_blob30"
-}
-layer {
-  name: "conv_transpose1"
-  type: "Deconvolution"
-  bottom: "relu_blob30"
-  top: "conv_transpose_blob1"
-  convolution_param {
-    num_output: 64
-    bias_term: true
-    pad: 0
-    kernel_size: 2
-    group: 1
-    stride: 2
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "crop1"
-  type: "Crop"
-  bottom: "conv_transpose_blob1"
-  bottom: "relu_blob29"
-  top: "crop1"
-}
-layer {
-  name: "add1"
-  type: "Eltwise"
-  bottom: "relu_blob29"
-  bottom: "crop1"
-  top: "add_blob1"
-  eltwise_param {
-    operation: SUM
-  }
-}
-layer {
-  name: "conv31"
-  type: "Convolution"
-  bottom: "add_blob1"
-  top: "conv_blob31"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm31"
-  type: "BatchNorm"
-  bottom: "conv_blob31"
-  top: "batch_norm_blob31"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale31"
-  type: "Scale"
-  bottom: "batch_norm_blob31"
-  top: "batch_norm_blob31"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu31"
-  type: "ReLU"
-  bottom: "batch_norm_blob31"
-  top: "relu_blob31"
-}
-layer {
-  name: "conv_transpose2"
-  type: "Deconvolution"
-  bottom: "relu_blob31"
-  top: "conv_transpose_blob2"
-  convolution_param {
-    num_output: 64
-    bias_term: true
-    pad: 0
-    kernel_size: 2
-    group: 1
-    stride: 2
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "crop2"
-  type: "Crop"
-  bottom: "conv_transpose_blob2"
-  bottom: "relu_blob28"
-  top: "crop2"
-}
-layer {
-  name: "add2"
-  type: "Eltwise"
-  bottom: "relu_blob28"
-  bottom: "crop2"
-  top: "add_blob2"
-  eltwise_param {
-    operation: SUM
-  }
-}
-layer {
-  name: "conv32"
-  type: "Convolution"
-  bottom: "add_blob2"
-  top: "conv_blob32"
-  convolution_param {
-    num_output: 64
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm32"
-  type: "BatchNorm"
-  bottom: "conv_blob32"
-  top: "batch_norm_blob32"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale32"
-  type: "Scale"
-  bottom: "batch_norm_blob32"
-  top: "batch_norm_blob32"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu32"
-  type: "ReLU"
-  bottom: "batch_norm_blob32"
-  top: "relu_blob32"
-}
-layer {
-  name: "conv33"
-  type: "Convolution"
-  bottom: "relu_blob32"
-  top: "conv_blob33"
-  convolution_param {
-    num_output: 32
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm33"
-  type: "BatchNorm"
-  bottom: "conv_blob33"
-  top: "batch_norm_blob33"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale33"
-  type: "Scale"
-  bottom: "batch_norm_blob33"
-  top: "batch_norm_blob33"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "conv34"
-  type: "Convolution"
-  bottom: "relu_blob32"
-  top: "conv_blob34"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm34"
-  type: "BatchNorm"
-  bottom: "conv_blob34"
-  top: "batch_norm_blob34"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale34"
-  type: "Scale"
-  bottom: "batch_norm_blob34"
-  top: "batch_norm_blob34"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu33"
-  type: "ReLU"
-  bottom: "batch_norm_blob34"
-  top: "relu_blob33"
-}
-layer {
-  name: "conv35"
-  type: "Convolution"
-  bottom: "relu_blob33"
-  top: "conv_blob35"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm35"
-  type: "BatchNorm"
-  bottom: "conv_blob35"
-  top: "batch_norm_blob35"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale35"
-  type: "Scale"
-  bottom: "batch_norm_blob35"
-  top: "batch_norm_blob35"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "conv36"
-  type: "Convolution"
-  bottom: "relu_blob33"
-  top: "conv_blob36"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm36"
-  type: "BatchNorm"
-  bottom: "conv_blob36"
-  top: "batch_norm_blob36"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale36"
-  type: "Scale"
-  bottom: "batch_norm_blob36"
-  top: "batch_norm_blob36"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu34"
-  type: "ReLU"
-  bottom: "batch_norm_blob36"
-  top: "relu_blob34"
-}
-layer {
-  name: "conv37"
-  type: "Convolution"
-  bottom: "relu_blob34"
-  top: "conv_blob37"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm37"
-  type: "BatchNorm"
-  bottom: "conv_blob37"
-  top: "batch_norm_blob37"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale37"
-  type: "Scale"
-  bottom: "batch_norm_blob37"
-  top: "batch_norm_blob37"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "cat1"
-  type: "Concat"
-  bottom: "batch_norm_blob33"
-  bottom: "batch_norm_blob35"
-  bottom: "batch_norm_blob37"
-  top: "cat_blob1"
-  concat_param {
-    axis: 1
-  }
-}
-layer {
-  name: "relu35"
-  type: "ReLU"
-  bottom: "cat_blob1"
-  top: "relu_blob35"
-}
-layer {
-  name: "conv38"
-  type: "Convolution"
-  bottom: "relu_blob31"
-  top: "conv_blob38"
-  convolution_param {
-    num_output: 32
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm38"
-  type: "BatchNorm"
-  bottom: "conv_blob38"
-  top: "batch_norm_blob38"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale38"
-  type: "Scale"
-  bottom: "batch_norm_blob38"
-  top: "batch_norm_blob38"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "conv39"
-  type: "Convolution"
-  bottom: "relu_blob31"
-  top: "conv_blob39"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm39"
-  type: "BatchNorm"
-  bottom: "conv_blob39"
-  top: "batch_norm_blob39"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale39"
-  type: "Scale"
-  bottom: "batch_norm_blob39"
-  top: "batch_norm_blob39"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu36"
-  type: "ReLU"
-  bottom: "batch_norm_blob39"
-  top: "relu_blob36"
-}
-layer {
-  name: "conv40"
-  type: "Convolution"
-  bottom: "relu_blob36"
-  top: "conv_blob40"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm40"
-  type: "BatchNorm"
-  bottom: "conv_blob40"
-  top: "batch_norm_blob40"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale40"
-  type: "Scale"
-  bottom: "batch_norm_blob40"
-  top: "batch_norm_blob40"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "conv41"
-  type: "Convolution"
-  bottom: "relu_blob36"
-  top: "conv_blob41"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm41"
-  type: "BatchNorm"
-  bottom: "conv_blob41"
-  top: "batch_norm_blob41"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale41"
-  type: "Scale"
-  bottom: "batch_norm_blob41"
-  top: "batch_norm_blob41"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu37"
-  type: "ReLU"
-  bottom: "batch_norm_blob41"
-  top: "relu_blob37"
-}
-layer {
-  name: "conv42"
-  type: "Convolution"
-  bottom: "relu_blob37"
-  top: "conv_blob42"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm42"
-  type: "BatchNorm"
-  bottom: "conv_blob42"
-  top: "batch_norm_blob42"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale42"
-  type: "Scale"
-  bottom: "batch_norm_blob42"
-  top: "batch_norm_blob42"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "cat2"
-  type: "Concat"
-  bottom: "batch_norm_blob38"
-  bottom: "batch_norm_blob40"
-  bottom: "batch_norm_blob42"
-  top: "cat_blob2"
-  concat_param {
-    axis: 1
-  }
-}
-layer {
-  name: "relu38"
-  type: "ReLU"
-  bottom: "cat_blob2"
-  top: "relu_blob38"
-}
-layer {
-  name: "conv43"
-  type: "Convolution"
-  bottom: "relu_blob30"
-  top: "conv_blob43"
-  convolution_param {
-    num_output: 32
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm43"
-  type: "BatchNorm"
-  bottom: "conv_blob43"
-  top: "batch_norm_blob43"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale43"
-  type: "Scale"
-  bottom: "batch_norm_blob43"
-  top: "batch_norm_blob43"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "conv44"
-  type: "Convolution"
-  bottom: "relu_blob30"
-  top: "conv_blob44"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm44"
-  type: "BatchNorm"
-  bottom: "conv_blob44"
-  top: "batch_norm_blob44"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale44"
-  type: "Scale"
-  bottom: "batch_norm_blob44"
-  top: "batch_norm_blob44"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu39"
-  type: "ReLU"
-  bottom: "batch_norm_blob44"
-  top: "relu_blob39"
-}
-layer {
-  name: "conv45"
-  type: "Convolution"
-  bottom: "relu_blob39"
-  top: "conv_blob45"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm45"
-  type: "BatchNorm"
-  bottom: "conv_blob45"
-  top: "batch_norm_blob45"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale45"
-  type: "Scale"
-  bottom: "batch_norm_blob45"
-  top: "batch_norm_blob45"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "conv46"
-  type: "Convolution"
-  bottom: "relu_blob39"
-  top: "conv_blob46"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm46"
-  type: "BatchNorm"
-  bottom: "conv_blob46"
-  top: "batch_norm_blob46"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale46"
-  type: "Scale"
-  bottom: "batch_norm_blob46"
-  top: "batch_norm_blob46"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "relu40"
-  type: "ReLU"
-  bottom: "batch_norm_blob46"
-  top: "relu_blob40"
-}
-layer {
-  name: "conv47"
-  type: "Convolution"
-  bottom: "relu_blob40"
-  top: "conv_blob47"
-  convolution_param {
-    num_output: 16
-    bias_term: false
-    pad: 1
-    kernel_size: 3
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "batch_norm47"
-  type: "BatchNorm"
-  bottom: "conv_blob47"
-  top: "batch_norm_blob47"
-  batch_norm_param {
-    use_global_stats: true
-    eps: 9.9999997e-06
-  }
-}
-layer {
-  name: "bn_scale47"
-  type: "Scale"
-  bottom: "batch_norm_blob47"
-  top: "batch_norm_blob47"
-  scale_param {
-    bias_term: true
-  }
-}
-layer {
-  name: "cat3"
-  type: "Concat"
-  bottom: "batch_norm_blob43"
-  bottom: "batch_norm_blob45"
-  bottom: "batch_norm_blob47"
-  top: "cat_blob3"
-  concat_param {
-    axis: 1
-  }
-}
-layer {
-  name: "relu41"
-  type: "ReLU"
-  bottom: "cat_blob3"
-  top: "relu_blob41"
-}
-layer {
-  name: "conv48"
-  type: "Convolution"
-  bottom: "relu_blob35"
-  top: "conv_blob48"
-  convolution_param {
-    num_output: 8
-    bias_term: true
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "conv49"
-  type: "Convolution"
-  bottom: "relu_blob35"
-  top: "conv_blob49"
-  convolution_param {
-    num_output: 4
-    bias_term: true
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "conv50"
-  type: "Convolution"
-  bottom: "relu_blob38"
-  top: "conv_blob50"
-  convolution_param {
-    num_output: 8
-    bias_term: true
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "conv51"
-  type: "Convolution"
-  bottom: "relu_blob38"
-  top: "conv_blob51"
-  convolution_param {
-    num_output: 4
-    bias_term: true
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "conv52"
-  type: "Convolution"
-  bottom: "relu_blob41"
-  top: "conv_blob52"
-  convolution_param {
-    num_output: 8
-    bias_term: true
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-layer {
-  name: "conv53"
-  type: "Convolution"
-  bottom: "relu_blob41"
-  top: "conv_blob53"
-  convolution_param {
-    num_output: 4
-    bias_term: true
-    pad: 0
-    kernel_size: 1
-    group: 1
-    stride: 1
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-    }
-    dilation: 1
-  }
-}
-############ prior box ###########
-
-layer {
-  name: "conv4_3_norm_mbox_loc_perm"
-  type: "Permute"
-  bottom: "conv_blob48"
-  top: "conv4_3_norm_mbox_loc_perm"
-  permute_param {
-    order: 0
-    order: 2
-    order: 3
-    order: 1
-  }
-}
-layer {
-  name: "conv4_3_norm_mbox_loc_flat"
-  type: "Flatten"
-  bottom: "conv4_3_norm_mbox_loc_perm"
-  top: "conv4_3_norm_mbox_loc_flat"
-  flatten_param {
-    axis: 1
-  }
-}
-layer {
-  name: "conv4_3_norm_mbox_conf_perm"
-  type: "Permute"
-  bottom: "conv_blob49"
-  top: "conv4_3_norm_mbox_conf_perm"
-  permute_param {
-    order: 0
-    order: 2
-    order: 3
-    order: 1
-  }
-}
-layer {
-  name: "conv4_3_norm_mbox_conf_flat"
-  type: "Flatten"
-  bottom: "conv4_3_norm_mbox_conf_perm"
-  top: "conv4_3_norm_mbox_conf_flat"
-  flatten_param {
-    axis: 1
-  }
-}
-layer {
-  name: "conv4_3_norm_mbox_priorbox"
-  type: "PriorBox"
-  bottom: "relu_blob35"
-  bottom: "data"
-  top: "conv4_3_norm_mbox_priorbox"
-  prior_box_param {
-    min_size: 16.0
-    min_size: 32.0
-    clip: false
-    variance: 0.1
-    variance: 0.1
-    variance: 0.2
-    variance: 0.2
-    step: 8.0
-    offset: 0.5
-  }
-}
-
-layer {
-  name: "conv5_3_norm_mbox_loc_perm"
-  type: "Permute"
-  bottom: "conv_blob50"
-  top: "conv5_3_norm_mbox_loc_perm"
-  permute_param {
-    order: 0
-    order: 2
-    order: 3
-    order: 1
-  }
-}
-layer {
-  name: "conv5_3_norm_mbox_loc_flat"
-  type: "Flatten"
-  bottom: "conv5_3_norm_mbox_loc_perm"
-  top: "conv5_3_norm_mbox_loc_flat"
-  flatten_param {
-    axis: 1
-  }
-}
-layer {
-  name: "conv5_3_norm_mbox_conf_perm"
-  type: "Permute"
-  bottom: "conv_blob51"
-  top: "conv5_3_norm_mbox_conf_perm"
-  permute_param {
-    order: 0
-    order: 2
-    order: 3
-    order: 1
-  }
-}
-layer {
-  name: "conv5_3_norm_mbox_conf_flat"
-  type: "Flatten"
-  bottom: "conv5_3_norm_mbox_conf_perm"
-  top: "conv5_3_norm_mbox_conf_flat"
-  flatten_param {
-    axis: 1
-  }
-}
-layer {
-  name: "conv5_3_norm_mbox_priorbox"
-  type: "PriorBox"
-  bottom: "relu_blob38"
-  bottom: "data"
-  top: "conv5_3_norm_mbox_priorbox"
-  prior_box_param {
-    min_size: 64.0
-    min_size: 128.0
-    clip: false
-    variance: 0.1
-    variance: 0.1
-    variance: 0.2
-    variance: 0.2
-    step: 16.0
-    offset: 0.5
-  }
-}
-
-layer {
-  name: "conv6_3_norm_mbox_loc_perm"
-  type: "Permute"
-  bottom: "conv_blob52"
-  top: "conv6_3_norm_mbox_loc_perm"
-  permute_param {
-    order: 0
-    order: 2
-    order: 3
-    order: 1
-  }
-}
-layer {
-  name: "conv6_3_norm_mbox_loc_flat"
-  type: "Flatten"
-  bottom: "conv6_3_norm_mbox_loc_perm"
-  top: "conv6_3_norm_mbox_loc_flat"
-  flatten_param {
-    axis: 1
-  }
-}
-layer {
-  name: "conv6_3_norm_mbox_conf_perm"
-  type: "Permute"
-  bottom: "conv_blob53"
-  top: "conv6_3_norm_mbox_conf_perm"
-  permute_param {
-    order: 0
-    order: 2
-    order: 3
-    order: 1
-  }
-}
-layer {
-  name: "conv6_3_norm_mbox_conf_flat"
-  type: "Flatten"
-  bottom: "conv6_3_norm_mbox_conf_perm"
-  top: "conv6_3_norm_mbox_conf_flat"
-  flatten_param {
-    axis: 1
-  }
-}
-layer {
-  name: "conv6_3_norm_mbox_priorbox"
-  type: "PriorBox"
-  bottom: "relu_blob41"
-  bottom: "data"
-  top: "conv6_3_norm_mbox_priorbox"
-  prior_box_param {
-    min_size: 256.0
-    min_size: 512.0
-    clip: false
-    variance: 0.1
-    variance: 0.1
-    variance: 0.2
-    variance: 0.2
-    step: 32.0
-    offset: 0.5
-  }
-}
-
-########################################################
-layer {
-  name: "mbox_loc"
-  type: "Concat"
-  bottom: "conv4_3_norm_mbox_loc_flat"
-  bottom: "conv5_3_norm_mbox_loc_flat"
-  bottom: "conv6_3_norm_mbox_loc_flat"
-  top: "mbox_loc"
-  concat_param {
-    axis: 1
-  }
-}
-layer {
-  name: "mbox_conf"
-  type: "Concat"
-  bottom: "conv4_3_norm_mbox_conf_flat"
-  bottom: "conv5_3_norm_mbox_conf_flat"
-  bottom: "conv6_3_norm_mbox_conf_flat"
-  top: "mbox_conf"
-  concat_param {
-    axis: 1
-  }
-}
-layer {
-  name: "mbox_priorbox"
-  type: "Concat"
-  bottom: "conv4_3_norm_mbox_priorbox"
-  bottom: "conv5_3_norm_mbox_priorbox"
-  bottom: "conv6_3_norm_mbox_priorbox"
-  top: "mbox_priorbox"
-  concat_param {
-    axis: 2
-  }
-}
-layer {
-  name: "mbox_conf_reshape"
-  type: "Reshape"
-  bottom: "mbox_conf"
-  top: "mbox_conf_reshape"
-  reshape_param {
-    shape {
-      dim: 0
-      dim: -1
-      dim: 2
-    }
-  }
-}
-layer {
-  name: "mbox_conf_softmax"
-  type: "Softmax"
-  bottom: "mbox_conf_reshape"
-  top: "mbox_conf_softmax"
-  softmax_param {
-    axis: 2
-  }
-}
-layer {
-  name: "mbox_conf_flatten"
-  type: "Flatten"
-  bottom: "mbox_conf_softmax"
-  top: "mbox_conf_flatten"
-  flatten_param {
-    axis: 1
-  }
-}
-layer {
-  name: "detection_out"
-  type: "DetectionOutput"
-  bottom: "mbox_loc"
-  bottom: "mbox_conf_flatten"
-  bottom: "mbox_priorbox"
-  top: "detection_out"
-  include {
-    phase: TEST
-  }
-  detection_output_param {
-    num_classes: 2
-    share_location: true
-    background_label_id: 0
-    nms_param {
-      nms_threshold: 0.3
-      top_k: 400
-    }
-    code_type: CENTER_SIZE
-    keep_top_k: 200
-    confidence_threshold: 0.1
-  }
-}

face_recognition1/face_detect/data/config.py

@@ -1,14 +0,0 @@
-# config.py
-
-cfg = {
-    'name': 'FaceBoxes',
-    #'min_dim': 1024,
-    #'feature_maps': [[32, 32], [16, 16], [8, 8]],
-    # 'aspect_ratios': [[1], [1], [1]],
-    'min_sizes': [[32, 64, 128], [256], [512]],
-    'steps': [32, 64, 128],
-    'variance': [0.1, 0.2],
-    'clip': False,
-    'loc_weight': 2.0,
-    'gpu_train': True
-}

face_recognition1/face_detect/layers/__init__.py

@@ -1,2 +0,0 @@
-from .functions import *
-from .modules import *

face_recognition1/face_detect/layers/functions/prior_box.py

@@ -1,43 +0,0 @@
-import torch
-from itertools import product as product
-import numpy as np
-from math import ceil
-
-
-class PriorBox(object):
-    def __init__(self, cfg, image_size=None, phase='train'):
-        super(PriorBox, self).__init__()
-        #self.aspect_ratios = cfg['aspect_ratios']
-        self.min_sizes = cfg['min_sizes']
-        self.steps = cfg['steps']
-        self.clip = cfg['clip']
-        self.image_size = image_size
-        self.feature_maps = [[ceil(self.image_size[0]/step), ceil(self.image_size[1]/step)] for step in self.steps]
-
-    def forward(self):
-        anchors = []
-        for k, f in enumerate(self.feature_maps):
-            min_sizes = self.min_sizes[k]
-            for i, j in product(range(f[0]), range(f[1])):
-                for min_size in min_sizes:
-                    s_kx = min_size / self.image_size[1]
-                    s_ky = min_size / self.image_size[0]
-                    if min_size == 32:
-                        dense_cx = [x*self.steps[k]/self.image_size[1] for x in [j+0, j+0.25, j+0.5, j+0.75]]
-                        dense_cy = [y*self.steps[k]/self.image_size[0] for y in [i+0, i+0.25, i+0.5, i+0.75]]
-                        for cy, cx in product(dense_cy, dense_cx):
-                            anchors += [cx, cy, s_kx, s_ky]
-                    elif min_size == 64:
-                        dense_cx = [x*self.steps[k]/self.image_size[1] for x in [j+0, j+0.5]]
-                        dense_cy = [y*self.steps[k]/self.image_size[0] for y in [i+0, i+0.5]]
-                        for cy, cx in product(dense_cy, dense_cx):
-                            anchors += [cx, cy, s_kx, s_ky]
-                    else:
-                        cx = (j + 0.5) * self.steps[k] / self.image_size[1]
-                        cy = (i + 0.5) * self.steps[k] / self.image_size[0]
-                        anchors += [cx, cy, s_kx, s_ky]
-        # back to torch land
-        output = torch.Tensor(anchors).view(-1, 4)
-        if self.clip:
-            output.clamp_(max=1, min=0)
-        return output

face_recognition1/face_detect/layers/modules/__init__.py

@@ -1,3 +0,0 @@
-from .multibox_loss import MultiBoxLoss
-
-__all__ = ['MultiBoxLoss']

face_recognition1/face_detect/layers/modules/multibox_loss.py

@@ -1,108 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.autograd import Variable
-from utils.box_utils import match, log_sum_exp
-from data.config import cfg
-GPU = cfg['gpu_train']
-
-class MultiBoxLoss(nn.Module):
-    """SSD Weighted Loss Function
-    Compute Targets:
-        1) Produce Confidence Target Indices by matching  ground truth boxes
-           with (default) 'priorboxes' that have jaccard index > threshold parameter
-           (default threshold: 0.5).
-        2) Produce localization target by 'encoding' variance into offsets of ground
-           truth boxes and their matched  'priorboxes'.
-        3) Hard negative mining to filter the excessive number of negative examples
-           that comes with using a large number of default bounding boxes.
-           (default negative:positive ratio 3:1)
-    Objective Loss:
-        L(x,c,l,g) = (Lconf(x, c) + αLloc(x,l,g)) / N
-        Where, Lconf is the CrossEntropy Loss and Lloc is the SmoothL1 Loss
-        weighted by α which is set to 1 by cross val.
-        Args:
-            c: class confidences,
-            l: predicted boxes,
-            g: ground truth boxes
-            N: number of matched default boxes
-        See: https://arxiv.org/pdf/1512.02325.pdf for more details.
-    """
-
-    def __init__(self, num_classes, overlap_thresh, prior_for_matching, bkg_label, neg_mining, neg_pos, neg_overlap, encode_target):
-        super(MultiBoxLoss, self).__init__()
-        self.num_classes = num_classes
-        self.threshold = overlap_thresh
-        self.background_label = bkg_label
-        self.encode_target = encode_target
-        self.use_prior_for_matching = prior_for_matching
-        self.do_neg_mining = neg_mining
-        self.negpos_ratio = neg_pos
-        self.neg_overlap = neg_overlap
-        self.variance = [0.1, 0.2]
-
-    def forward(self, predictions, priors, targets):
-        """Multibox Loss
-        Args:
-            predictions (tuple): A tuple containing loc preds, conf preds,
-            and prior boxes from SSD net.
-                conf shape: torch.size(batch_size,num_priors,num_classes)
-                loc shape: torch.size(batch_size,num_priors,4)
-                priors shape: torch.size(num_priors,4)
-
-            ground_truth (tensor): Ground truth boxes and labels for a batch,
-                shape: [batch_size,num_objs,5] (last idx is the label).
-        """
-
-        loc_data, conf_data = predictions
-        priors = priors
-        num = loc_data.size(0)
-        num_priors = (priors.size(0))
-
-        # match priors (default boxes) and ground truth boxes
-        loc_t = torch.Tensor(num, num_priors, 4)
-        conf_t = torch.LongTensor(num, num_priors)
-        for idx in range(num):
-            truths = targets[idx][:, :-1].data
-            labels = targets[idx][:, -1].data
-            defaults = priors.data
-            match(self.threshold, truths, defaults, self.variance, labels, loc_t, conf_t, idx)
-        if GPU:
-            loc_t = loc_t.cuda()
-            conf_t = conf_t.cuda()
-
-        pos = conf_t > 0
-
-        # Localization Loss (Smooth L1)
-        # Shape: [batch,num_priors,4]
-        pos_idx = pos.unsqueeze(pos.dim()).expand_as(loc_data)
-        loc_p = loc_data[pos_idx].view(-1, 4)
-        loc_t = loc_t[pos_idx].view(-1, 4)
-        loss_l = F.smooth_l1_loss(loc_p, loc_t, reduction='sum')
-
-        # Compute max conf across batch for hard negative mining
-        batch_conf = conf_data.view(-1, self.num_classes)
-        loss_c = log_sum_exp(batch_conf) - batch_conf.gather(1, conf_t.view(-1, 1))
-
-        # Hard Negative Mining
-        loss_c[pos.view(-1, 1)] = 0 # filter out pos boxes for now
-        loss_c = loss_c.view(num, -1)
-        _, loss_idx = loss_c.sort(1, descending=True)
-        _, idx_rank = loss_idx.sort(1)
-        num_pos = pos.long().sum(1, keepdim=True)
-        num_neg = torch.clamp(self.negpos_ratio*num_pos, max=pos.size(1)-1)
-        neg = idx_rank < num_neg.expand_as(idx_rank)
-
-        # Confidence Loss Including Positive and Negative Examples
-        pos_idx = pos.unsqueeze(2).expand_as(conf_data)
-        neg_idx = neg.unsqueeze(2).expand_as(conf_data)
-        conf_p = conf_data[(pos_idx+neg_idx).gt(0)].view(-1,self.num_classes)
-        targets_weighted = conf_t[(pos+neg).gt(0)]
-        loss_c = F.cross_entropy(conf_p, targets_weighted, reduction='sum')
-
-        # Sum of losses: L(x,c,l,g) = (Lconf(x, c) + αLloc(x,l,g)) / N
-        N = max(num_pos.data.sum().float(), 1)
-        loss_l /= N
-        loss_c /= N
-
-        return loss_l, loss_c

face_recognition1/face_detect/models/faceboxes.py

@@ -1,149 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class BasicConv2d(nn.Module):
-
-    def __init__(self, in_channels, out_channels, **kwargs):
-        super(BasicConv2d, self).__init__()
-        self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
-        self.bn = nn.BatchNorm2d(out_channels, eps=1e-5)
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        return F.relu(x, inplace=True)
-
-
-class Inception(nn.Module):
-
-  def __init__(self):
-    super(Inception, self).__init__()
-    self.branch1x1 = BasicConv2d(128, 32, kernel_size=1, padding=0)
-    self.branch1x1_2 = BasicConv2d(128, 32, kernel_size=1, padding=0)
-    self.branch3x3_reduce = BasicConv2d(128, 24, kernel_size=1, padding=0)
-    self.branch3x3 = BasicConv2d(24, 32, kernel_size=3, padding=1)
-    self.branch3x3_reduce_2 = BasicConv2d(128, 24, kernel_size=1, padding=0)
-    self.branch3x3_2 = BasicConv2d(24, 32, kernel_size=3, padding=1)
-    self.branch3x3_3 = BasicConv2d(32, 32, kernel_size=3, padding=1)
-
-  def forward(self, x):
-    branch1x1 = self.branch1x1(x)
-
-    branch1x1_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
-    branch1x1_2 = self.branch1x1_2(branch1x1_pool)
-
-    branch3x3_reduce = self.branch3x3_reduce(x)
-    branch3x3 = self.branch3x3(branch3x3_reduce)
-
-    branch3x3_reduce_2 = self.branch3x3_reduce_2(x)
-    branch3x3_2 = self.branch3x3_2(branch3x3_reduce_2)
-    branch3x3_3 = self.branch3x3_3(branch3x3_2)
-
-    outputs = [branch1x1, branch1x1_2, branch3x3, branch3x3_3]
-    return torch.cat(outputs, 1)
-
-
-class CRelu(nn.Module):
-
-  def __init__(self, in_channels, out_channels, **kwargs):
-    super(CRelu, self).__init__()
-    self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
-    self.bn = nn.BatchNorm2d(out_channels, eps=1e-5)
-
-  def forward(self, x):
-    x = self.conv(x)
-    x = self.bn(x)
-    x = torch.cat([x, -x], 1)
-    x = F.relu(x, inplace=True)
-    return x
-
-
-class FaceBoxes(nn.Module):
-
-  def __init__(self, phase, size, num_classes):
-    super(FaceBoxes, self).__init__()
-    self.phase = phase
-    self.num_classes = num_classes
-    self.size = size
-
-    self.conv1 = CRelu(3, 24, kernel_size=7, stride=4, padding=3)
-    self.conv2 = CRelu(48, 64, kernel_size=5, stride=2, padding=2)
-
-    self.inception1 = Inception()
-    self.inception2 = Inception()
-    self.inception3 = Inception()
-
-    self.conv3_1 = BasicConv2d(128, 128, kernel_size=1, stride=1, padding=0)
-    self.conv3_2 = BasicConv2d(128, 256, kernel_size=3, stride=2, padding=1)
-
-    self.conv4_1 = BasicConv2d(256, 128, kernel_size=1, stride=1, padding=0)
-    self.conv4_2 = BasicConv2d(128, 256, kernel_size=3, stride=2, padding=1)
-
-    self.loc, self.conf = self.multibox(self.num_classes)
-
-    if self.phase == 'test':
-        self.softmax = nn.Softmax(dim=-1)
-
-    if self.phase == 'train':
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                if m.bias is not None:
-                    nn.init.xavier_normal_(m.weight.data)
-                    m.bias.data.fill_(0.02)
-                else:
-                    m.weight.data.normal_(0, 0.01)
-            elif isinstance(m, nn.BatchNorm2d):
-                m.weight.data.fill_(1)
-                m.bias.data.zero_()
-
-  def multibox(self, num_classes):
-    loc_layers = []
-    conf_layers = []
-    loc_layers += [nn.Conv2d(128, 21 * 4, kernel_size=3, padding=1)]
-    conf_layers += [nn.Conv2d(128, 21 * num_classes, kernel_size=3, padding=1)]
-    loc_layers += [nn.Conv2d(256, 1 * 4, kernel_size=3, padding=1)]
-    conf_layers += [nn.Conv2d(256, 1 * num_classes, kernel_size=3, padding=1)]
-    loc_layers += [nn.Conv2d(256, 1 * 4, kernel_size=3, padding=1)]
-    conf_layers += [nn.Conv2d(256, 1 * num_classes, kernel_size=3, padding=1)]
-    return nn.Sequential(*loc_layers), nn.Sequential(*conf_layers)
-
-  def forward(self, x):
-
-    detection_sources = list()
-    loc = list()
-    conf = list()
-
-    x = self.conv1(x)
-    x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
-    x = self.conv2(x)
-    x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
-    x = self.inception1(x)
-    x = self.inception2(x)
-    x = self.inception3(x)
-    detection_sources.append(x)
-
-    x = self.conv3_1(x)
-    x = self.conv3_2(x)
-    detection_sources.append(x)
-
-    x = self.conv4_1(x)
-    x = self.conv4_2(x)
-    detection_sources.append(x)
-
-    for (x, l, c) in zip(detection_sources, self.loc, self.conf):
-        loc.append(l(x).permute(0, 2, 3, 1).contiguous())
-        conf.append(c(x).permute(0, 2, 3, 1).contiguous())
-
-    loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)
-    conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)
-
-    if self.phase == "test":
-      output = (loc.view(loc.size(0), -1, 4),
-                self.softmax(conf.view(conf.size(0), -1, self.num_classes)))
-    else:
-      output = (loc.view(loc.size(0), -1, 4),
-                conf.view(conf.size(0), -1, self.num_classes))
-
-    return output

face_recognition1/face_detect/models/voc-model-labels.txt

@@ -1,2 +0,0 @@
-BACKGROUND
-face

face_recognition1/face_detect/test.py

@@ -1,197 +0,0 @@
-import os
-import sys
-sys.path.append(os.path.dirname(__file__))
-
-import cv2
-import math
-import torch
-import torch.backends.cudnn as cudnn
-import numpy as np
-from data.config import cfg
-from layers.functions.prior_box import PriorBox
-from utils.nms_wrapper import nms
-from models.faceboxes import FaceBoxes
-from utils.box_utils import decode
-from utils.timer import Timer
-
-trained_model = os.path.join(os.path.dirname(__file__), './checkpoints/FaceBoxesProd.pth')
-save_folder = 'eval'
-dataset = 'Custom'
-confidence_threshold = 0.2
-top_k = 5000
-nms_threshold = 0.3
-keep_top_k = 750
-show_image = True
-vis_thres = 0.5
-
-
-def check_keys(model, pretrained_state_dict):
-    ckpt_keys = set(pretrained_state_dict.keys())
-    model_keys = set(model.state_dict().keys())
-    used_pretrained_keys = model_keys & ckpt_keys
-    unused_pretrained_keys = ckpt_keys - model_keys
-    missing_keys = model_keys - ckpt_keys
-    print('Missing keys:{}'.format(len(missing_keys)))
-    print('Unused checkpoint keys:{}'.format(len(unused_pretrained_keys)))
-    print('Used keys:{}'.format(len(used_pretrained_keys)))
-    assert len(used_pretrained_keys) > 0, 'load NONE from pretrained checkpoint'
-    return True
-
-
-def remove_prefix(state_dict, prefix):
-    """ Old style model is stored with all names of parameters sharing common prefix 'module.' """
-    print('remove prefix \'{}\''.format(prefix))
-    f = lambda x: x.split(prefix, 1)[-1] if x.startswith(prefix) else x
-    return {f(key): value for key, value in state_dict.items()}
-
-
-def load_model(model, pretrained_path, device):
-    print('Loading pretrained model from {}'.format(pretrained_path))
-    pretrained_dict = torch.load(pretrained_path, map_location=device)
-
-    if "state_dict" in pretrained_dict.keys():
-        pretrained_dict = remove_prefix(pretrained_dict['state_dict'], 'module.')
-    else:
-        pretrained_dict = remove_prefix(pretrained_dict, 'module.')
-    check_keys(model, pretrained_dict)
-    model.load_state_dict(pretrained_dict, strict=False)
-    return model
-
-
-torch.set_grad_enabled(False)
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-net = FaceBoxes(phase='test', size=None, num_classes=2)
-net = load_model(net, trained_model, device)
-net.eval()
-cudnn.benchmark = True
-net = net.to(device)
-
-
-def get_bbox(orig_image):
-    # testing scale
-    resize = 0.5
-
-    _t = {'forward_pass': Timer(), 'misc': Timer()}
-
-    img_raw = orig_image
-    img = np.float32(img_raw)
-    if resize != 1:
-        img = cv2.resize(img, None, None, fx=resize, fy=resize, interpolation=cv2.INTER_LINEAR)
-    im_height, im_width, _ = img.shape
-    scale = torch.Tensor([img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
-    img -= (104, 117, 123)
-    img = img.transpose(2, 0, 1)
-    img = torch.from_numpy(img).unsqueeze(0)
-    img = img.to(device)
-    scale = scale.to(device)
-
-    _t['forward_pass'].tic()
-    loc, conf = net(img)  # forward pass
-    _t['forward_pass'].toc()
-    _t['misc'].tic()
-    priorbox = PriorBox(cfg, image_size=(im_height, im_width))
-    priors = priorbox.forward()
-    priors = priors.to(device)
-    prior_data = priors.data
-    boxes = decode(loc.data.squeeze(0), prior_data, cfg['variance'])
-    boxes = boxes * scale / resize
-    boxes = boxes.cpu().numpy()
-    scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
-
-    # ignore low scores
-    inds = np.where(scores > confidence_threshold)[0]
-    boxes = boxes[inds]
-    scores = scores[inds]
-
-    # keep top-K before NMS
-    order = scores.argsort()[::-1][:top_k]
-    boxes = boxes[order]
-    scores = scores[order]
-
-    # do NMS
-    dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=False)
-    #keep = py_cpu_nms(dets, nms_threshold)
-    keep = nms(dets, nms_threshold, force_cpu=True)
-    dets = dets[keep, :]
-
-    # keep top-K faster NMS
-    dets = dets[:keep_top_k, :]
-    _t['misc'].toc()
-
-    boxes, scores = [], []
-    for k in range(dets.shape[0]):
-        xmin = dets[k, 0]
-        ymin = dets[k, 1]
-        xmax = dets[k, 2]
-        ymax = dets[k, 3]
-        ymin += 0.2 * (ymax - ymin + 1)
-        score = dets[k, 4]
-        boxes.append([int(xmin), int(ymin), int(xmax - xmin), int(ymax - ymin)])
-        scores.append(score)
-
-    max_score = 0.0
-    final_box = None
-    for i, score in enumerate(scores):
-        if max_score < score:
-            max_score = score
-            final_box = boxes[i]
-
-    return final_box
-
-
-class Detection:
-    def __init__(self):
-        src_dir = os.path.dirname(__file__)
-        if not os.path.exists(os.path.join(src_dir, "checkpoints")):
-            os.makedirs(os.path.join(src_dir, "checkpoints"))
-
-        caffemodel = os.path.join(src_dir, "checkpoints/Widerface-RetinaFace.caffemodel")
-        deploy = os.path.join(src_dir, "checkpoints/deploy.prototxt")
-
-        self.detector = cv2.dnn.readNetFromCaffe(deploy, caffemodel)
-        self.detector_confidence = 0.6
-
-    def get_bbox(self, img):
-        height, width = img.shape[0], img.shape[1]
-        aspect_ratio = width / height
-        if img.shape[1] * img.shape[0] >= 192 * 192:
-            img = cv2.resize(img,
-                             (int(192 * math.sqrt(aspect_ratio)),
-                              int(192 / math.sqrt(aspect_ratio))), interpolation=cv2.INTER_LINEAR)
-
-        blob = cv2.dnn.blobFromImage(img, 1, mean=(104, 117, 123))
-        self.detector.setInput(blob, 'data')
-        out = self.detector.forward('detection_out').squeeze()
-        max_conf_index = np.argmax(out[:, 2])
-        left, top, right, bottom = out[max_conf_index, 3]*width, out[max_conf_index, 4]*height, \
-                                   out[max_conf_index, 5]*width, out[max_conf_index, 6]*height
-
-        if right == left or bottom == top:
-            return None
-
-        bbox = [int(left), int(top), int(right-left+1), int(bottom-top+1)]
-        return bbox
-
-    def check_face(self):
-        pass
-
-
-if __name__ == '__main__':
-
-    # image = cv2.imread('arun_2.jpg')
-
-    # box = get_bbox(image)
-    # cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 0, 255), 2)
-    #
-    src_dir = 'D:/19.Database/office_angled_db'
-    dst_dir = 'D:/19.Database/office_angled_db_result'
-    detector = Detection()
-
-    for file in os.listdir(src_dir):
-        image1 = cv2.imread(os.path.join(src_dir, file))
-        box = detector.get_bbox(image1)
-        if box:
-            cv2.rectangle(image1, (box[0], box[1]), (box[0] + box[2], box[1] + box[3]), (0, 0, 255), 5)
-
-        cv2.imwrite(os.path.join(dst_dir, file), image1)
-        # cv2.waitKey(0)

face_recognition1/face_detect/utils/box_utils.py

@@ -1,276 +0,0 @@
-import torch
-import numpy as np
-
-
-def point_form(boxes):
-    """ Convert prior_boxes to (xmin, ymin, xmax, ymax)
-    representation for comparison to point form ground truth data.
-    Args:
-        boxes: (tensor) center-size default boxes from priorbox layers.
-    Return:
-        boxes: (tensor) Converted xmin, ymin, xmax, ymax form of boxes.
-    """
-    return torch.cat((boxes[:, :2] - boxes[:, 2:]/2,     # xmin, ymin
-                     boxes[:, :2] + boxes[:, 2:]/2), 1)  # xmax, ymax
-
-
-def center_size(boxes):
-    """ Convert prior_boxes to (cx, cy, w, h)
-    representation for comparison to center-size form ground truth data.
-    Args:
-        boxes: (tensor) point_form boxes
-    Return:
-        boxes: (tensor) Converted xmin, ymin, xmax, ymax form of boxes.
-    """
-    return torch.cat((boxes[:, 2:] + boxes[:, :2])/2,  # cx, cy
-                     boxes[:, 2:] - boxes[:, :2], 1)  # w, h
-
-
-def intersect(box_a, box_b):
-    """ We resize both tensors to [A,B,2] without new malloc:
-    [A,2] -> [A,1,2] -> [A,B,2]
-    [B,2] -> [1,B,2] -> [A,B,2]
-    Then we compute the area of intersect between box_a and box_b.
-    Args:
-      box_a: (tensor) bounding boxes, Shape: [A,4].
-      box_b: (tensor) bounding boxes, Shape: [B,4].
-    Return:
-      (tensor) intersection area, Shape: [A,B].
-    """
-    A = box_a.size(0)
-    B = box_b.size(0)
-    max_xy = torch.min(box_a[:, 2:].unsqueeze(1).expand(A, B, 2),
-                       box_b[:, 2:].unsqueeze(0).expand(A, B, 2))
-    min_xy = torch.max(box_a[:, :2].unsqueeze(1).expand(A, B, 2),
-                       box_b[:, :2].unsqueeze(0).expand(A, B, 2))
-    inter = torch.clamp((max_xy - min_xy), min=0)
-    return inter[:, :, 0] * inter[:, :, 1]
-
-
-def jaccard(box_a, box_b):
-    """Compute the jaccard overlap of two sets of boxes.  The jaccard overlap
-    is simply the intersection over union of two boxes.  Here we operate on
-    ground truth boxes and default boxes.
-    E.g.:
-        A ∩ B / A ∪ B = A ∩ B / (area(A) + area(B) - A ∩ B)
-    Args:
-        box_a: (tensor) Ground truth bounding boxes, Shape: [num_objects,4]
-        box_b: (tensor) Prior boxes from priorbox layers, Shape: [num_priors,4]
-    Return:
-        jaccard overlap: (tensor) Shape: [box_a.size(0), box_b.size(0)]
-    """
-    inter = intersect(box_a, box_b)
-    area_a = ((box_a[:, 2]-box_a[:, 0]) *
-              (box_a[:, 3]-box_a[:, 1])).unsqueeze(1).expand_as(inter)  # [A,B]
-    area_b = ((box_b[:, 2]-box_b[:, 0]) *
-              (box_b[:, 3]-box_b[:, 1])).unsqueeze(0).expand_as(inter)  # [A,B]
-    union = area_a + area_b - inter
-    return inter / union  # [A,B]
-
-
-def matrix_iou(a, b):
-    """
-    return iou of a and b, numpy version for data augenmentation
-    """
-    lt = np.maximum(a[:, np.newaxis, :2], b[:, :2])
-    rb = np.minimum(a[:, np.newaxis, 2:], b[:, 2:])
-
-    area_i = np.prod(rb - lt, axis=2) * (lt < rb).all(axis=2)
-    area_a = np.prod(a[:, 2:] - a[:, :2], axis=1)
-    area_b = np.prod(b[:, 2:] - b[:, :2], axis=1)
-    return area_i / (area_a[:, np.newaxis] + area_b - area_i)
-
-
-def matrix_iof(a, b):
-    """
-    return iof of a and b, numpy version for data augenmentation
-    """
-    lt = np.maximum(a[:, np.newaxis, :2], b[:, :2])
-    rb = np.minimum(a[:, np.newaxis, 2:], b[:, 2:])
-
-    area_i = np.prod(rb - lt, axis=2) * (lt < rb).all(axis=2)
-    area_a = np.prod(a[:, 2:] - a[:, :2], axis=1)
-    return area_i / np.maximum(area_a[:, np.newaxis], 1)
-
-
-def match(threshold, truths, priors, variances, labels, loc_t, conf_t, idx):
-    """Match each prior box with the ground truth box of the highest jaccard
-    overlap, encode the bounding boxes, then return the matched indices
-    corresponding to both confidence and location preds.
-    Args:
-        threshold: (float) The overlap threshold used when mathing boxes.
-        truths: (tensor) Ground truth boxes, Shape: [num_obj, num_priors].
-        priors: (tensor) Prior boxes from priorbox layers, Shape: [n_priors,4].
-        variances: (tensor) Variances corresponding to each prior coord,
-            Shape: [num_priors, 4].
-        labels: (tensor) All the class labels for the image, Shape: [num_obj].
-        loc_t: (tensor) Tensor to be filled w/ endcoded location targets.
-        conf_t: (tensor) Tensor to be filled w/ matched indices for conf preds.
-        idx: (int) current batch index
-    Return:
-        The matched indices corresponding to 1)location and 2)confidence preds.
-    """
-    # jaccard index
-    overlaps = jaccard(
-        truths,
-        point_form(priors)
-    )
-    # (Bipartite Matching)
-    # [1,num_objects] best prior for each ground truth
-    best_prior_overlap, best_prior_idx = overlaps.max(1, keepdim=True)
-
-    # ignore hard gt
-    valid_gt_idx = best_prior_overlap[:, 0] >= 0.2
-    best_prior_idx_filter = best_prior_idx[valid_gt_idx, :]
-    if best_prior_idx_filter.shape[0] <= 0:
-        loc_t[idx] = 0
-        conf_t[idx] = 0
-        return
-
-    # [1,num_priors] best ground truth for each prior
-    best_truth_overlap, best_truth_idx = overlaps.max(0, keepdim=True)
-    best_truth_idx.squeeze_(0)
-    best_truth_overlap.squeeze_(0)
-    best_prior_idx.squeeze_(1)
-    best_prior_idx_filter.squeeze_(1)
-    best_prior_overlap.squeeze_(1)
-    best_truth_overlap.index_fill_(0, best_prior_idx_filter, 2)  # ensure best prior
-    # TODO refactor: index  best_prior_idx with long tensor
-    # ensure every gt matches with its prior of max overlap
-    for j in range(best_prior_idx.size(0)):
-        best_truth_idx[best_prior_idx[j]] = j
-    matches = truths[best_truth_idx]          # Shape: [num_priors,4]
-    conf = labels[best_truth_idx]          # Shape: [num_priors]
-    conf[best_truth_overlap < threshold] = 0  # label as background
-    loc = encode(matches, priors, variances)
-    loc_t[idx] = loc    # [num_priors,4] encoded offsets to learn
-    conf_t[idx] = conf  # [num_priors] top class label for each prior
-
-
-def encode(matched, priors, variances):
-    """Encode the variances from the priorbox layers into the ground truth boxes
-    we have matched (based on jaccard overlap) with the prior boxes.
-    Args:
-        matched: (tensor) Coords of ground truth for each prior in point-form
-            Shape: [num_priors, 4].
-        priors: (tensor) Prior boxes in center-offset form
-            Shape: [num_priors,4].
-        variances: (list[float]) Variances of priorboxes
-    Return:
-        encoded boxes (tensor), Shape: [num_priors, 4]
-    """
-
-    # dist b/t match center and prior's center
-    g_cxcy = (matched[:, :2] + matched[:, 2:])/2 - priors[:, :2]
-    # encode variance
-    g_cxcy /= (variances[0] * priors[:, 2:])
-    # match wh / prior wh
-    g_wh = (matched[:, 2:] - matched[:, :2]) / priors[:, 2:]
-    g_wh = torch.log(g_wh) / variances[1]
-    # return target for smooth_l1_loss
-    return torch.cat([g_cxcy, g_wh], 1)  # [num_priors,4]
-
-
-# Adapted from https://github.com/Hakuyume/chainer-ssd
-def decode(loc, priors, variances):
-    """Decode locations from predictions using priors to undo
-    the encoding we did for offset regression at train time.
-    Args:
-        loc (tensor): location predictions for loc layers,
-            Shape: [num_priors,4]
-        priors (tensor): Prior boxes in center-offset form.
-            Shape: [num_priors,4].
-        variances: (list[float]) Variances of priorboxes
-    Return:
-        decoded bounding box predictions
-    """
-
-    boxes = torch.cat((
-        priors[:, :2] + loc[:, :2] * variances[0] * priors[:, 2:],
-        priors[:, 2:] * torch.exp(loc[:, 2:] * variances[1])), 1)
-    boxes[:, :2] -= boxes[:, 2:] / 2
-    boxes[:, 2:] += boxes[:, :2]
-    return boxes
-
-
-def log_sum_exp(x):
-    """Utility function for computing log_sum_exp while determining
-    This will be used to determine unaveraged confidence loss across
-    all examples in a batch.
-    Args:
-        x (Variable(tensor)): conf_preds from conf layers
-    """
-    x_max = x.data.max()
-    return torch.log(torch.sum(torch.exp(x-x_max), 1, keepdim=True)) + x_max
-
-
-# Original author: Francisco Massa:
-# https://github.com/fmassa/object-detection.torch
-# Ported to PyTorch by Max deGroot (02/01/2017)
-def nms(boxes, scores, overlap=0.5, top_k=200):
-    """Apply non-maximum suppression at test time to avoid detecting too many
-    overlapping bounding boxes for a given object.
-    Args:
-        boxes: (tensor) The location preds for the img, Shape: [num_priors,4].
-        scores: (tensor) The class predscores for the img, Shape:[num_priors].
-        overlap: (float) The overlap thresh for suppressing unnecessary boxes.
-        top_k: (int) The Maximum number of box preds to consider.
-    Return:
-        The indices of the kept boxes with respect to num_priors.
-    """
-
-    keep = torch.Tensor(scores.size(0)).fill_(0).long()
-    if boxes.numel() == 0:
-        return keep
-    x1 = boxes[:, 0]
-    y1 = boxes[:, 1]
-    x2 = boxes[:, 2]
-    y2 = boxes[:, 3]
-    area = torch.mul(x2 - x1, y2 - y1)
-    v, idx = scores.sort(0)  # sort in ascending order
-    # I = I[v >= 0.01]
-    idx = idx[-top_k:]  # indices of the top-k largest vals
-    xx1 = boxes.new()
-    yy1 = boxes.new()
-    xx2 = boxes.new()
-    yy2 = boxes.new()
-    w = boxes.new()
-    h = boxes.new()
-
-    # keep = torch.Tensor()
-    count = 0
-    while idx.numel() > 0:
-        i = idx[-1]  # index of current largest val
-        # keep.append(i)
-        keep[count] = i
-        count += 1
-        if idx.size(0) == 1:
-            break
-        idx = idx[:-1]  # remove kept element from view
-        # load bboxes of next highest vals
-        torch.index_select(x1, 0, idx, out=xx1)
-        torch.index_select(y1, 0, idx, out=yy1)
-        torch.index_select(x2, 0, idx, out=xx2)
-        torch.index_select(y2, 0, idx, out=yy2)
-        # store element-wise max with next highest score
-        xx1 = torch.clamp(xx1, min=x1[i])
-        yy1 = torch.clamp(yy1, min=y1[i])
-        xx2 = torch.clamp(xx2, max=x2[i])
-        yy2 = torch.clamp(yy2, max=y2[i])
-        w.resize_as_(xx2)
-        h.resize_as_(yy2)
-        w = xx2 - xx1
-        h = yy2 - yy1
-        # check sizes of xx1 and xx2.. after each iteration
-        w = torch.clamp(w, min=0.0)
-        h = torch.clamp(h, min=0.0)
-        inter = w*h
-        # IoU = i / (area(a) + area(b) - i)
-        rem_areas = torch.index_select(area, 0, idx)  # load remaining areas)
-        union = (rem_areas - inter) + area[i]
-        IoU = inter/union  # store result in iou
-        # keep only elements with an IoU <= overlap
-        idx = idx[IoU.le(overlap)]
-    return keep, count
-
-

face_recognition1/face_detect/utils/build.py

@@ -1,138 +0,0 @@
-import os
-from os.path import join as pjoin
-import numpy as np
-from distutils.core import setup
-from distutils.extension import Extension
-from Cython.Distutils import build_ext
-
-
-def find_in_path(name, path):
-    "Find a file in a search path"
-    # adapted fom http://code.activestate.com/recipes/52224-find-a-file-given-a-search-path/
-    for dir in path.split(os.pathsep):
-        binpath = pjoin(dir, name)
-        if os.path.exists(binpath):
-            return os.path.abspath(binpath)
-    return None
-
-
-def locate_cuda():
-    """Locate the CUDA environment on the system
-
-    Returns a dict with keys 'home', 'nvcc', 'include', and 'lib64'
-    and values giving the absolute path to each directory.
-
-    Starts by looking for the CUDAHOME env variable. If not found, everything
-    is based on finding 'nvcc' in the PATH.
-    """
-
-    # first check if the CUDAHOME env variable is in use
-    if 'CUDAHOME' in os.environ:
-        home = os.environ['CUDAHOME']
-        nvcc = pjoin(home, 'bin', 'nvcc')
-    else:
-        # otherwise, search the PATH for NVCC
-        default_path = pjoin(os.sep, 'usr', 'local', 'cuda', 'bin')
-        nvcc = find_in_path('nvcc', os.environ['PATH'] + os.pathsep + default_path)
-        if nvcc is None:
-            raise EnvironmentError('The nvcc binary could not be '
-                                   'located in your $PATH. Either add it to your path, or set $CUDAHOME')
-        home = os.path.dirname(os.path.dirname(nvcc))
-
-    cudaconfig = {'home': home, 'nvcc': nvcc,
-                  'include': pjoin(home, 'include'),
-                  'lib64': pjoin(home, 'lib64')}
-    for k, v in cudaconfig.items():
-        if not os.path.exists(v):
-            raise EnvironmentError('The CUDA %s path could not be located in %s' % (k, v))
-
-    return cudaconfig
-
-
-CUDA = locate_cuda()
-
-# Obtain the numpy include directory.  This logic works across numpy versions.
-try:
-    numpy_include = np.get_include()
-except AttributeError:
-    numpy_include = np.get_numpy_include()
-
-
-def customize_compiler_for_nvcc(self):
-    """inject deep into distutils to customize how the dispatch
-    to gcc/nvcc works.
-
-    If you subclass UnixCCompiler, it's not trivial to get your subclass
-    injected in, and still have the right customizations (i.e.
-    distutils.sysconfig.customize_compiler) run on it. So instead of going
-    the OO route, I have this. Note, it's kindof like a wierd functional
-    subclassing going on."""
-
-    # tell the compiler it can processes .cu
-    self.src_extensions.append('.cu')
-
-    # save references to the default compiler_so and _comple methods
-    default_compiler_so = self.compiler_so
-    super = self._compile
-
-    # now redefine the _compile method. This gets executed for each
-    # object but distutils doesn't have the ability to change compilers
-    # based on source extension: we add it.
-    def _compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
-        print(extra_postargs)
-        if os.path.splitext(src)[1] == '.cu':
-            # use the cuda for .cu files
-            self.set_executable('compiler_so', CUDA['nvcc'])
-            # use only a subset of the extra_postargs, which are 1-1 translated
-            # from the extra_compile_args in the Extension class
-            postargs = extra_postargs['nvcc']
-        else:
-            postargs = extra_postargs['gcc']
-
-        super(obj, src, ext, cc_args, postargs, pp_opts)
-        # reset the default compiler_so, which we might have changed for cuda
-        self.compiler_so = default_compiler_so
-
-    # inject our redefined _compile method into the class
-    self._compile = _compile
-
-
-# run the customize_compiler
-class custom_build_ext(build_ext):
-    def build_extensions(self):
-        customize_compiler_for_nvcc(self.compiler)
-        build_ext.build_extensions(self)
-
-
-ext_modules = [
-    Extension(
-        "nms.cpu_nms",
-        ["nms/cpu_nms.pyx"],
-        extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
-        include_dirs=[numpy_include]
-    ),
-    Extension('nms.gpu_nms',
-              ['nms/nms_kernel.cu', 'nms/gpu_nms.pyx'],
-              library_dirs=[CUDA['lib64']],
-              libraries=['cudart'],
-              language='c++',
-              runtime_library_dirs=[CUDA['lib64']],
-              # this syntax is specific to this build system
-              # we're only going to use certain compiler args with nvcc and not with gcc
-              # the implementation of this trick is in customize_compiler() below
-              extra_compile_args={'gcc': ["-Wno-unused-function"],
-                                  'nvcc': ['-arch=sm_52',
-                                           '--ptxas-options=-v',
-                                           '-c',
-                                           '--compiler-options',
-                                           "'-fPIC'"]},
-              include_dirs=[numpy_include, CUDA['include']]
-              ),
-]
-
-setup(
-    name='mot_utils',
-    ext_modules=ext_modules,
-    # inject our custom trigger
-    cmdclass={'build_ext': custom_build_ext},
-)

face_recognition1/face_detect/utils/nms/cpu_nms.pyx

@@ -1,156 +0,0 @@
-import numpy as np
-cimport numpy as np
-
-cdef inline np.float32_t max(np.float32_t a, np.float32_t b):
-    return a if a >= b else b
-
-cdef inline np.float32_t min(np.float32_t a, np.float32_t b):
-    return a if a <= b else b
-
-def cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
-    cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
-    cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
-    cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
-    cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
-    cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
-
-    cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-    cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
-
-    cdef int ndets = dets.shape[0]
-    cdef np.ndarray[np.int_t, ndim=1] suppressed = \
-            np.zeros((ndets), dtype=np.int)
-
-    # nominal indices
-    cdef int _i, _j
-    # sorted indices
-    cdef int i, j
-    # temp variables for box i's (the box currently under consideration)
-    cdef np.float32_t ix1, iy1, ix2, iy2, iarea
-    # variables for computing overlap with box j (lower scoring box)
-    cdef np.float32_t xx1, yy1, xx2, yy2
-    cdef np.float32_t w, h
-    cdef np.float32_t inter, ovr
-
-    keep = []
-    for _i in range(ndets):
-        i = order[_i]
-        if suppressed[i] == 1:
-            continue
-        keep.append(i)
-        ix1 = x1[i]
-        iy1 = y1[i]
-        ix2 = x2[i]
-        iy2 = y2[i]
-        iarea = areas[i]
-        for _j in range(_i + 1, ndets):
-            j = order[_j]
-            if suppressed[j] == 1:
-                continue
-            xx1 = max(ix1, x1[j])
-            yy1 = max(iy1, y1[j])
-            xx2 = min(ix2, x2[j])
-            yy2 = min(iy2, y2[j])
-            w = max(0.0, xx2 - xx1 + 1)
-            h = max(0.0, yy2 - yy1 + 1)
-            inter = w * h
-            ovr = inter / (iarea + areas[j] - inter)
-            if ovr >= thresh:
-                suppressed[j] = 1
-
-    return keep
-
-def cpu_soft_nms(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0):
-    cdef unsigned int N = boxes.shape[0]
-    cdef float iw, ih, box_area
-    cdef float ua
-    cdef int pos = 0
-    cdef float maxscore = 0
-    cdef int maxpos = 0
-    cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
-
-    for i in range(N):
-        maxscore = boxes[i, 4]
-        maxpos = i
-
-        tx1 = boxes[i,0]
-        ty1 = boxes[i,1]
-        tx2 = boxes[i,2]
-        ty2 = boxes[i,3]
-        ts = boxes[i,4]
-
-        pos = i + 1
-	# get max box
-        while pos < N:
-            if maxscore < boxes[pos, 4]:
-                maxscore = boxes[pos, 4]
-                maxpos = pos
-            pos = pos + 1
-
-	# add max box as a detection
-        boxes[i,0] = boxes[maxpos,0]
-        boxes[i,1] = boxes[maxpos,1]
-        boxes[i,2] = boxes[maxpos,2]
-        boxes[i,3] = boxes[maxpos,3]
-        boxes[i,4] = boxes[maxpos,4]
-
-	# swap ith box with position of max box
-        boxes[maxpos,0] = tx1
-        boxes[maxpos,1] = ty1
-        boxes[maxpos,2] = tx2
-        boxes[maxpos,3] = ty2
-        boxes[maxpos,4] = ts
-
-        tx1 = boxes[i,0]
-        ty1 = boxes[i,1]
-        tx2 = boxes[i,2]
-        ty2 = boxes[i,3]
-        ts = boxes[i,4]
-
-        pos = i + 1
-	# NMS iterations, note that N changes if detection boxes fall below threshold
-        while pos < N:
-            x1 = boxes[pos, 0]
-            y1 = boxes[pos, 1]
-            x2 = boxes[pos, 2]
-            y2 = boxes[pos, 3]
-            s = boxes[pos, 4]
-
-            area = (x2 - x1 + 1) * (y2 - y1 + 1)
-            iw = (min(tx2, x2) - max(tx1, x1) + 1)
-            if iw > 0:
-                ih = (min(ty2, y2) - max(ty1, y1) + 1)
-                if ih > 0:
-                    ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
-                    ov = iw * ih / ua #iou between max box and detection box
-
-                    if method == 1: # linear
-                        if ov > Nt:
-                            weight = 1 - ov
-                        else:
-                            weight = 1
-                    elif method == 2: # gaussian
-                        weight = np.exp(-(ov * ov)/sigma)
-                    else: # original NMS
-                        if ov > Nt:
-                            weight = 0
-                        else:
-                            weight = 1
-
-                    boxes[pos, 4] = weight*boxes[pos, 4]
-
-		    # if box score falls below threshold, discard the box by swapping with last box
-		    # update N
-                    if boxes[pos, 4] < threshold:
-                        boxes[pos,0] = boxes[N-1, 0]
-                        boxes[pos,1] = boxes[N-1, 1]
-                        boxes[pos,2] = boxes[N-1, 2]
-                        boxes[pos,3] = boxes[N-1, 3]
-                        boxes[pos,4] = boxes[N-1, 4]
-                        N = N - 1
-                        pos = pos - 1
-
-            pos = pos + 1
-
-    keep = [i for i in range(N)]
-    return keep

face_recognition1/face_detect/utils/nms/gpu_nms.hpp

@@ -1,2 +0,0 @@
-void _nms(int* keep_out, int* num_out, const float* boxes_host, int boxes_num,
-          int boxes_dim, float nms_overlap_thresh, int device_id);

face_recognition1/face_detect/utils/nms/gpu_nms.pyx

@@ -1,24 +0,0 @@
-import numpy as np
-cimport numpy as np
-
-assert sizeof(int) == sizeof(np.int32_t)
-
-cdef extern from "gpu_nms.hpp":
-    void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int)
-
-def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh,
-            np.int32_t device_id=0):
-    cdef int boxes_num = dets.shape[0]
-    cdef int boxes_dim = dets.shape[1]
-    cdef int num_out
-    cdef np.ndarray[np.int32_t, ndim=1] \
-        keep = np.zeros(boxes_num, dtype=np.int32)
-    cdef np.ndarray[np.float32_t, ndim=1] \
-        scores = dets[:, 4]
-    cdef np.ndarray[np.int_t, ndim=1] \
-        order = scores.argsort()[::-1]
-    cdef np.ndarray[np.float32_t, ndim=2] \
-        sorted_dets = dets[order, :]
-    _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id)
-    keep = keep[:num_out]
-    return list(order[keep])

face_recognition1/face_detect/utils/nms/nms_kernel.cu

@@ -1,144 +0,0 @@
-// ------------------------------------------------------------------
-// Faster R-CNN
-// Copyright (c) 2015 Microsoft
-// Licensed under The MIT License [see fast-rcnn/LICENSE for details]
-// Written by Shaoqing Ren
-// ------------------------------------------------------------------
-
-#include "gpu_nms.hpp"
-#include <vector>
-#include <iostream>
-
-#define CUDA_CHECK(condition) \
-  /* Code block avoids redefinition of cudaError_t error */ \
-  do { \
-    cudaError_t error = condition; \
-    if (error != cudaSuccess) { \
-      std::cout << cudaGetErrorString(error) << std::endl; \
-    } \
-  } while (0)
-
-#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0))
-int const threadsPerBlock = sizeof(unsigned long long) * 8;
-
-__device__ inline float devIoU(float const * const a, float const * const b) {
-  float left = max(a[0], b[0]), right = min(a[2], b[2]);
-  float top = max(a[1], b[1]), bottom = min(a[3], b[3]);
-  float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f);
-  float interS = width * height;
-  float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1);
-  float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1);
-  return interS / (Sa + Sb - interS);
-}
-
-__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh,
-                           const float *dev_boxes, unsigned long long *dev_mask) {
-  const int row_start = blockIdx.y;
-  const int col_start = blockIdx.x;
-
-  // if (row_start > col_start) return;
-
-  const int row_size =
-        min(n_boxes - row_start * threadsPerBlock, threadsPerBlock);
-  const int col_size =
-        min(n_boxes - col_start * threadsPerBlock, threadsPerBlock);
-
-  __shared__ float block_boxes[threadsPerBlock * 5];
-  if (threadIdx.x < col_size) {
-    block_boxes[threadIdx.x * 5 + 0] =
-        dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0];
-    block_boxes[threadIdx.x * 5 + 1] =
-        dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1];
-    block_boxes[threadIdx.x * 5 + 2] =
-        dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2];
-    block_boxes[threadIdx.x * 5 + 3] =
-        dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3];
-    block_boxes[threadIdx.x * 5 + 4] =
-        dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4];
-  }
-  __syncthreads();
-
-  if (threadIdx.x < row_size) {
-    const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x;
-    const float *cur_box = dev_boxes + cur_box_idx * 5;
-    int i = 0;
-    unsigned long long t = 0;
-    int start = 0;
-    if (row_start == col_start) {
-      start = threadIdx.x + 1;
-    }
-    for (i = start; i < col_size; i++) {
-      if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) {
-        t |= 1ULL << i;
-      }
-    }
-    const int col_blocks = DIVUP(n_boxes, threadsPerBlock);
-    dev_mask[cur_box_idx * col_blocks + col_start] = t;
-  }
-}
-
-void _set_device(int device_id) {
-  int current_device;
-  CUDA_CHECK(cudaGetDevice(&current_device));
-  if (current_device == device_id) {
-    return;
-  }
-  // The call to cudaSetDevice must come before any calls to Get, which
-  // may perform initialization using the GPU.
-  CUDA_CHECK(cudaSetDevice(device_id));
-}
-
-void _nms(int* keep_out, int* num_out, const float* boxes_host, int boxes_num,
-          int boxes_dim, float nms_overlap_thresh, int device_id) {
-  _set_device(device_id);
-
-  float* boxes_dev = NULL;
-  unsigned long long* mask_dev = NULL;
-
-  const int col_blocks = DIVUP(boxes_num, threadsPerBlock);
-
-  CUDA_CHECK(cudaMalloc(&boxes_dev,
-                        boxes_num * boxes_dim * sizeof(float)));
-  CUDA_CHECK(cudaMemcpy(boxes_dev,
-                        boxes_host,
-                        boxes_num * boxes_dim * sizeof(float),
-                        cudaMemcpyHostToDevice));
-
-  CUDA_CHECK(cudaMalloc(&mask_dev,
-                        boxes_num * col_blocks * sizeof(unsigned long long)));
-
-  dim3 blocks(DIVUP(boxes_num, threadsPerBlock),
-              DIVUP(boxes_num, threadsPerBlock));
-  dim3 threads(threadsPerBlock);
-  nms_kernel<<<blocks, threads>>>(boxes_num,
-                                  nms_overlap_thresh,
-                                  boxes_dev,
-                                  mask_dev);
-
-  std::vector<unsigned long long> mask_host(boxes_num * col_blocks);
-  CUDA_CHECK(cudaMemcpy(&mask_host[0],
-                        mask_dev,
-                        sizeof(unsigned long long) * boxes_num * col_blocks,
-                        cudaMemcpyDeviceToHost));
-
-  std::vector<unsigned long long> remv(col_blocks);
-  memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks);
-
-  int num_to_keep = 0;
-  for (int i = 0; i < boxes_num; i++) {
-    int nblock = i / threadsPerBlock;
-    int inblock = i % threadsPerBlock;
-
-    if (!(remv[nblock] & (1ULL << inblock))) {
-      keep_out[num_to_keep++] = i;
-      unsigned long long *p = &mask_host[0] + i * col_blocks;
-      for (int j = nblock; j < col_blocks; j++) {
-        remv[j] |= p[j];
-      }
-    }
-  }
-  *num_out = num_to_keep;
-
-  CUDA_CHECK(cudaFree(boxes_dev));
-  CUDA_CHECK(cudaFree(mask_dev));
-}

face_recognition1/face_detect/utils/nms/py_cpu_nms.py

@@ -1,32 +0,0 @@
-import numpy as np
-
-
-def py_cpu_nms(dets, thresh):
-    """Pure Python NMS baseline."""
-    x1 = dets[:, 0]
-    y1 = dets[:, 1]
-    x2 = dets[:, 2]
-    y2 = dets[:, 3]
-    scores = dets[:, 4]
-
-    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-    order = scores.argsort()[::-1]
-
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(i)
-        xx1 = np.maximum(x1[i], x1[order[1:]])
-        yy1 = np.maximum(y1[i], y1[order[1:]])
-        xx2 = np.minimum(x2[i], x2[order[1:]])
-        yy2 = np.minimum(y2[i], y2[order[1:]])
-
-        w = np.maximum(0.0, xx2 - xx1 + 1)
-        h = np.maximum(0.0, yy2 - yy1 + 1)
-        inter = w * h
-        ovr = inter / (areas[i] + areas[order[1:]] - inter)
-
-        inds = np.where(ovr <= thresh)[0]
-        order = order[inds + 1]
-
-    return keep

face_recognition1/face_detect/utils/nms_wrapper.py

@@ -1,29 +0,0 @@
-import os
-import sys
-sys.path.append(os.path.dirname(__file__))
-
-# from nms.cpu_nms import cpu_nms, cpu_soft_nms
-# from utils.nms.gpu_nms import gpu_nms
-from nms.py_cpu_nms import py_cpu_nms
-
-
-# def nms(dets, thresh, force_cpu=False):
-#     """Dispatch to either CPU or GPU NMS implementations."""
-#
-#     if dets.shape[0] == 0:
-#         return []
-#     if cfg.USE_GPU_NMS and not force_cpu:
-#         return gpu_nms(dets, thresh, device_id=cfg.GPU_ID)
-#     else:
-#         return cpu_nms(dets, thresh)
-
-
-def nms(dets, thresh, force_cpu=False):
-    """Dispatch to either CPU or GPU NMS implementations."""
-
-    if dets.shape[0] == 0:
-        return []
-    # if force_cpu:
-        #return cpu_soft_nms(dets, thresh, method = 0)
-    return py_cpu_nms(dets, thresh)
-    # return gpu_nms(dets, thresh)

face_recognition1/face_detect/utils/timer.py

@@ -1,33 +0,0 @@
-import time
-
-
-class Timer(object):
-    """A simple timer."""
-    def __init__(self):
-        self.total_time = 0.
-        self.calls = 0
-        self.start_time = 0.
-        self.diff = 0.
-        self.average_time = 0.
-
-    def tic(self):
-        # using time.time instead of time.clock because time time.clock
-        # does not normalize for multithreading
-        self.start_time = time.time()
-
-    def toc(self, average=True):
-        self.diff = time.time() - self.start_time
-        self.total_time += self.diff
-        self.calls += 1
-        self.average_time = self.total_time / self.calls
-        if average:
-            return self.average_time
-        else:
-            return self.diff
-
-    def clear(self):
-        self.total_time = 0.
-        self.calls = 0
-        self.start_time = 0.
-        self.diff = 0.
-        self.average_time = 0.

face_recognition1/face_feature/checkpoints/feat_net.ckpt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cbe719b05e516bfc7a3692f4edc448b4eac368e536676a2278cb4facafb8b3d0
-size 299884972

face_recognition1/face_feature/dataloader/__init__.py

@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: __init__.py.py
-@desc:
-'''

face_recognition1/face_feature/dataloader/agedb.py

@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: agedb.py.py
-@desc: AgeDB-30 test data loader, agedb test protocol is the same with lfw
-'''
-
-import os
-import numpy as np
-import cv2
-import torch.utils.data as data
-
-import torch
-import torchvision.transforms as transforms
-
-
-def img_loader(path):
-    try:
-        img = cv2.imread(path)
-        if len(img.shape) == 2:
-            img = np.stack([img] * 3, 2)
-        return img
-    except IOError:
-        print('Cannot load image ' + path)
-        return None
-
-
-class AgeDB30(data.Dataset):
-    def __init__(self, root, file_list, transform=None, loader=img_loader):
-        super().__init__()
-        self.root = root
-        self.file_list = file_list
-        self.transform = transform
-        self.loader = loader
-        self.nameLs = []
-        self.nameRs = []
-        self.folds = []
-        self.flags = []
-
-        with open(file_list) as f:
-            pairs = f.read().splitlines()
-        for i, p in enumerate(pairs):
-            p = p.split(' ')
-            nameL = p[0]
-            nameR = p[1]
-            fold = i // 600
-            flag = int(p[2])
-
-            self.nameLs.append(nameL)
-            self.nameRs.append(nameR)
-            self.folds.append(fold)
-            self.flags.append(flag)
-
-    def __getitem__(self, index):
-
-        img_l = self.loader(os.path.join(self.root, self.nameLs[index]))
-        img_r = self.loader(os.path.join(self.root, self.nameRs[index]))
-        imglist = [img_l, cv2.flip(img_l, 1), img_r, cv2.flip(img_r, 1)]
-
-        if self.transform is not None:
-            for _, i in enumerate(imglist):
-                imglist[i] = self.transform(imglist[i])
-
-            imgs = imglist
-            return imgs
-        else:
-            imgs = [torch.from_numpy(i) for i in imglist]
-            return imgs
-
-    def __len__(self):
-        return len(self.nameLs)
-
-
-if __name__ == '__main__':
-    root = '/media/sda/AgeDB-30/agedb30_align_112'
-    file_list = '/media/sda/AgeDB-30/agedb_30_pair.txt'
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-
-    dataset = AgeDB30(root, file_list, transform=transform)
-    trainloader = data.DataLoader(dataset, batch_size=64, shuffle=False, num_workers=2, drop_last=False)
-    for data in trainloader:
-        for d in data:
-            print(d[0].shape)

face_recognition1/face_feature/dataloader/casia_webface.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: casia_webface.py
-@desc: CASIA-WebFace dataloader loader
-'''
-
-import os
-import torch
-import torch.utils.data as data
-import torchvision.transforms as transforms
-import numpy as np
-import cv2
-
-
-def img_loader(path):
-    try:
-        img = cv2.imread(path)
-        if len(img.shape) == 2:
-            img = np.stack([img] * 3, 2)
-        return img
-    except IOError:
-        print('Cannot load image ' + path)
-        return None
-
-
-class CASIAWebFace(data.Dataset):
-    def __init__(self, root, file_list, transform=None, loader=img_loader):
-        super().__init__()
-        self.root = root
-        self.transform = transform
-        self.loader = loader
-
-        image_list = []
-        label_list = []
-        with open(file_list) as f:
-            img_label_list = f.read().splitlines()
-        for info in img_label_list:
-            image_path, label_name = info.split('  ')
-            image_list.append(image_path)
-            label_list.append(int(label_name))
-
-        self.image_list = image_list
-        self.label_list = label_list
-        self.class_nums = len(np.unique(self.label_list))
-        print("dataloader size: ", len(self.image_list), '/', self.class_nums)
-
-    def __getitem__(self, index):
-        img_path = self.image_list[index]
-        label = self.label_list[index]
-
-        img = self.loader(os.path.join(self.root, img_path))
-
-        # random flip with ratio of 0.5
-        flip = np.random.choice(2) * 2 - 1
-        if flip == 1:
-            img = cv2.flip(img, 1)
-
-        if self.transform is not None:
-            img = self.transform(img)
-        else:
-            img = torch.from_numpy(img)
-
-        return img, label
-
-    def __len__(self):
-        return len(self.image_list)
-
-
-class CASIAWebFaceDataset:
-    def __init__(self, root, file_list, loader=img_loader):
-        super().__init__()
-        self.root = root
-        self.loader = loader
-
-        image_list = []
-        label_list = []
-        with open(file_list) as f:
-            img_label_list = f.read().splitlines()
-        for i in range(0, len(img_label_list), 10):
-            info = img_label_list[i]
-            image_path, label_name = info.split('  ')
-            image_list.append(image_path)
-            label_list.append(int(label_name))
-
-        self.image_list = image_list
-        self.label_list = label_list
-        self.class_nums = len(np.unique(self.label_list))
-        print("dataloader size: ", len(self.image_list), '/', self.class_nums)
-
-    def __getitem__(self, index):
-        img_path = self.image_list[index]
-        label = self.label_list[index]
-
-        img = self.loader(os.path.join(self.root, img_path))
-
-        # random flip with ratio of 0.5
-        flip = np.random.choice(2) * 2 - 1
-        if flip == 1:
-            img = cv2.flip(img, 1)
-
-        img = img.astype(np.float32).transpose((2, 1, 0))
-        img = (img - 127.5) / 127.5
-
-        return img, label
-
-    def __len__(self):
-        return len(self.image_list)
-
-
-if __name__ == '__main__':
-    root = 'D:/data/webface_align_112'
-    file_list = 'D:/data/webface_align_train.list'
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-    dataset = CASIAWebFace(root, file_list, transform=transform)
-    trainloader = data.DataLoader(dataset, batch_size=64, shuffle=True, num_workers=2, drop_last=False)
-    print(len(dataset))
-    for data in trainloader:
-        print(data[0].shape)

face_recognition1/face_feature/dataloader/cfp.py

@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: cfp.py
-@desc: the CFP-FP test dataloader loader, it's similar with lfw and adedb, except that it has 700 pairs every fold
-'''
-
-
-import os
-import numpy as np
-import cv2
-import torch.utils.data as data
-import torch
-import torchvision.transforms as transforms
-
-
-def img_loader(path):
-    try:
-        img = cv2.imread(path)
-        if len(img.shape) == 2:
-            img = np.stack([img] * 3, 2)
-        return img
-    except IOError:
-        print('Cannot load image ' + path)
-        return None
-
-
-class CFP_FP(data.Dataset):
-    def __init__(self, root, file_list, transform=None, loader=img_loader):
-        super().__init__()
-        self.root = root
-        self.file_list = file_list
-        self.transform = transform
-        self.loader = loader
-        self.nameLs = []
-        self.nameRs = []
-        self.folds = []
-        self.flags = []
-
-        with open(file_list) as f:
-            pairs = f.read().splitlines()
-        for i, p in enumerate(pairs):
-            p = p.split(' ')
-            nameL = p[0]
-            nameR = p[1]
-            fold = i // 700
-            flag = int(p[2])
-
-            self.nameLs.append(nameL)
-            self.nameRs.append(nameR)
-            self.folds.append(fold)
-            self.flags.append(flag)
-
-    def __getitem__(self, index):
-
-        img_l = self.loader(os.path.join(self.root, self.nameLs[index]))
-        img_r = self.loader(os.path.join(self.root, self.nameRs[index]))
-        imglist = [img_l, cv2.flip(img_l, 1), img_r, cv2.flip(img_r, 1)]
-
-        if self.transform is not None:
-            for _, i in enumerate(imglist):
-                imglist[i] = self.transform(imglist[i])
-
-            imgs = imglist
-            return imgs
-        else:
-            imgs = [torch.from_numpy(i) for i in imglist]
-            return imgs
-
-    def __len__(self):
-        return len(self.nameLs)
-
-
-if __name__ == '__main__':
-    root = '/media/sda/CFP-FP/CFP_FP_aligned_112'
-    file_list = '/media/sda/CFP-FP/cfp-fp-pair.txt'
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-
-    dataset = CFP_FP(root, file_list, transform=transform)
-    trainloader = data.DataLoader(dataset, batch_size=64, shuffle=False, num_workers=2, drop_last=False)
-    for data in trainloader:
-        for d in data:
-            print(d[0].shape)

face_recognition1/face_feature/dataloader/lfw.py

@@ -1,141 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: lfw.py.py
-@desc: lfw dataloader loader
-'''
-
-import os
-import numpy as np
-import cv2
-import torch
-import torch.utils.data as data
-import torchvision.transforms as transforms
-
-
-def img_loader(path):
-    try:
-        img = cv2.imread(path)
-        if len(img.shape) == 2:
-            img = np.stack([img] * 3, 2)
-        return img
-    except IOError:
-        print('Cannot load image ' + path)
-        return None
-
-
-class LFW(data.Dataset):
-    def __init__(self, root, file_list, transform=None, loader=img_loader):
-        super().__init__()
-        self.root = root
-        self.file_list = file_list
-        self.transform = transform
-        self.loader = loader
-        self.nameLs = []
-        self.nameRs = []
-        self.folds = []
-        self.flags = []
-
-        with open(file_list) as f:
-            pairs = f.read().splitlines()[1:]
-        for i, p in enumerate(pairs):
-            p = p.split(' ')
-            nameL = p[0]
-            nameR = p[1]
-            fold = i // 600
-            flag = int(p[2])
-
-            self.nameLs.append(nameL)
-            self.nameRs.append(nameR)
-            self.folds.append(fold)
-            self.flags.append(flag)
-
-    def __getitem__(self, index):
-
-        img_l = self.loader(os.path.join(self.root, self.nameLs[index]))
-        img_r = self.loader(os.path.join(self.root, self.nameRs[index]))
-        imglist = [img_l, cv2.flip(img_l, 1), img_r, cv2.flip(img_r, 1)]
-
-        if self.transform is not None:
-            for _, i in enumerate(imglist):
-                imglist[i] = self.transform(imglist[i])
-
-            imgs = imglist
-            return imgs
-        else:
-            imgs = [torch.from_numpy(i) for i in imglist]
-            return imgs
-
-    def __len__(self):
-        return len(self.nameLs)
-
-
-class LFWDataset:
-    def __init__(self, root, file_list, loader=img_loader):
-        super().__init__()
-        self.root = root
-        self.file_list = file_list
-        self.loader = loader
-        self.nameLs = []
-        self.nameRs = []
-        self.folds = []
-        self.flags = []
-
-        with open(file_list) as f:
-            pairs = f.read().splitlines()[1:]
-        for i, p in enumerate(pairs):
-            p = p.split(' ')
-            nameL = p[0]
-            nameR = p[1]
-            fold = i // 600
-            flag = int(p[2])
-
-            self.nameLs.append(nameL)
-            self.nameRs.append(nameR)
-            self.folds.append(fold)
-            self.flags.append(flag)
-
-        self.idx = 0
-        self.len = len(self.nameLs)
-
-    def __next__(self, index):
-        if self.idx > self.len:
-            raise StopIteration
-
-        img_l = self.loader(os.path.join(self.root, self.nameLs[self.idx]))
-        img_r = self.loader(os.path.join(self.root, self.nameRs[self.idx]))
-        imglist = [img_l, cv2.flip(img_l, 1), img_r, cv2.flip(img_r, 1)]
-
-        outputs = []
-        image_mean = np.array([127.5, 127.5, 127.5])
-        for _, image in enumerate(imglist):
-            img = (image - image_mean) / 127.5
-            img = img.astype(np.float32).transpose((2, 0, 1))
-            img = np.expand_dims(img, axis=0)
-
-            outputs.append(img)
-
-        self.idx += 1
-        return outputs
-
-    def __iter__(self):
-        return self
-
-
-if __name__ == '__main__':
-    root = 'D:/data/lfw_align_112'
-    file_list = 'D:/data/pairs.txt'
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]+
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-
-    dataset = LFW(root, file_list, transform=transform)
-    #dataloader = LFW(root, file_list)
-    trainloader = data.DataLoader(dataset, batch_size=64, shuffle=False, num_workers=2, drop_last=False)
-    print(len(dataset))
-    for data in trainloader:
-        for d in data:
-            print(d[0].shape)

face_recognition1/face_feature/dataloader/lfw_2.py

@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: lfw_2.py
-@desc:  lfw dataloader from insightface ,just like agedb and cfp-fp
-'''
-
-import os
-
-import torch
-import torch.utils.data as data
-import torchvision.transforms as transforms
-import numpy as np
-import cv2
-
-
-def img_loader(path):
-    try:
-        img = cv2.imread(path)
-        if len(img.shape) == 2:
-            img = np.stack([img] * 3, 2)
-        return img
-    except IOError:
-        print('Cannot load image ' + path)
-        return None
-
-
-class LFW_2(data.Dataset):
-    def __init__(self, root, file_list, transform=None, loader=img_loader):
-        super().__init__()
-        self.root = root
-        self.file_list = file_list
-        self.transform = transform
-        self.loader = loader
-        self.nameLs = []
-        self.nameRs = []
-        self.folds = []
-        self.flags = []
-
-        with open(file_list) as f:
-            pairs = f.read().splitlines()
-        for i, p in enumerate(pairs):
-            p = p.split(' ')
-            nameL = p[0]
-            nameR = p[1]
-            fold = i // 600
-            flag = int(p[2])
-
-            self.nameLs.append(nameL)
-            self.nameRs.append(nameR)
-            self.folds.append(fold)
-            self.flags.append(flag)
-
-    def __getitem__(self, index):
-
-        img_l = self.loader(os.path.join(self.root, self.nameLs[index]))
-        img_r = self.loader(os.path.join(self.root, self.nameRs[index]))
-        imglist = [img_l, cv2.flip(img_l, 1), img_r, cv2.flip(img_r, 1)]
-
-        if self.transform is not None:
-            for _, i in enumerate(imglist):
-                imglist[i] = self.transform(imglist[i])
-
-            imgs = imglist
-            return imgs
-        else:
-            imgs = [torch.from_numpy(i) for i in imglist]
-            return imgs
-
-    def __len__(self):
-        return len(self.nameLs)
-
-
-if __name__ == '__main__':
-    root = '/media/sda/insightface_emore/lfw'
-    file_list = '/media/sda/insightface_emore/pair_lfw.txt'
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-
-    dataset = LFW_2(root, file_list, transform=transform)
-    trainloader = data.DataLoader(dataset, batch_size=64, shuffle=False, num_workers=2, drop_last=False)
-    for data in trainloader:
-        for d in data:
-            print(d[0].shape)

face_recognition1/face_feature/dataloader/megaface.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: megaface.py
-@desc:
-'''
-
-import os
-import numpy as np
-import cv2
-import torch
-import torch.utils.data as data
-import torchvision.transforms as transforms
-
-
-def img_loader(path):
-    try:
-        img = cv2.imread(path)
-        if len(img.shape) == 2:
-            img = np.stack([img] * 3, 2)
-        return img
-    except IOError:
-        print('Cannot load image ' + path)
-        return None
-
-
-class MegaFace(data.Dataset):
-    def __init__(self, facescrub_dir, megaface_dir, transform=None, loader=img_loader):
-        super().__init__()
-        self.transform = transform
-        self.loader = loader
-
-        test_image_file_list = []
-        print('Scanning files under facescrub and megaface...')
-        for root, _, files in os.walk(facescrub_dir):
-            for e in files:
-                filename = os.path.join(root, e)
-                ext = os.path.splitext(filename)[1].lower()
-                if ext in ('.png', '.bmp', '.jpg', '.jpeg'):
-                    test_image_file_list.append(filename)
-        for root, _, files in os.walk(megaface_dir):
-            for e in files:
-                filename = os.path.join(root, e)
-                ext = os.path.splitext(filename)[1].lower()
-                if ext in ('.png', '.bmp', '.jpg', '.jpeg'):
-                    test_image_file_list.append(filename)
-
-        self.image_list = test_image_file_list
-
-    def __getitem__(self, index):
-        img_path = self.image_list[index]
-        img = self.loader(img_path)
-
-        #水平翻转图像
-        #img = cv2.flip(img, 1)
-
-        if self.transform is not None:
-            img = self.transform(img)
-        else:
-            img = torch.from_numpy(img)
-
-        return img, img_path
-
-    def __len__(self):
-        return len(self.image_list)
-
-
-if __name__ == '__main__':
-    facescrub = '/media/sda/megaface_test_kit/facescrub_align_112/'
-    megaface = '/media/sda/megaface_test_kit/megaface_align_112/'
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-    dataset = MegaFace(facescrub, megaface, transform=transform)
-    trainloader = data.DataLoader(dataset, batch_size=64, shuffle=False, num_workers=2, drop_last=False)
-    print(len(dataset))
-    for data in trainloader:
-        print(data.shape)

face_recognition1/face_feature/datasets/prepare_dataset.py

@@ -1,111 +0,0 @@
-"""
-@author: MingDong
-@file: prepare_dataset.py
-@desc: merge the face align images (112x112)
-"""
-import sys
-
-import cv2
-
-sys.path.append('../..')
-
-import os
-import argparse
-from tqdm import tqdm
-from face_liveness.datasets.prepare_dataset import get_file_names
-from face_detect.test import get_bbox
-from face_pose.test import get_pose
-from feature_api import align
-
-parser = argparse.ArgumentParser(description='split or merge')
-parser.add_argument('--file_name', default='./glink360k/train.rec', help='source file name')
-parser.add_argument('--start_no', type=int, default=1, help='start number for merge')
-parser.add_argument('--end_no', type=int, default=34, help='end number for merge')
-parser.add_argument('--remove', default=False, help='Flag for Remove')
-parser.add_argument('--split_size', type=int, default=80000000, help='split file size')
-parser.add_argument('--db_path', default='/datasets/public2/upload/faces_emore_images', help='source file name')
-parser.add_argument('--label_file', default='/datasets/public2/upload/faces_emore/faces_emore.list', help='source file name')
-
-args = parser.parse_args()
-
-
-def merge_files(args):
-    """ merge the split files in Azure """
-    with open(args.file_name, 'ab') as f:
-        for i in range(args.start_no, args.end_no + 1):
-            fn = args.file_name + str(i) + '.rar'
-            with open(fn, 'rb') as chunk_file:
-                f.write(chunk_file.read())
-            if args.remove:
-                os.remove(fn)
-            print(fn)
-
-    print('ok')
-
-
-def split_files(args):
-    file_number = 1
-    with open(args.file_name, 'rb') as f:
-        chunk = f.read(args.split_size)
-        while chunk:
-            with open(args.file_name + str(file_number) + '.rar', 'wb') as chunk_file:
-                chunk_file.write(chunk)
-            file_number += 1
-            chunk = f.read(args.split_size)
-
-    print('ok')
-
-
-def generate_train_label_file(args):
-    label_list = []
-    file_list = get_file_names(args.db_path)
-    class_idx = -1
-    dir_list = []
-    for file_path in tqdm(file_list):
-        dirname = os.path.basename(os.path.dirname(file_path))
-        if dirname not in dir_list:
-            dir_list.append(dirname)
-            class_idx += 1
-
-        label_list.append(f'{file_path}  {class_idx}\n')
-
-    with open(args.label_file, 'w') as f:
-        f.writelines(label_list)
-
-
-def align_files(args):
-    """ align face images from the indian dataset and use it as the training dataset for feature extraction """
-    file_list = get_file_names(args.db_path)
-    for path in tqdm(file_list):
-        image = cv2.imread(path)
-
-        face_bbox = get_bbox(image)
-        if face_bbox is None:
-            continue
-
-        yaw, pitch, roll = get_pose(image, face_bbox)
-        if abs(yaw.item()) > 25 or abs(pitch.item()) > 25 or abs(roll.item()) > 25:
-            continue
-
-        face_image = align(image, output_size=(112, 112))
-        dst_path = path.replace('indian_images', 'indian_align_images')
-        if not os.path.exists(os.path.dirname(dst_path)):
-            os.makedirs(os.path.dirname(dst_path))
-
-        if face_image is not None:
-            cv2.imwrite(dst_path, face_image)
-
-
-def rename_umd(args):
-    """ rename folder name for umd dataset """
-    folders = os.listdir(args.db_path)
-    for folder in folders:
-        os.rename(os.path.join(args.db_path, folder), f'{args.db_path}/umd{folder}')
-
-
-if __name__ == '__main__':
-    # merge_files(args)
-    # split_files(args)
-    # align_files(args)
-    # generate_train_label_file(args)
-    rename_umd(args)

face_recognition1/face_feature/eval_agedb30.py

@@ -1,146 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: eval_agedb30.py
-@desc: The AgeDB-30 test protocol is same with LFW, so I just copy the code from eval_lfw.py
-'''
-
-
-import os
-import argparse
-import numpy as np
-import scipy.io
-import torch.utils.data
-import torchvision.transforms as transforms
-from torch.nn import DataParallel
-from model import mobilefacenet, cbam
-from dataloader.agedb import AgeDB30
-
-
-def getAccuracy(scores, flags, threshold):
-    p = np.sum(scores[flags == 1] > threshold)
-    n = np.sum(scores[flags == -1] < threshold)
-    return 1.0 * (p + n) / len(scores)
-
-def getThreshold(scores, flags, thrNum):
-    accuracys = np.zeros((2 * thrNum + 1, 1))
-    thresholds = np.arange(-thrNum, thrNum + 1) * 1.0 / thrNum
-    for i in range(2 * thrNum + 1):
-        accuracys[i] = getAccuracy(scores, flags, thresholds[i])
-    max_index = np.squeeze(accuracys == np.max(accuracys))
-    bestThreshold = np.mean(thresholds[max_index])
-    return bestThreshold
-
-def evaluation_10_fold(feature_path='./result/cur_epoch_agedb_result.mat'):
-    ACCs = np.zeros(10)
-    result = scipy.io.loadmat(feature_path)
-    for i in range(10):
-        fold = result['fold']
-        flags = result['flag']
-        featureLs = result['fl']
-        featureRs = result['fr']
-
-        valFold = fold != i
-        testFold = fold == i
-        flags = np.squeeze(flags)
-
-        mu = np.mean(np.concatenate((featureLs[valFold[0], :], featureRs[valFold[0], :]), 0), 0)
-        mu = np.expand_dims(mu, 0)
-        featureLs = featureLs - mu
-        featureRs = featureRs - mu
-        featureLs = featureLs / np.expand_dims(np.sqrt(np.sum(np.power(featureLs, 2), 1)), 1)
-        featureRs = featureRs / np.expand_dims(np.sqrt(np.sum(np.power(featureRs, 2), 1)), 1)
-
-        scores = np.sum(np.multiply(featureLs, featureRs), 1)
-        threshold = getThreshold(scores[valFold[0]], flags[valFold[0]], 10000)
-        ACCs[i] = getAccuracy(scores[testFold[0]], flags[testFold[0]], threshold)
-
-    return ACCs
-
-def loadModel(data_root, file_list, backbone_net, gpus='0', resume=None):
-
-    if backbone_net == 'MobileFace':
-        net = mobilefacenet.MobileFaceNet()
-    elif backbone_net == 'CBAM_50':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_50_SE':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir_se')
-    elif backbone_net == 'CBAM_100':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_100_SE':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir_se')
-    else:
-        print(backbone_net, ' is not available!')
-
-    # gpu init
-    multi_gpus = False
-    if len(gpus.split(',')) > 1:
-        multi_gpus = True
-    os.environ['CUDA_VISIBLE_DEVICES'] = gpus
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-    net.load_state_dict(torch.load(resume)['net_state_dict'])
-
-    if multi_gpus:
-        net = DataParallel(net).to(device)
-    else:
-        net = net.to(device)
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-    agedb_dataset = AgeDB30(data_root, file_list, transform=transform)
-    agedb_loader = torch.utils.data.DataLoader(agedb_dataset, batch_size=128,
-                                             shuffle=False, num_workers=2, drop_last=False)
-
-    return net.eval(), device, agedb_dataset, agedb_loader
-
-def getFeatureFromTorch(feature_save_dir, net, device, data_set, data_loader):
-    featureLs = None
-    featureRs = None
-    count = 0
-    for data in data_loader:
-        for _, i in enumerate(data):
-            data[i] = data[i].to(device)
-        count += data[0].size(0)
-        #print('extracing deep features from the face pair {}...'.format(count))
-        with torch.no_grad():
-            res = [net(d).data.cpu().numpy() for d in data]
-        featureL = np.concatenate((res[0], res[1]), 1)
-        featureR = np.concatenate((res[2], res[3]), 1)
-        # print(featureL.shape, featureR.shape)
-        if featureLs is None:
-            featureLs = featureL
-        else:
-            featureLs = np.concatenate((featureLs, featureL), 0)
-        if featureRs is None:
-            featureRs = featureR
-        else:
-            featureRs = np.concatenate((featureRs, featureR), 0)
-        # print(featureLs.shape, featureRs.shape)
-
-    result = {'fl': featureLs, 'fr': featureRs, 'fold': data_set.folds, 'flag': data_set.flags}
-    scipy.io.savemat(feature_save_dir, result)
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Testing')
-    parser.add_argument('--root', type=str, default='/media/sda/AgeDB-30/agedb30_align_112', help='The path of lfw data')
-    parser.add_argument('--file_list', type=str, default='/media/sda/AgeDB-30/agedb_30_pair.txt', help='The path of lfw data')
-    parser.add_argument('--resume', type=str, default='./model/SERES100_SERES100_IR_20190528_132635/Iter_342000_net.ckpt', help='The path pf save model')
-    parser.add_argument('--backbone_net', type=str, default='CBAM_100_SE', help='MobileFace, CBAM_50, CBAM_50_SE, CBAM_100, CBAM_100_SE')
-    parser.add_argument('--feature_dim', type=int, default=512, help='feature dimension')
-    parser.add_argument('--feature_save_path', type=str, default='./result/cur_epoch_agedb_result.mat',
-                        help='The path of the extract features save, must be .mat file')
-    parser.add_argument('--gpus', type=str, default='2,3', help='gpu list')
-    args = parser.parse_args()
-
-    net, device, agedb_dataset, agedb_loader = loadModel(args.root, args.file_list, args.backbone_net, args.gpus, args.resume)
-    getFeatureFromTorch(args.feature_save_path, net, device, agedb_dataset, agedb_loader)
-    ACCs = evaluation_10_fold(args.feature_save_path)
-    for _, i in enumerate(ACCs):
-        print(f'{i + 1}    {ACCs[i] * 100:.2f}')
-    print('--------')
-    print(f'AVE    {np.mean(ACCs) * 100:.4f}')

face_recognition1/face_feature/eval_cfp.py

@@ -1,143 +0,0 @@
-"""
-@author: MingDong
-@file: eval_cfp.py
-@desc: this code is very similar with eval_lfw.py and eval_agedb30.py
-"""
-import os
-import argparse
-import numpy as np
-import scipy.io
-import torch.utils.data
-import torchvision.transforms as transforms
-from torch.nn import DataParallel
-from model import mobilefacenet, cbam
-from dataloader.cfp import CFP_FP
-
-
-def getAccuracy(scores, flags, threshold):
-    p = np.sum(scores[flags == 1] > threshold)
-    n = np.sum(scores[flags == -1] < threshold)
-    return 1.0 * (p + n) / len(scores)
-
-
-def getThreshold(scores, flags, thrNum):
-    accuracys = np.zeros((2 * thrNum + 1, 1))
-    thresholds = np.arange(-thrNum, thrNum + 1) * 1.0 / thrNum
-    for i in range(2 * thrNum + 1):
-        accuracys[i] = getAccuracy(scores, flags, thresholds[i])
-    max_index = np.squeeze(accuracys == np.max(accuracys))
-    bestThreshold = np.mean(thresholds[max_index])
-    return bestThreshold
-
-def evaluation_10_fold(feature_path='./result/cur_epoch_cfp_result.mat'):
-    ACCs = np.zeros(10)
-    result = scipy.io.loadmat(feature_path)
-    for i in range(10):
-        fold = result['fold']
-        flags = result['flag']
-        featureLs = result['fl']
-        featureRs = result['fr']
-
-        valFold = fold != i
-        testFold = fold == i
-        flags = np.squeeze(flags)
-
-        mu = np.mean(np.concatenate((featureLs[valFold[0], :], featureRs[valFold[0], :]), 0), 0)
-        mu = np.expand_dims(mu, 0)
-        featureLs = featureLs - mu
-        featureRs = featureRs - mu
-        featureLs = featureLs / np.expand_dims(np.sqrt(np.sum(np.power(featureLs, 2), 1)), 1)
-        featureRs = featureRs / np.expand_dims(np.sqrt(np.sum(np.power(featureRs, 2), 1)), 1)
-
-        scores = np.sum(np.multiply(featureLs, featureRs), 1)
-        threshold = getThreshold(scores[valFold[0]], flags[valFold[0]], 10000)
-        ACCs[i] = getAccuracy(scores[testFold[0]], flags[testFold[0]], threshold)
-
-    return ACCs
-
-def loadModel(data_root, file_list, backbone_net, gpus='0', resume=None):
-
-    if backbone_net == 'MobileFace':
-        net = mobilefacenet.MobileFaceNet()
-    elif backbone_net == 'CBAM_50':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_50_SE':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir_se')
-    elif backbone_net == 'CBAM_100':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_100_SE':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir_se')
-    else:
-        print(backbone_net, ' is not available!')
-
-    # gpu init
-    multi_gpus = False
-    if len(gpus.split(',')) > 1:
-        multi_gpus = True
-    os.environ['CUDA_VISIBLE_DEVICES'] = gpus
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-    net.load_state_dict(torch.load(resume)['net_state_dict'])
-
-    if multi_gpus:
-        net = DataParallel(net).to(device)
-    else:
-        net = net.to(device)
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-    cfp_dataset = CFP_FP(data_root, file_list, transform=transform)
-    cfp_loader = torch.utils.data.DataLoader(cfp_dataset, batch_size=128,
-                                             shuffle=False, num_workers=4, drop_last=False)
-
-    return net.eval(), device, cfp_dataset, cfp_loader
-
-def getFeatureFromTorch(feature_save_dir, net, device, data_set, data_loader):
-    featureLs = None
-    featureRs = None
-    count = 0
-    for data in data_loader:
-        for _, i in enumerate(data):
-            data[i] = data[i].to(device)
-        count += data[0].size(0)
-        #print('extracing deep features from the face pair {}...'.format(count))
-        with torch.no_grad():
-            res = [net(d).data.cpu().numpy() for d in data]
-        featureL = np.concatenate((res[0], res[1]), 1)
-        featureR = np.concatenate((res[2], res[3]), 1)
-        # print(featureL.shape, featureR.shape)
-        if featureLs is None:
-            featureLs = featureL
-        else:
-            featureLs = np.concatenate((featureLs, featureL), 0)
-        if featureRs is None:
-            featureRs = featureR
-        else:
-            featureRs = np.concatenate((featureRs, featureR), 0)
-        # print(featureLs.shape, featureRs.shape)
-
-    result = {'fl': featureLs, 'fr': featureRs, 'fold': data_set.folds, 'flag': data_set.flags}
-    scipy.io.savemat(feature_save_dir, result)
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Testing')
-    parser.add_argument('--root', type=str, default='/media/sda/CFP-FP/cfp_fp_aligned_112', help='The path of lfw data')
-    parser.add_argument('--file_list', type=str, default='/media/sda/CFP-FP/cfp_fp_pair.txt', help='The path of lfw data')
-    parser.add_argument('--resume', type=str, default='./checkpoints/SERES100_SERES100_IR_20190528_132635/Iter_342000_net.ckpt', help='The path pf save checkpoints')
-    parser.add_argument('--backbone_net', type=str, default='CBAM_100_SE', help='MobileFace, CBAM_50, CBAM_50_SE, CBAM_100, CBAM_100_SE')
-    parser.add_argument('--feature_dim', type=int, default=512, help='feature dimension')
-    parser.add_argument('--feature_save_path', type=str, default='./result/cur_epoch_cfp_result.mat',
-                        help='The path of the extract features save, must be .mat file')
-    parser.add_argument('--gpus', type=str, default='2,3', help='gpu list')
-    args = parser.parse_args()
-
-    net, device, agedb_dataset, agedb_loader = loadModel(args.root, args.file_list, args.backbone_net, args.gpus, args.resume)
-    getFeatureFromTorch(args.feature_save_path, net, device, agedb_dataset, agedb_loader)
-    ACCs = evaluation_10_fold(args.feature_save_path)
-    for _, i in enumerate(ACCs):
-        print(f'{i + 1}    {ACCs[i] * 100:.2f}')
-    print('--------')
-    print(f'AVE    {np.mean(ACCs) * 100:.4f}')

face_recognition1/face_feature/eval_deepglint_merge.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-@author: MingDong
-@file: eval_deepglint_merge.py.py
-@desc: merge the feature of deepglint test data to one file. original deepglint feature is generated by the protocol of megaface.
-
-We use the same format as Megaface(http://megaface.cs.washington.edu)
-except that we merge all files into a single binary file.
-
-for examples:
-
-when megaface: N * (512, 1)
-while deepglint:(N, 512)
-
-"""
-import os
-import argparse
-import struct
-import numpy as np
-
-cv_type_to_dtype = {
-    5: np.dtype('float32')
-}
-
-dtype_to_cv_type = {v: k for k, v in cv_type_to_dtype.items()}
-
-
-def write_mat(f, m):
-    """Write mat m to file f"""
-    if len(m.shape) == 1:
-        rows = m.shape[0]
-        cols = 1
-    else:
-        rows, cols = m.shape
-    header = struct.pack('iiii', rows, cols, cols * 4, dtype_to_cv_type[m.dtype])
-    f.write(header)
-    f.write(m.data)
-
-
-def read_mat(f):
-    """
-    Reads an OpenCV mat from the given file opened in binary mode
-    """
-    rows, cols, stride, type_ = struct.unpack('iiii', f.read(4 * 4))
-    mat = np.fromstring(f.read(rows * stride), dtype=cv_type_to_dtype[type_])
-    return mat.reshape(rows, cols)
-
-
-def load_mat(filename):
-    """
-    Reads a OpenCV Mat from the given filename
-    """
-    return read_mat(open(filename, 'rb'))
-
-
-def save_mat(filename, m):
-    """Saves mat m to the given filename"""
-    return write_mat(open(filename, 'wb'), m)
-
-
-
-def main(args):
-
-    deepglint_features = args.deepglint_features_path
-    # merge all features into one file
-    total_feature = []
-    total_files = []
-    for root, _, files in os.walk(deepglint_features):
-        for file in files:
-            filename = os.path.join(root, file)
-            ext = os.path.splitext(filename)[1]
-            ext = ext.lower()
-            if ext in ('.feat'):
-                total_files.append(filename)
-
-    assert len(total_files) == 1862120
-    total_files.sort()  # important
-
-    for _, i in enumerate(total_files):
-        filename = total_files[i]
-        tmp_feature = load_mat(filename)
-        # print(filename)
-        # print(tmp_feature.shape)
-        tmp_feature = tmp_feature.T
-        total_feature.append(tmp_feature)
-        print(i + 1, tmp_feature.shape)
-        # write_mat(feature_path_out, feature_fusion)
-
-    print('total feature number: ', len(total_feature))
-    total_feature = np.array(total_feature).squeeze()
-    print(total_feature.shape, total_feature.dtype, type(total_feature))
-    save_mat('deepglint_test_feature.bin', total_feature)
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--deepglint_features_path", type=str, default="/home/mingdong/deepglint/deepglint_feature_ir+ws/")
-    args = parser.parse_args()
-
-    main(args)

face_recognition1/face_feature/eval_lfw.py

@@ -1,195 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-@author: MingDong
-@file: eval_lfw.py
-@desc:
-"""
-
-import os
-import argparse
-import numpy as np
-import scipy.io
-import onnxruntime as ort
-import torch.utils.data
-import torchvision.transforms as transforms
-from torch.nn import DataParallel
-from model import mobilefacenet, resnet, cbam
-from dataloader.lfw import LFW, LFWDataset
-
-
-def getAccuracy(scores, flags, threshold):
-    p = np.sum(scores[flags == 1] > threshold)
-    n = np.sum(scores[flags == -1] < threshold)
-    return 1.0 * (p + n) / len(scores)
-
-def getThreshold(scores, flags, thrNum):
-    accuracys = np.zeros((2 * thrNum + 1, 1))
-    thresholds = np.arange(-thrNum, thrNum + 1) * 1.0 / thrNum
-    for i in range(2 * thrNum + 1):
-        accuracys[i] = getAccuracy(scores, flags, thresholds[i])
-    max_index = np.squeeze(accuracys == np.max(accuracys))
-    bestThreshold = np.mean(thresholds[max_index])
-    return bestThreshold
-
-def evaluation_10_fold(feature_path='./result/cur_epoch_result.mat'):
-    ACCs = np.zeros(10)
-    result = scipy.io.loadmat(feature_path)
-    for i in range(10):
-        fold = result['fold']
-        flags = result['flag']
-        featureLs = result['fl']
-        featureRs = result['fr']
-
-        valFold = fold != i
-        testFold = fold == i
-        flags = np.squeeze(flags)
-
-        mu = np.mean(np.concatenate((featureLs[valFold[0], :], featureRs[valFold[0], :]), 0), 0)
-        mu = np.expand_dims(mu, 0)
-        featureLs = featureLs - mu
-        featureRs = featureRs - mu
-        featureLs = featureLs / np.expand_dims(np.sqrt(np.sum(np.power(featureLs, 2), 1)), 1)
-        featureRs = featureRs / np.expand_dims(np.sqrt(np.sum(np.power(featureRs, 2), 1)), 1)
-
-        scores = np.sum(np.multiply(featureLs, featureRs), 1)
-        threshold = getThreshold(scores[valFold[0]], flags[valFold[0]], 10000)
-        ACCs[i] = getAccuracy(scores[testFold[0]], flags[testFold[0]], threshold)
-
-    return ACCs
-
-
-def load_model(data_root, file_list, backbone_net, gpus='0', resume=None):
-
-    if backbone_net == 'MobileFace':
-        net = mobilefacenet.MobileFaceNet()
-    elif backbone_net == 'Res50':
-        net = resnet.ResNet50()
-    elif backbone_net == 'CBAM_50':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_50_SE':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir_se')
-    elif backbone_net == 'CBAM_100':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_100_SE':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir_se')
-    else:
-        print(backbone_net, ' is not available!')
-
-    # gpu init
-    multi_gpus = False
-    if len(gpus.split(',')) > 1:
-        multi_gpus = True
-    os.environ['CUDA_VISIBLE_DEVICES'] = gpus
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-    net.load_state_dict(torch.load(resume)['net_state_dict'])
-
-    if multi_gpus:
-        net = DataParallel(net).to(device)
-    else:
-        net = net.to(device)
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-    lfw_dataset = LFW(data_root, file_list, transform=transform)
-    lfw_loader = torch.utils.data.DataLoader(lfw_dataset, batch_size=128,
-                                             shuffle=False, num_workers=2, drop_last=False)
-
-    return net.eval(), device, lfw_dataset, lfw_loader
-
-
-def load_onnx_model(data_root, file_list):
-    ort_session = ort.InferenceSession('checkpoints/resnet50_Quant.onnx')
-
-    lfw_dataset = LFWDataset(data_root, file_list)
-
-    return ort_session, lfw_dataset
-
-
-def getFeatureFromTorch(feature_save_dir, net, device, data_set, data_loader):
-    featureLs = None
-    featureRs = None
-    count = 0
-    for data in data_loader:
-        for i, _ in enumerate(data):
-            data[i] = data[i].to(device)
-        count += data[0].size(0)
-        #print('extracing deep features from the face pair {}...'.format(count))
-        with torch.no_grad():
-            res = [net(d).data.cpu().numpy() for d in data]
-        featureL = np.concatenate((res[0], res[1]), 1)
-        featureR = np.concatenate((res[2], res[3]), 1)
-        # print(featureL.shape, featureR.shape)
-        if featureLs is None:
-            featureLs = featureL
-        else:
-            featureLs = np.concatenate((featureLs, featureL), 0)
-        if featureRs is None:
-            featureRs = featureR
-        else:
-            featureRs = np.concatenate((featureRs, featureR), 0)
-        # print(featureLs.shape, featureRs.shape)
-
-    result = {'fl': featureLs, 'fr': featureRs, 'fold': data_set.folds, 'flag': data_set.flags}
-    scipy.io.savemat(feature_save_dir, result)
-
-
-def getFeatureFromOnnx(feature_save_dir, net, data_set):
-    featureLs = None
-    featureRs = None
-    count = 0
-
-    for data in data_set:
-        res = []
-        for _, i in enumerate(data):
-            feat = net.run(None, {"input": data[i]})
-            res.append(feat)
-        count += data[0].size(0)
-
-        featureL = np.concatenate((res[0], res[1]), 1)
-        featureR = np.concatenate((res[2], res[3]), 1)
-        # print(featureL.shape, featureR.shape)
-        if featureLs is None:
-            featureLs = featureL
-        else:
-            featureLs = np.concatenate((featureLs, featureL), 0)
-        if featureRs is None:
-            featureRs = featureR
-        else:
-            featureRs = np.concatenate((featureRs, featureR), 0)
-        # print(featureLs.shape, featureRs.shape)
-
-    result = {'fl': featureLs, 'fr': featureRs, 'fold': data_set.folds, 'flag': data_set.flags}
-    scipy.io.savemat(feature_save_dir, result)
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Testing')
-    parser.add_argument('--root', type=str, default='/datasets/public1/upload/datasets/lfw', help='The path of lfw data')
-    parser.add_argument('--file_list', type=str, default='/datasets/public1/upload/datasets/lfw_pair.txt', help='The path of lfw data')
-    parser.add_argument('--backbone_net', type=str, default='Res50', help='MobileFace, Res50, CBAM_50, CBAM_50_SE, CBAM_100, CBAM_100_SE')
-    parser.add_argument('--feature_dim', type=int, default=512, help='feature dimension')
-    parser.add_argument('--resume', type=str, default='./checkpoints/Res50_RES50_20210711_091848/Iter_066000_net.ckpt',
-                        help='The path pf save checkpoints')
-    parser.add_argument('--feature_save_path', type=str, default='./result/cur_epoch_lfw_result.mat',
-                        help='The path of the extract features save, must be .mat file')
-    parser.add_argument('--gpus', type=str, default='0', help='gpu list')
-    args = parser.parse_args()
-
-    # inference by torch
-    # net, device, lfw_dataset, lfw_loader = load_model(args.root, args.file_list, args.backbone_net, args.gpus, args.resume)
-    # getFeatureFromTorch(args.feature_save_path, net, device, lfw_dataset, lfw_loader)
-    # ACCs = evaluation_10_fold(args.feature_save_path)
-
-    # inference by onnx
-    net, lfw_dataset = load_onnx_model(args.root, args.file_list)
-    getFeatureFromOnnx(args.feature_save_path, net, lfw_dataset)
-    ACCs = evaluation_10_fold(args.feature_save_path)
-
-    for _, i in enumerate(ACCs):
-        print(f'{i + 1}    {ACCs[i] * 100:.2f}')
-    print('--------')
-    print(f'AVE    {np.mean(ACCs) * 100:.4f}')

face_recognition1/face_feature/eval_lfw_blufr.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-@author: MingDong
-@file: eval_lfw_blufr.py
-@desc: test lfw accuracy on blufr protocol
-"""
-
-import argparse
-import scipy.io as sio
-
-def readName(file='pairs.txt'):
-    name_list = []
-    f = open(file, 'r')
-    lines = f.readlines()
-
-    for line in lines[1:]:
-        line_split = line.rstrip().split()
-        if len(line_split) == 3:
-            name_list.append(line_split[0])
-        elif len(line_split) == 4:
-            name_list.append(line_split[0])
-            name_list.append(line_split[2])
-        else:
-            print('wrong file, please check again')
-
-    return list(set(name_list))
-
-
-def main(args):
-    blufr_info = sio.loadmat(args.lfw_blufr_file)
-    #print(blufr_info)
-    name_list = readName()
-
-    image = blufr_info['imageList']
-    missing_files = []
-    for i in range(image.shape[0]):
-        name = image[i][0][0]
-        index = name.rfind('_')
-        name = name[0:index]
-        if name not in name_list:
-            print(name)
-            missing_files.append(name)
-    print('lfw pairs.txt total persons: ', len(name_list))
-    print('blufr_mat_missing persons: ', len(missing_files))
-
-    # Some of the missing file:
-    # Zdravko_Mucic
-    # Zelma_Novelo
-    # Zeng_Qinghong
-    # Zumrati_Juma
-    # lfw pairs.txt total persons:  4281
-    # blufr_mat_missing persons:  1549
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='lfw blufr test')
-    parser.add_argument('--lfw_blufr_file', type=str, default='./blufr_lfw_config.mat', help='feature dimension')
-    parser.add_argument('--lfw_pairs.txt', type=str, default='./pairs.txt', help='feature dimension')
-    parser.add_argument('--gpus', type=str, default='2,3', help='gpu list')
-    args = parser.parse_args()
-
-    main(args)

face_recognition1/face_feature/eval_megaface.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: eval_megaface.py
-@desc: megaface feature extractor
-'''
-import os
-import argparse
-import struct
-import numpy as np
-import torch.utils.data
-import torchvision.transforms as transforms
-from torch.nn import DataParallel
-from model import mobilefacenet, cbam
-from dataloader.megaface import MegaFace
-
-cv_type_to_dtype = {5: np.dtype('float32'), 6: np.dtype('float64')}
-dtype_to_cv_type = {v: k for k, v in cv_type_to_dtype.items()}
-
-
-def write_mat(filename, m):
-    """Write mat m to file f"""
-    if len(m.shape) == 1:
-        rows = m.shape[0]
-        cols = 1
-    else:
-        rows, cols = m.shape
-    header = struct.pack('iiii', rows, cols, cols * 4, dtype_to_cv_type[m.dtype])
-
-    with open(filename, 'wb') as outfile:
-        outfile.write(header)
-        outfile.write(m.data)
-
-
-def read_mat(filename):
-    """
-    Reads an OpenCV mat from the given file opened in binary mode
-    """
-    with open(filename, 'rb') as fin:
-        rows, cols, stride, type_ = struct.unpack('iiii', fin.read(4 * 4))
-        mat = np.fromstring(str(fin.read(rows * stride)), dtype=cv_type_to_dtype[type_])
-        return mat.reshape(rows, cols)
-
-
-def extract_feature(model_path, backbone_net, face_scrub_path, megaface_path, batch_size=32, gpus='0', do_norm=False):
-
-    if backbone_net == 'MobileFace':
-        net = mobilefacenet.MobileFaceNet()
-    elif backbone_net == 'CBAM_50':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_50_SE':
-        net = cbam.CBAMResNet(50, feature_dim=args.feature_dim, mode='ir_se')
-    elif backbone_net == 'CBAM_100':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir')
-    elif backbone_net == 'CBAM_100_SE':
-        net = cbam.CBAMResNet(100, feature_dim=args.feature_dim, mode='ir_se')
-    else:
-        print(args.backbone, ' is not available!')
-
-    multi_gpus = False
-    if len(gpus.split(',')) > 1:
-        multi_gpus = True
-    os.environ['CUDA_VISIBLE_DEVICES'] = gpus
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-    net.load_state_dict(torch.load(model_path)['net_state_dict'])
-    if multi_gpus:
-        net = DataParallel(net).to(device)
-    else:
-        net = net.to(device)
-    net.eval()
-
-    transform = transforms.Compose([
-        transforms.ToTensor(),  # range [0, 255] -> [0.0,1.0]
-        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))  # range [0.0, 1.0] -> [-1.0,1.0]
-    ])
-    megaface_dataset = MegaFace(face_scrub_path, megaface_path, transform=transform)
-    megaface_loader = torch.utils.data.DataLoader(megaface_dataset, batch_size=batch_size,
-                                             shuffle=False, num_workers=12, drop_last=False)
-
-    for data in megaface_loader:
-        img, img_path= data[0].to(device), data[1]
-        with torch.no_grad():
-            output = net(img).data.cpu().numpy()
-
-        if do_norm is False:
-            for _, i in enumerate(img_path):
-                abs_path = img_path[i] + '.feat'
-                write_mat(abs_path, output[i])
-            print('extract 1 batch...without feature normalization')
-        else:
-            for _, i in enumerate(img_path):
-                abs_path = img_path[i] + '.feat'
-                feat = output[i]
-                feat = feat / np.sqrt((np.dot(feat, feat)))
-                write_mat(abs_path, feat)
-            print('extract 1 batch...with feature normalization')
-    print('all images have been processed!')
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Testing')
-    parser.add_argument('--model_path', type=str, default='./checkpoints/RES100_RES100_IR_20190423_100728/Iter_333000_net.ckpt', help='The path of trained checkpoints')
-    parser.add_argument('--backbone_net', type=str, default='CBAM_100', help='MobileFace, CBAM_50, CBAM_50_SE, CBAM_100, CBAM_100_SE')
-    parser.add_argument('--facescrub_dir', type=str, default='/media/sda/megaface_test_kit/facescrub_align_112/', help='facescrub data')
-    parser.add_argument('--megaface_dir', type=str, default='/media/sda/megaface_test_kit/megaface_align_112/', help='megaface data')
-    parser.add_argument('--batch_size', type=int, default=1024, help='batch size')
-    parser.add_argument('--feature_dim', type=int, default=512, help='feature dimension')
-    parser.add_argument('--gpus', type=str, default='0,1,2,3', help='gpu list')
-    parser.add_argument("--do_norm", type=int, default=1, help="1 if normalize feature, 0 do nothing(Default case)")
-    args = parser.parse_args()
-
-    extract_feature(args.model_path, args.backbone_net, args.facescrub_dir, args.megaface_dir, args.batch_size, args.gpus, args.do_norm)

face_recognition1/face_feature/loss/__init__.py

@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: __init__.py.py
-@desc:
-'''

face_recognition1/face_feature/loss/agentcenterloss.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-'''
-@author: MingDong
-@file: agentcenterloss.py
-@desc: the variety of center loss, which use the class weight as the class center and normalize both the weight and feature,
-       in this way, the cos distance of weight and feature can be used as the supervised signal.
-       It's similar with torch.nn.CosineEmbeddingLoss, x_1 means weight_i, x_2 means feature_i.
-'''
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class AgentCenterLoss(nn.Module):
-
-    def __init__(self, num_classes, feat_dim, scale):
-        super(AgentCenterLoss, self).__init__()
-        self.num_classes = num_classes
-        self.feat_dim = feat_dim
-        self.scale = scale
-
-        self.centers = nn.Parameter(torch.randn(self.num_classes, self.feat_dim))
-
-    def forward(self, x, labels):
-        '''
-        Parameters:
-            x: input tensor with shape (batch_size, feat_dim)
-            labels: ground truth label with shape (batch_size)
-        Return:
-            loss of centers
-        '''
-        cos_dis = F.linear(F.normalize(x), F.normalize(self.centers)) * self.scale
-
-        one_hot = torch.zeros_like(cos_dis)
-        one_hot.scatter_(1, labels.view(-1, 1), 1.0)
-
-        # loss = 1 - cosine(i)
-        loss = one_hot * self.scale - (one_hot * cos_dis)
-
-        return loss.mean()