cross entropy for classification

Author: experiencor

callbacks.py

@@ -1,67 +1,36 @@
-from keras.callbacks import Callback
+from keras.callbacks import TensorBoard, ModelCheckpoint
+import tensorflow as tf
 import numpy as np
 
-class CustomModelCheckpoint(Callback):
-    """Save the model after every epoch.
-    `filepath` can contain named formatting options,
-    which will be filled the value of `epoch` and
-    keys in `logs` (passed in `on_epoch_end`).
-    For example: if `filepath` is `weights.{epoch:02d}-{val_loss:.2f}.hdf5`,
-    then the model checkpoints will be saved with the epoch number and
-    the validation loss in the filename.
-    # Arguments
-        filepath: string, path to save the model file.
-        monitor: quantity to monitor.
-        verbose: verbosity mode, 0 or 1.
-        save_best_only: if `save_best_only=True`,
-            the latest best model according to
-            the quantity monitored will not be overwritten.
-        mode: one of {auto, min, max}.
-            If `save_best_only=True`, the decision
-            to overwrite the current save file is made
-            based on either the maximization or the
-            minimization of the monitored quantity. For `val_acc`,
-            this should be `max`, for `val_loss` this should
-            be `min`, etc. In `auto` mode, the direction is
-            automatically inferred from the name of the monitored quantity.
-        save_weights_only: if True, then only the model's weights will be
-            saved (`model.save_weights(filepath)`), else the full model
-            is saved (`model.save(filepath)`).
-        period: Interval (number of epochs) between checkpoints.
-    """
+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)
 
-    def __init__(self, filepath, model_to_save, monitor='val_loss', verbose=0,
-                 save_best_only=False, save_weights_only=False,
-                 mode='auto', period=1):
-        super(CustomModelCheckpoint, self).__init__()
+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
-        self.monitor = monitor
-        self.verbose = verbose
-        self.filepath = filepath
-        self.save_best_only = save_best_only
-        self.save_weights_only = save_weights_only
-        self.period = period
-        self.epochs_since_last_save = 0
-
-        if mode not in ['auto', 'min', 'max']:
-            warnings.warn('ModelCheckpoint mode %s is unknown, '
-                          'fallback to auto mode.' % (mode),
-                          RuntimeWarning)
-            mode = 'auto'
-
-        if mode == 'min':
-            self.monitor_op = np.less
-            self.best = np.Inf
-        elif mode == 'max':
-            self.monitor_op = np.greater
-            self.best = -np.Inf
-        else:
-            if 'acc' in self.monitor or self.monitor.startswith('fmeasure'):
-                self.monitor_op = np.greater
-                self.best = -np.Inf
-            else:
-                self.monitor_op = np.less
-                self.best = np.Inf
 
     def on_epoch_end(self, epoch, logs=None):
         logs = logs or {}
@@ -96,4 +65,6 @@ def on_epoch_end(self, epoch, logs=None):
                 if self.save_weights_only:
                     self.model_to_save.save_weights(filepath, overwrite=True)
                 else:
-                    self.model_to_save.save(filepath, overwrite=True)
+                    self.model_to_save.save(filepath, overwrite=True)
+
+        super(CustomModelCheckpoint, self).on_batch_end(epoch, logs)

config.json

@@ -18,7 +18,12 @@
         "warmup_epochs":        3,
         "ignore_thresh":        0.5,
         "gpus":                 "0,1",
-        "scales":               [1,2,4],
+
+        "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",

predict.py

@@ -106,7 +106,7 @@ def _main_(args):
         else:
             image_paths += [input_path]
 
-        image_paths = [inp_file for inp_file in image_paths if (inp_file[-4:] == '.jpg' or inp_file == '.png')]
+        image_paths = [inp_file for inp_file in image_paths if (inp_file[-4:] in ['.jpg', '.png', 'JPEG'])]
 
         # the main loop
         for image_path in image_paths:

train.py

@@ -8,9 +8,9 @@
 from yolo import create_yolov3_model, dummy_loss
 from generator import BatchGenerator
 from utils.utils import normalize, evaluate, makedirs
-from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau, TensorBoard
+from keras.callbacks import EarlyStopping, ReduceLROnPlateau
 from keras.optimizers import Adam
-from callbacks import CustomModelCheckpoint
+from callbacks import CustomModelCheckpoint, CustomTensorBoard
 from utils.multi_gpu_model import multi_gpu_model
 import tensorflow as tf
 import keras
