get size from Model

* update CI
* allow GPU grows #11

Author: Borda

.codecov.yml

@@ -21,7 +21,7 @@ coverage:
     patch:
       default:
         against: auto
-        target: 40% # specify the target "X%" coverage to hit
+        target: 25% # specify the target "X%" coverage to hit
         # threshold: 50% # allow this much decrease on patch
     changes: false
 

.travis.yml

@@ -7,6 +7,8 @@ env:
   global:
     - DISPLAY=""
 
+cache: pip
+
 matrix:
   include:
 #    - python: 2.7
@@ -23,6 +25,6 @@ install:
   - pip install tox codecov
   - pip list
 
-script: tox
+script: tox --sitepackages
 
 after_success: codecov

README.md

@@ -45,13 +45,11 @@ For more model and configuration please see  [YOLO website](http://pjreddie.com/
        --path_weights ./model_data/yolo.h5 \
        --path_anchors ./model_data/yolo_anchors.csv \
        --path_classes ./model_data/coco_classes.txt \
-       --model_image_size 608 608 \
        --path_output ./results \
        --path_image ./model_data/bike-car-dog.jpg \
        --path_video person.mp4
     ```
     For Full YOLOv3, just do in a similar way, just specify model path and anchor path with `--path_weights <model_file>` and `--path_anchors <anchor_file>`.
-    Note `model_image_size` is depending on used model, see width and height in model config `*.cfg`. Expected values are ` 608 608` for full YOLO and and `416 416` for Tiny YOLO.
 4. MultiGPU usage: use `--nb_gpu N` to use N GPUs. It is passed to the Keras [multi_gpu_model()](https://keras.io/utils/#multi_gpu_model).
 
 ---
@@ -93,7 +91,14 @@ If you want to use original pre-trained weights for YOLOv3:
 1. The test environment is Python 3.x ; Keras 2.2.0 ; tensorflow 1.14.0
 2. Default anchors are used. If you use your own anchors, probably some changes are needed.
 3. The inference result is not totally the same as Darknet but the difference is small.
-4. The loaded model takes whole GPU memory.
-5. Always load pretrained weights and freeze layers in the first stage of training. Or try Darknet training. It's OK if there is a mismatch warning.
-6. The training strategy is for reference only. Adjust it according to your dataset and your goal. and add further strategy if needed.
-7. For speeding up the training process with frozen layers train_bottleneck.py can be used. It will compute the bottleneck features of the frozen model first and then only trains the last layers. This makes training on CPU possible in a reasonable time. See this [post](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html) for more information on bottleneck features.
+4. Always load pretrained weights and freeze layers in the first stage of training. Or try Darknet training. It's OK if there is a mismatch warning.
+5. The training strategy is for reference only. Adjust it according to your dataset and your goal. and add further strategy if needed.
+6. For speeding up the training process with frozen layers train_bottleneck.py can be used. It will compute the bottleneck features of the frozen model first and then only trains the last layers. This makes training on CPU possible in a reasonable time. See this [post](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html) for more information on bottleneck features.
+7. Failing while run multi-GPU training, think about porting to TF 2.0.
+
+---
+
+## Nice reading
+
+- [Building efficient data pipelines using TensorFlow](https://towardsdatascience.com/building-efficient-data-pipelines-using-tensorflow-8f647f03b4ce)
+- [How to use half precision float16 when training on RTX cards with Tensorflow / Keras](https://medium.com/@noel_kennedy/how-to-use-half-precision-float16-when-training-on-rtx-cards-with-tensorflow-keras-d4033d59f9e4)

appveyor.yml

@@ -12,10 +12,10 @@ environment:
     # a later point release.
     # See: http://www.appveyor.com/docs/installed-software#python
 
-    - PYTHON: "C:\\Python35-x64"
-      PYTHON_VERSION: "3.5.x"
-      PYTHON_ARCH: "64"
-      TOXENV: "py35"
+#    - PYTHON: "C:\\Python35-x64"
+#      PYTHON_VERSION: "3.5.x"
+#      PYTHON_ARCH: "64"
+#      TOXENV: "py35"
 
     - PYTHON: "C:\\Python36-x64"
       PYTHON_VERSION: "3.6.x"

circle.yml

@@ -1,35 +1,49 @@
 version: 2.0
 
+references:
+
+  install_deps: &install_deps
+    run:
+      name: Install Dependences
+      command: |
+        sudo apt-get update -qq
+        sudo apt-get install pkg-config python-dev python-tk
+        # PyPI
+        pip install -r requirements.txt --user
+        python --version ; pip --version ; pip list
+
 jobs:
-  Py35:
+
+  Py3-Tests:
     docker:
-      - image: circleci/python:3.5
-    steps: &steps
+      - image: circleci/python:3.6
+    steps:
       - checkout
-
-      - run:
-          name: Install Packages
-          command: |
-            sudo apt-get update
-            sudo apt-get install pkg-config python-dev python-tk
-
-      - run:
-          name: Install PyPI dependences
-          command: |
-            pip install -r requirements.txt --user
-            sudo pip install coverage pytest pytest-cov codecov
-            python --version ; pip --version ; pip list
+      - *install_deps
 
       - run:
           name: Testing
           command: |
             export DISPLAY=""
-            coverage run --source keras_yolo3 -m py.test keras_yolo3 scripts -v --doctest-modules --junitxml=test-reports/pytest_junit.xml
+            sudo pip install coverage pytest pytest-cov codecov pytest-flake8
+            coverage run --source keras_yolo3 -m py.test keras_yolo3 scripts -v --doctest-modules --junitxml=test-reports/pytest_junit.xml --flake8
             coverage report && coverage xml -o test-reports/coverage.xml
             codecov
 
+      - store_test_results:
+          path: test-reports
+      - store_artifacts:
+          path: test-reports
+
+  Py3-Sample:
+    docker:
+      - image: circleci/python:3.6
+    steps:
+      - checkout
+      - *install_deps
+
       - run:
-          name: Sample Detection
+          name: Pre-trained Detection
           command: |
             export DISPLAY=""
             # download and conver weights
@@ -39,7 +53,7 @@ jobs:
             # download sample video
             wget -O ./results/volleyball.mp4  https://d2v9y0dukr6mq2.cloudfront.net/video/preview/UnK3Qzg/crowds-of-poeple-hot-summer-day-at-wasaga-beach-ontario-canada-during-heatwave_n2t3d8trl__SB_PM.mp4
             # run sample detections
-            python ./scripts/detection.py -w ./model_data/tiny-yolo.h5 -a ./model_data/tiny-yolo_anchors.csv --model_image_size 416 416 -c ./model_data/coco_classes.txt -o ./results -i ./model_data/bike-car-dog.jpg -v ./results/volleyball.mp4
+            python ./scripts/detection.py -w ./model_data/tiny-yolo.h5 -a ./model_data/tiny-yolo_anchors.csv -c ./model_data/coco_classes.txt -o ./results -i ./model_data/bike-car-dog.jpg -v ./results/volleyball.mp4
             ls -l results/*
             cat ./results/bike-car-dog.csv
 
@@ -60,22 +74,12 @@ jobs:
             cat ./model_data/train_tiny-yolo_test.yaml
             python ./scripts/training.py --path_dataset ./model_data/VOC_2007_val.txt --path_weights ./model_data/tiny-yolo.h5 --path_anchors ./model_data/tiny-yolo_anchors.csv --path_classes ./model_data/voc_classes.txt --path_output ./model_data --path_config ./model_data/train_tiny-yolo_test.yaml
             # use the train model
-            python ./scripts/detection.py -w ./model_data/tiny-yolo_weights_full.h5 -a ./model_data/tiny-yolo_anchors.csv --model_image_size 416 416 -c ./model_data/voc_classes.txt -o ./results -i ./model_data/bike-car-dog.jpg
+            python ./scripts/detection.py -w ./model_data/tiny-yolo_weights_full.h5 -a ./model_data/tiny-yolo_anchors.csv -c ./model_data/voc_classes.txt -o ./results -i ./model_data/bike-car-dog.jpg
             ls -l results/*
 
-      - store_test_results:
-          path: test-reports
-      - store_artifacts:
-          path: test-reports
-
-  Py36:
-    docker:
-      - image: circleci/python:3.6
-    steps: *steps
-
 workflows:
   version: 2
   build:
     jobs:
-      - Py35
-      - Py36
+      - Py3-Tests
+      - Py3-Sample

keras_yolo3/model.py

@@ -413,8 +413,8 @@ def create_model(input_shape, anchors, num_classes, weights_path=None, model_fac
         os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
 
     # K.clear_session()  # get a new session
-    image_input = Input(shape=(None, None, 3))
-    h, w = input_shape
+    cnn_h, cnn_w = input_shape
+    image_input = Input(shape=(cnn_h, cnn_w, 3))
     num_anchors = len(anchors)
 
     model_body = _FACTOR_YOLO_BODY[model_factor](image_input, num_anchors // model_factor, num_classes)
@@ -437,8 +437,8 @@ def create_model(input_shape, anchors, num_classes, weights_path=None, model_fac
 
     model_loss_fn = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss',
                            arguments=_LOSS_ARGUMENTS)
-    y_true = [Input(shape=(h // {i: _INPUT_SHAPES[i] for i in range(model_factor)}[l],
-                           w // {i: _INPUT_SHAPES[i] for i in range(model_factor)}[l],
+    y_true = [Input(shape=(cnn_h // {i: _INPUT_SHAPES[i] for i in range(model_factor)}[l],
+                           cnn_w // {i: _INPUT_SHAPES[i] for i in range(model_factor)}[l],
                            num_anchors // model_factor,
                            num_classes + 5))
               for l in range(model_factor)]
@@ -465,12 +465,12 @@ def create_model_bottleneck(input_shape, anchors, num_classes, freeze_body=2,
                             weights_path=None, nb_gpu=1):
     """create the training model"""
     # K.clear_session()  # get a new session
-    image_input = Input(shape=(None, None, 3))
-    h, w = input_shape
+    cnn_h, cnn_w = input_shape
+    image_input = Input(shape=(cnn_w, cnn_h, 3))
     num_anchors = len(anchors)
 
-    y_true = [Input(shape=(h // {0: 32, 1: 16, 2: 8}[l],
-                           w // {0: 32, 1: 16, 2: 8}[l],
+    y_true = [Input(shape=(cnn_h // {0: 32, 1: 16, 2: 8}[l],
+                           cnn_w // {0: 32, 1: 16, 2: 8}[l],
                            num_anchors // 3,
                            num_classes + 5))
               for l in range(3)]

keras_yolo3/yolo.py

@@ -49,7 +49,7 @@ class YOLO(object):
         "classes_path": os.path.join(update_path('model_data'), 'coco_classes.txt'),
         "score": 0.3,
         "iou": 0.45,
-        "model_image_size": (416, 416),
+        # "model_image_size": (416, 416),
         "nb_gpu": 1,
     }
 
@@ -78,35 +78,35 @@ def __init__(self, weights_path, anchors_path, classes_path, model_image_size=(N
         self.classes_path = update_path(classes_path)
         self.score = score
         self.iou = iou
-        self.model_image_size = model_image_size
+
         self.nb_gpu = nb_gpu
         if not self.nb_gpu:
             # disable all GPUs
             os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
         self.class_names = get_class_names(self.classes_path)
         self.anchors = get_anchors(self.anchors_path)
         self._open_session()
-        self.boxes, self.scores, self.classes = self._create_model()
+        self.boxes, self.scores, self.classes = self._create_model(model_image_size)
+
         self._generate_class_colors()
 
     def _open_session(self):
-        if K.backend() == 'tensorflow':
+        if K.backend().lower() == 'tensorflow':
             import tensorflow as tf
-            from keras.backend.tensorflow_backend import set_session
-
             config = tf.ConfigProto(allow_soft_placement=True,
                                     log_device_placement=False)
             config.gpu_options.force_gpu_compatible = True
-            # config.gpu_options.per_process_gpu_memory_fraction = 0.5
+            # config.gpu_options.per_process_gpu_memory_fraction = 0.3
             # Don't pre-allocate memory; allocate as-needed
             config.gpu_options.allow_growth = True
+            self.sess = tf.Session(config=config)
+            K.tensorflow_backend.set_session(self.sess)
+        else:
+            logging.warning('Using %s backend.', K.backend())
+            self.sess = K.get_session()
 
-            sess = tf.Session(config=config)
-            set_session(sess)
-
-        self.sess = K.get_session()
-
-    def _create_model(self):
+    def _create_model(self, model_image_size=(None, None)):
         # weights_path = update_path(self.weights_path)
         logging.debug('loading model from "%s"', self.weights_path)
         assert self.weights_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
@@ -119,12 +119,12 @@ def _create_model(self):
         except Exception:
             is_tiny_version = (num_anchors == 6)  # default setting
             logging.exception('Loading weights from "%s"', self.weights_path)
+            cnn_h, cnn_w = model_image_size
+            input = Input(shape=(cnn_h, cnn_w, 3))
             if is_tiny_version:
-                self.yolo_model = yolo_body_tiny(Input(shape=(None, None, 3)),
-                                                 num_anchors // 2, num_classes)
+                self.yolo_model = yolo_body_tiny(input, num_anchors // 2, num_classes)
             else:
-                self.yolo_model = yolo_body_full(Input(shape=(None, None, 3)),
-                                                 num_anchors // 3, num_classes)
+                self.yolo_model = yolo_body_full(input, num_anchors // 3, num_classes)
             # make sure model, anchors and classes match
             self.yolo_model.load_weights(self.weights_path, by_name=True, skip_mismatch=True)
         else:
@@ -164,11 +164,13 @@ def _generate_class_colors(self):
 
     def detect_image(self, image):
         start = time.time()
+        # this should be taken from the model
+        model_image_size = self.yolo_model._input_layers[0].input_shape[1:3]
 
-        if isinstance(self.model_image_size, (list, tuple, set)) and all(self.model_image_size):
-            assert self.model_image_size[0] % 32 == 0, 'Multiples of 32 required'
-            assert self.model_image_size[1] % 32 == 0, 'Multiples of 32 required'
-            boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))
+        if all(model_image_size):
+            for size in model_image_size:
+                assert size % 32 == 0, 'Multiples of 32 required'
+            boxed_image = letterbox_image(image, tuple(reversed(model_image_size)))
         else:
             new_image_size = (image.width - (image.width % 32),
                               image.height - (image.height % 32))

model_data/train_yolo.yaml

@@ -1,9 +1,9 @@
 image-size: [608, 608]
 batch-size:
   bottlenecks: 8
-  head: 8
+  head: 4
   # the unfreeze model takes more memory
-  full: 4
+  full: 2
 epochs:
   bottlenecks: 25
   head: 50

scripts/convert_weights.py

@@ -263,12 +263,14 @@ def _main(config_path, weights_path, output_path, weights_only, plot_model):
     cfg_parser.read_file(unique_config_file)
 
     logging.info('Creating Keras model.')
-    input_layer = Input(shape=(None, None, 3))
+    cnn_w = int(cfg_parser['net_0']['width'])
+    cnn_h = int(cfg_parser['net_0']['height'])
+    input_layer = Input(shape=(cnn_h, cnn_w, 3))
     prev_layer = input_layer
     all_layers = []
 
-    weight_decay = float(cfg_parser['net_0']['decay']
-                         ) if 'net_0' in cfg_parser.sections() else 5e-4
+    weight_decay = float(cfg_parser['net_0']['decay']) \
+        if 'net_0' in cfg_parser.sections() else 5e-4
     count = 0
     out_index = []
     for section in tqdm.tqdm(cfg_parser.sections()):

scripts/detect_interactive.py

@@ -62,12 +62,11 @@ def loop_detect_stream(yolo, path_output=None):
         predict_video(yolo, vid_path, path_output, show_stream=True)
 
 
-def _main(path_weights, path_anchors, model_image_size, path_classes, nb_gpu,
+def _main(path_weights, path_anchors, path_classes, nb_gpu,
           path_output=None, images=False, videos=False, stream=False):
     assert any([images, videos, stream]), 'nothing to do...'
 
-    yolo = YOLO(path_weights, path_anchors, path_classes, model_image_size,
-                nb_gpu=nb_gpu)
+    yolo = YOLO(path_weights, path_anchors, path_classes, nb_gpu=nb_gpu)
 
     if images:
         # Image detection mode, disregard any remaining command line arguments