build

Author: Shuvashish Chatterjee

.gitignore

@@ -32,6 +32,7 @@ wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+*.mp4
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Current File",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

.vscode/settings.json

@@ -1,3 +1,5 @@
 {
-    "python.pythonPath": "/anaconda3/bin/python"
+    "python.pythonPath": "C:\\ProgramData\\Anaconda3\\python.exe",
+    "python.linting.pylintEnabled": true,
+    "python.linting.enabled": true
 }

callbacks.py

@@ -0,0 +1,70 @@
+from keras.callbacks import TensorBoard, ModelCheckpoint
+import tensorflow as tf
+import numpy as np
+
+class CustomTensorBoard(TensorBoard):
+    """ to log the loss after each batch
+    """    
+    def __init__(self, log_every=1, **kwargs):
+        super(CustomTensorBoard, self).__init__(**kwargs)
+        self.log_every = log_every
+        self.counter = 0
+    
+    def on_batch_end(self, batch, logs=None):
+        self.counter+=1
+        if self.counter%self.log_every==0:
+            for name, value in logs.items():
+                if name in ['batch', 'size']:
+                    continue
+                summary = tf.Summary()
+                summary_value = summary.value.add()
+                summary_value.simple_value = value.item()
+                summary_value.tag = name
+                self.writer.add_summary(summary, self.counter)
+            self.writer.flush()
+        
+        super(CustomTensorBoard, self).on_batch_end(batch, logs)
+
+class CustomModelCheckpoint(ModelCheckpoint):
+    """ to save the template model, not the multi-GPU model
+    """
+    def __init__(self, model_to_save, **kwargs):
+        super(CustomModelCheckpoint, self).__init__(**kwargs)
+        self.model_to_save = model_to_save
+
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+        self.epochs_since_last_save += 1
+        if self.epochs_since_last_save >= self.period:
+            self.epochs_since_last_save = 0
+            filepath = self.filepath.format(epoch=epoch + 1, **logs)
+            if self.save_best_only:
+                current = logs.get(self.monitor)
+                if current is None:
+                    warnings.warn('Can save best model only with %s available, '
+                                  'skipping.' % (self.monitor), RuntimeWarning)
+                else:
+                    if self.monitor_op(current, self.best):
+                        if self.verbose > 0:
+                            print('\nEpoch %05d: %s improved from %0.5f to %0.5f,'
+                                  ' saving model to %s'
+                                  % (epoch + 1, self.monitor, self.best,
+                                     current, filepath))
+                        self.best = current
+                        if self.save_weights_only:
+                            self.model_to_save.save_weights(filepath, overwrite=True)
+                        else:
+                            self.model_to_save.save(filepath, overwrite=True)
+                    else:
+                        if self.verbose > 0:
+                            print('\nEpoch %05d: %s did not improve from %0.5f' %
+                                  (epoch + 1, self.monitor, self.best))
+            else:
+                if self.verbose > 0:
+                    print('\nEpoch %05d: saving model to %s' % (epoch + 1, filepath))
+                if self.save_weights_only:
+                    self.model_to_save.save_weights(filepath, overwrite=True)
+                else:
+                    self.model_to_save.save(filepath, overwrite=True)
+
+        super(CustomModelCheckpoint, self).on_batch_end(epoch, logs)

camera.py

@@ -16,7 +16,7 @@
 import numpy as np
 import pickle
 from pathlib import Path
-
+from datetime import datetime
 
 
 
@@ -28,7 +28,7 @@ class VIDEO :
         "save": False,
         "anotate": False,
         "save_path" :'./images/',
-        "path" : "./video/",
+        "path" : "./videos/VID_20190518_181206.mp4",
         "period" : 0.1
         }
 
@@ -46,22 +46,25 @@ def __init__(self, **kwargs):
     self.anotate : bool 
     self.fps : int
     self.path : str
-    self.video : cv2.VideoCapture
     self.__dict__.update(self._defaults) # set up default values
     self.__dict__.update(kwargs) # and update with user overrides
+    self.video = None 
+    self.fps =  int 
+    self.step =  int
+    # self.extract_frames()
+
+  def extract_frames(self):
     self.video =  cv2.VideoCapture(self.path) 
     self.fps =  self.video.get(cv2.CAP_PROP_FPS)
     self.step =  int(self.period* self.fps)
-
-  def extract_frames(self):
     count = 0
     success = 1
 
     while success: 
       success, image = self.video.read() 
-      if  count  % self.step == 0 :
-
-        count += 1
+      fn = int(datetime.utcnow().timestamp())
+      cv2.imwrite(self.save_path+str(fn)+".jpg",image)
+      count += 1
 
 
 
@@ -75,10 +78,10 @@ def __init__(self):
     self.img_size = None
     self.rvecs = None
     self.tvecs = None