@@ -46,8 +46,8 @@ def create_training_instances(
     if len(labels) > 0:
         overlap_labels = set(labels).intersection(set(train_labels.keys()))
 
-        print('Seen labels: \t\t'  + str(train_labels) + '\n')
-        print('Given labels: \t\t' + str(labels))
+        print('Seen labels: \t'  + str(train_labels) + '\n')
+        print('Given labels: \t' + str(labels))
 
         # return None, None, None if some given label is not in the dataset
         if len(overlap_labels) < len(labels):
@@ -73,8 +73,8 @@ def create_callbacks(saved_weights_name, tensorboard_logs, model_to_save):
         verbose     = 1
     )
     checkpoint = CustomModelCheckpoint(
-        saved_weights_name,# + '{epoch:02d}.h5', 
         model_to_save   = model_to_save,
+        filepath        = saved_weights_name,# + '{epoch:02d}.h5', 
         monitor         = 'loss', 
         verbose         = 1, 
         save_best_only  = True, 
@@ -91,7 +91,7 @@ def create_callbacks(saved_weights_name, tensorboard_logs, model_to_save):
         cooldown = 0,
         min_lr   = 0
     )
-    tensorboard = TensorBoard(
+    tensorboard = CustomTensorBoard(
         log_dir                = tensorboard_logs,
         write_graph            = True,
         write_images           = True,
@@ -108,7 +108,11 @@ def create_model(
     multi_gpu, 
     saved_weights_name, 
     lr,
-    scales
+    grid_scales,
+    obj_scale,
+    noobj_scale,
+    xywh_scale,
+    class_scale  
 ):
     if multi_gpu > 1:
         with tf.device('/cpu:0'):
@@ -120,7 +124,11 @@ def create_model(
                 batch_size          = batch_size//multi_gpu, 
                 warmup_batches      = warmup_batches,
                 ignore_thresh       = ignore_thresh,
-                scales              = scales
+                grid_scales         = grid_scales,
+                obj_scale           = obj_scale,
+                noobj_scale         = noobj_scale,
+                xywh_scale          = xywh_scale,
+                class_scale         = class_scale
             )
     else:
         template_model, infer_model = create_yolov3_model(
@@ -131,8 +139,12 @@ def create_model(
             batch_size          = batch_size, 
             warmup_batches      = warmup_batches,
             ignore_thresh       = ignore_thresh,
-            scales              = scales
-        )        
+            grid_scales         = grid_scales,
+            obj_scale           = obj_scale,
+            noobj_scale         = noobj_scale,
+            xywh_scale          = xywh_scale,
+            class_scale         = class_scale
+        )  
 
     # load the pretrained weight if exists, otherwise load the backend weight only
     if os.path.exists(saved_weights_name): 
@@ -169,7 +181,7 @@ def _main_(args):
         config['valid']['cache_name'],
         config['model']['labels']
     )
-    print('\nTraining on the following labels: ' + str(labels))
+    print('\nTraining on: \t' + str(labels) + '\n')
 
     ###############################
     #   Create the generators 
@@ -223,7 +235,11 @@ def _main_(args):
         multi_gpu           = multi_gpu,
         saved_weights_name  = config['train']['saved_weights_name'],
         lr                  = config['train']['learning_rate'],
-        scales              = config['train']['scales'],
+        grid_scales         = config['train']['grid_scales'],
+        obj_scale           = config['train']['obj_scale'],
+        noobj_scale         = config['train']['noobj_scale'],
+        xywh_scale          = config['train']['xywh_scale'],
+        class_scale         = config['train']['class_scale'],
     )
 
     ###############################

utils/utils.py

@@ -175,8 +175,8 @@ def decode_netout(netout, anchors, obj_thresh, net_h, net_w):
     boxes = []
 
     netout[..., :2]  = _sigmoid(netout[..., :2])
-    netout[..., 4:]  = _sigmoid(netout[..., 4:])
-    netout[..., 5:]  = netout[..., 4][..., np.newaxis] * netout[..., 5:]
+    netout[..., 4]   = _sigmoid(netout[..., 4])
+    netout[..., 5:]  = netout[..., 4][..., np.newaxis] * _softmax(netout[..., 5:])
     netout[..., 5:] *= netout[..., 5:] > obj_thresh
 
     for i in range(grid_h*grid_w):
@@ -314,4 +314,10 @@ def compute_ap(recall, precision):
 
     # and sum (\Delta recall) * prec
     ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
-    return ap          
+    return ap     
+
+def _softmax(x, axis=-1):
+    x = x - np.amax(x, axis, keepdims=True)
+    e_x = np.exp(x)
+    
+    return e_x / e_x.sum(axis, keepdims=True)