This is the data and progam for Human Detection

checkpoint

@@ -0,0 +1,2 @@
+model_checkpoint_path: "model.ckpt"
+all_model_checkpoint_paths: "model.ckpt"

detection.py

@@ -0,0 +1,90 @@
+
+import numpy as np
+import tensorflow as tf
+import cv2
+import time
+import msvcrt
+
+
+video='TownCentreXVID.avi'
+
+class DetectorAPI:
+    def __init__(self, path_to_ckpt):
+        self.path_to_ckpt = path_to_ckpt
+
+        self.detection_graph = tf.Graph()
+        with self.detection_graph.as_default():
+            od_graph_def = tf.compat.v1.GraphDef()
+            with tf.io.gfile.GFile(self.path_to_ckpt, 'rb') as fid:
+                serialized_graph = fid.read()
+                od_graph_def.ParseFromString(serialized_graph)
+                tf.import_graph_def(od_graph_def, name='')
+
+        self.default_graph = self.detection_graph.as_default()
+        self.sess = tf.compat.v1.Session(graph=self.detection_graph)
+
+        # Definite input and output Tensors for detection_graph
+        self.image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')
+        # Each box represents a part of the image where a particular object was detected.
+        self.detection_boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')
+        # Each score represent how level of confidence for each of the objects.
+        # Score is shown on the result image, together with the class label.
+        self.detection_scores = self.detection_graph.get_tensor_by_name('detection_scores:0')
+        self.detection_classes = self.detection_graph.get_tensor_by_name('detection_classes:0')
+        self.num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')
+
+    def processFrame(self, image):
+        # Expand dimensions since the trained_model expects images to have shape: [1, None, None, 3]
+        image_np_expanded = np.expand_dims(image, axis=0)
+        # Actual detection.
+        start_time = time.time()
+        (boxes, scores, classes, num) = self.sess.run(
+            [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],
+            feed_dict={self.image_tensor: image_np_expanded})
+        end_time = time.time()
+
+        #print("Elapsed Time:", end_time-start_time)
+
+        im_height, im_width,_ = image.shape
+        boxes_list = [None for i in range(boxes.shape[1])]
+        for i in range(boxes.shape[1]):
+            boxes_list[i] = (int(boxes[0,i,0] * im_height),
+                        int(boxes[0,i,1]*im_width),
+                        int(boxes[0,i,2] * im_height),
+                        int(boxes[0,i,3]*im_width))
+
+        return boxes_list, scores[0].tolist(), [int(x) for x in classes[0].tolist()], int(num[0])
+
+    def close(self):
+        self.sess.close()
+        self.default_graph.close()
+
+if __name__ == "__main__":
+    model_path = 'frozen_inference_graph.pb'
+    odapi = DetectorAPI(path_to_ckpt=model_path)
+    threshold = 0.7
+    cap = cv2.VideoCapture(video)
+    print("Press ESC key to exit the program ")
+    while True:
+        r, img = cap.read()
+        img = cv2.resize(img, (1280, 720))
+
+        boxes, scores, classes, num = odapi.processFrame(img)
+        # Visualization of the results of a detection.
+        count=0
+        for i in range(len(boxes)):
+            # Class 1 represents human
+            if classes[i] == 1 and scores[i] > threshold:
+                box = boxes[i]
+                cv2.rectangle(img,(box[1],box[0]),(box[3],box[2]),(255,0,255),2)
+                count+=1
+        print("NO of Humans are",count)
+
+        cv2.imshow("preview", img)
+        if cv2.waitKey(10) & 0xff==ord('q'):
+            break
+
+
+    cv2.destroyAllWindows()
+    cap.release()
+    print("BYEBYE")

pipeline.config

@@ -0,0 +1,134 @@
+model {
+  faster_rcnn {
+    num_classes: 90
+    image_resizer {
+      keep_aspect_ratio_resizer {
+        min_dimension: 600
+        max_dimension: 1024
+      }
+    }
+    feature_extractor {
+      type: "faster_rcnn_inception_v2"
+      first_stage_features_stride: 16
+    }
+    first_stage_anchor_generator {
+      grid_anchor_generator {
+        height_stride: 16
+        width_stride: 16
+        scales: 0.25
+        scales: 0.5
+        scales: 1.0
+        scales: 2.0
+        aspect_ratios: 0.5
+        aspect_ratios: 1.0
+        aspect_ratios: 2.0
+      }
+    }
+    first_stage_box_predictor_conv_hyperparams {
+      op: CONV
+      regularizer {
+        l2_regularizer {
+          weight: 0.0
+        }
+      }
+      initializer {
+        truncated_normal_initializer {
+          stddev: 0.00999999977648
+        }
+      }
+    }
+    first_stage_nms_score_threshold: 0.0
+    first_stage_nms_iou_threshold: 0.699999988079
+    first_stage_max_proposals: 100
+    first_stage_localization_loss_weight: 2.0
+    first_stage_objectness_loss_weight: 1.0
+    initial_crop_size: 14
+    maxpool_kernel_size: 2
+    maxpool_stride: 2
+    second_stage_box_predictor {
+      mask_rcnn_box_predictor {
+        fc_hyperparams {
+          op: FC
+          regularizer {
+            l2_regularizer {
+              weight: 0.0
+            }
+          }
+          initializer {
+            variance_scaling_initializer {
+              factor: 1.0
+              uniform: true
+              mode: FAN_AVG
+            }
+          }
+        }
+        use_dropout: false
+        dropout_keep_probability: 1.0
+      }
+    }
+    second_stage_post_processing {
+      batch_non_max_suppression {
+        score_threshold: 0.300000011921
+        iou_threshold: 0.600000023842
+        max_detections_per_class: 100
+        max_total_detections: 100
+      }
+      score_converter: SOFTMAX
+    }
+    second_stage_localization_loss_weight: 2.0
+    second_stage_classification_loss_weight: 1.0
+  }
+}
+train_config {
+  batch_size: 1
+  data_augmentation_options {
+    random_horizontal_flip {
+    }
+  }
+  optimizer {
+    momentum_optimizer {
+      learning_rate {
+        manual_step_learning_rate {
+          initial_learning_rate: 0.000199999994948
+          schedule {
+            step: 0
+            learning_rate: 0.000199999994948
+          }
+          schedule {
+            step: 900000
+            learning_rate: 1.99999994948e-05
+          }
+          schedule {
+            step: 1200000
+            learning_rate: 1.99999999495e-06
+          }
+        }
+      }
+      momentum_optimizer_value: 0.899999976158
+    }
+    use_moving_average: false
+  }
+  gradient_clipping_by_norm: 10.0
+  fine_tune_checkpoint: "PATH_TO_BE_CONFIGURED/model.ckpt"
+  from_detection_checkpoint: true
+  num_steps: 200000
+}
+train_input_reader {
+  label_map_path: "PATH_TO_BE_CONFIGURED/mscoco_label_map.pbtxt"
+  tf_record_input_reader {
+    input_path: "PATH_TO_BE_CONFIGURED/mscoco_train.record"
+  }
+}
+eval_config {
+  num_examples: 8000
+  max_evals: 10
+  use_moving_averages: false
+}
+eval_input_reader {
+  label_map_path: "PATH_TO_BE_CONFIGURED/mscoco_label_map.pbtxt"
+  shuffle: false
+  num_readers: 1
+  tf_record_input_reader {
+    input_path: "PATH_TO_BE_CONFIGURED/mscoco_val.record"
+  }
+}