-    self.callibrate()
+    # self.callibrate()
 
 
-  def callibrate(self , folder = 'camera_cal',n_x = 9, n_y = 6, verbose =   False):
+  def callibrate(self , folder = 'camera_cal',n_x = 7, n_y = 7, verbose =   False):
     objp = np.zeros((n_y*n_x, 3), np.float32)
     objp[:, :2] = np.mgrid[0:n_x, 0:n_y].T.reshape(-1, 2)
     image_points = []
@@ -87,6 +90,7 @@ def callibrate(self , folder = 'camera_cal',n_x = 9, n_y = 6, verbose =   False)
     directory =  Path(folder)
     for image_file in directory.glob("*.jpg"):
       img = cv2.imread(str( image_file))
+      img= cv2.resize(img, (400,300))
       img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
       found, corners = cv2.findChessboardCorners(img_gray, (n_x, n_y))
       if found:
@@ -117,4 +121,5 @@ def __init__(self):
     self.image_path : str
     self.type : int
     self.speed : float
-    self.coordinates : [float, float]
+    self.coordinates : [float, float]
+

config.json

@@ -0,0 +1,40 @@
+{
+    "model" : {
+        "min_input_size":       288,
+        "max_input_size":       448,
+        "anchors":              [55,69, 75,234, 133,240, 136,129, 142,363, 203,290, 228,184, 285,359, 341,260],
+        "labels":               ["kangaroo"]
+    },
+
+    "train": {
+        "train_image_folder":   "/home/andy/Desktop/github/kangaroo/images/",
+        "train_annot_folder":   "/home/andy/Desktop/github/kangaroo/annots/",
+        "cache_name":           "kangaroo_train.pkl",
+
+        "train_times":          8,
+        "batch_size":           16,
+        "learning_rate":        1e-4,
+        "nb_epochs":            100,
+        "warmup_epochs":        3,
+        "ignore_thresh":        0.5,
+        "gpus":                 "0,1",
+
+        "grid_scales":          [1,1,1],
+        "obj_scale":            5,
+        "noobj_scale":          1,
+        "xywh_scale":           1,
+        "class_scale":          1,
+
+        "tensorboard_dir":      "logs",
+        "saved_weights_name":   "kangaroo.h5",
+        "debug":                true
+    },
+
+    "valid": {
+        "valid_image_folder":   "",
+        "valid_annot_folder":   "",
+        "cache_name":           "",
+
+        "valid_times":          1
+    }
+}

evaluate.py

@@ -0,0 +1,68 @@
+#! /usr/bin/env python
+
+import argparse
+import os
+import numpy as np
+import json
+from voc import parse_voc_annotation
+from yolo import create_yolov3_model
+from generator import BatchGenerator
+from utils.utils import normalize, evaluate
+from keras.callbacks import EarlyStopping, ModelCheckpoint
+from keras.optimizers import Adam
+from keras.models import load_model
+
+def _main_(args):
+    config_path = args.conf
+
+    with open(config_path) as config_buffer:    
+        config = json.loads(config_buffer.read())
+
+    ###############################
+    #   Create the validation generator
+    ###############################  
+    valid_ints, labels = parse_voc_annotation(
+        config['valid']['valid_annot_folder'], 
+        config['valid']['valid_image_folder'], 
+        config['valid']['cache_name'],
+        config['model']['labels']
+    )
+
+    labels = labels.keys() if len(config['model']['labels']) == 0 else config['model']['labels']
+    labels = sorted(labels)
+   
+    valid_generator = BatchGenerator(
+        instances           = valid_ints, 
+        anchors             = config['model']['anchors'],   
+        labels              = labels,        
+        downsample          = 32, # ratio between network input's size and network output's size, 32 for YOLOv3
+        max_box_per_image   = 0,
+        batch_size          = config['train']['batch_size'],
+        min_net_size        = config['model']['min_input_size'],
+        max_net_size        = config['model']['max_input_size'],   
+        shuffle             = True, 
+        jitter              = 0.0, 
+        norm                = normalize
+    )
+
+    ###############################
+    #   Load the model and do evaluation
+    ###############################
+    os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
+
+    infer_model = load_model(config['train']['saved_weights_name'])
+
+    # compute mAP for all the classes
+    average_precisions = evaluate(infer_model, valid_generator)
+
+    # print the score
+    for label, average_precision in average_precisions.items():
+        print(labels[label] + ': {:.4f}'.format(average_precision))
+    print('mAP: {:.4f}'.format(sum(average_precisions.values()) / len(average_precisions)))           
+
+if __name__ == '__main__':
+    argparser = argparse.ArgumentParser(description='Evaluate YOLO_v3 model on any dataset')
+    argparser.add_argument('-c', '--conf', help='path to configuration file')    
+    
+    args = argparser.parse_args()
+    _main_(args)